1  import { EVENT_ID, EVENT_UUID, TRAVEL_ID, USER, USER_ID } from "../constants";
  2  import { PassengerInput } from "../graphql";
  3  import { sdk } from "../lib/gqlSdk";
  4  
  5  test("createPassenger add a new passenger to event's waiting list", async () => {
  6    const passenger: PassengerInput = {
  7      name: "Test waiting list passenger",
  8      email: "okidoki@octree.ch",
  9      location: "Church place",
 10    };
 11    const createPassengerRequest = sdk.createPassenger({
 12      passenger: { ...passenger, event: EVENT_ID },
 13    });
 14  
 15    await expect(createPassengerRequest).resolves.toMatchObject({
 16      createPassenger: {
 17        data: {
 18          id: expect.stringMatching(/\d/),
 19          attributes: passenger,
 20        },
 21      },
 22    });
 23  
 24    const getEventRequest = sdk.eventByUUID({
 25      uuid: EVENT_UUID,
 26    });
 27    await expect(getEventRequest).resolves.toMatchObject({
 28      eventByUUID: {
 29        data: {
 30          id: expect.stringMatching(/\d/),
 31          attributes: {
 32            waitingPassengers: {
 33              data: [
 34                {
 35                  id: expect.stringMatching(/\d/),
 36                  attributes: { ...passenger },
 37                },
 38              ],
 39            },
 40          },
 41        },
 42      },
 43    });
 44  });
 45  
 46  test("createPassenger add a new known user to event's waiting list", async () => {
 47    const passenger: PassengerInput = {
 48      name: "Test User",
 49      email: "test@octree.ch",
 50      location: "Train station",
 51      user: USER_ID,
 52    };
 53    const createPassengerRequest = sdk.createPassenger({
 54      passenger: { ...passenger, event: EVENT_ID },
 55    });
 56  
 57    await expect(createPassengerRequest).resolves.toMatchObject({
 58      createPassenger: {
 59        data: {
 60          attributes: {
 61            ...passenger,
 62            user: {
 63              data: {
 64                id: USER_ID,
 65                attributes: {
 66                  firstName: expect.any(String),
 67                  lastName: USER.lastName,
 68                },
 69              },
 70            },
 71          },
 72        },
 73      },
 74    });
 75  
 76    const getEventRequest = sdk.eventByUUID({
 77      uuid: EVENT_UUID,
 78    });
 79    await expect(getEventRequest).resolves.toMatchObject({
 80      eventByUUID: {
 81        data: {
 82          id: expect.stringMatching(/\d/),
 83          attributes: {
 84            waitingPassengers: {
 85              data: expect.arrayContaining([
 86                expect.any(Object),
 87                {
 88                  id: expect.stringMatching(/./),
 89                  attributes: {
 90                    ...passenger,
 91                    user: {
 92                      data: {
 93                        id: USER_ID,
 94                        attributes: {
 95                          firstName: expect.any(String),
 96                          lastName: USER.lastName,
 97                        },
 98                      },
 99                    },
100                  },
101                },
102              ]),
103            },
104          },
105        },
106      },
107    });
108  });
109  
110  test("createPassenger add a new passenger to travel's passengers list", async () => {
111    const passenger: PassengerInput = {
112      name: "Test travel list passenger",
113      email: "okidoki@octree.ch",
114      location: "Church place",
115    };
116    const createPassengerRequest = sdk.createPassenger({
117      passenger: { ...passenger, travel: TRAVEL_ID, event: EVENT_ID },
118    });
119  
120    await expect(createPassengerRequest).resolves.toMatchObject({
121      createPassenger: {
122        data: {
123          id: expect.stringMatching(/\d/),
124          attributes: passenger,
125        },
126      },
127    });
128  
129    const getEventRequest = sdk.eventByUUID({
130      uuid: EVENT_UUID,
131    });
132    await expect(getEventRequest).resolves.toMatchObject({
133      eventByUUID: {
134        data: {
135          id: expect.stringMatching(/\d/),
136          attributes: {
137            travels: {
138              data: [
139                {
140                  attributes: {
141                    passengers: {
142                      data: [
143                        {
144                          id: expect.any(String),
145                          attributes: {
146                            name: passenger.name,
147                            location: passenger.location,
148                            user: null,
149                          },
150                        },
151                      ],
152                    },
153                  },
154                },
155              ],
156            },
157          },
158        },
159      },
160    });
161  });
162  
163  test("updatePassenger returns updated passenger", async () => {
164    const passengerUpdate: PassengerInput = {
165      name: "Updated name",
166    };
167    const request = sdk.updatePassenger({
168      id: "2",
169      passengerUpdate,
170    });
171  
172    await expect(request).resolves.toMatchObject({
173      updatePassenger: {
174        data: {
175          id: "2",
176          attributes: {
177            name: passengerUpdate.name,
178          },
179        },
180      },
181    });
182  });
183  
184  test("deletePassenger returns ID of deleted passenger", async () => {
185    const request = sdk.deletePassenger({
186      id: "3",
187    });
188  
189    await expect(request).resolves.toMatchObject({
190      deletePassenger: {
191        data: {
192          id: "3",
193        },
194      },
195    });
196  });