fix: broken recurring mutation tests

Author: joonatank

apps/admin-ui/src/component/reservations/EditPage.test.tsx

@@ -6,12 +6,11 @@ import userEvent from "@testing-library/user-event";
 // @ts-expect-error -- FIXME react-router typing
 import * as router from "react-router";
 import { CustomerTypeChoice, ReservationDocument } from "@gql/gql-types";
-
 import EditPage from "./EditPage";
 import {
   CHANGED_WORKING_MEMO,
   mockReservation,
-  mocks,
+  createMocks,
 } from "./hooks/__test__/mocks";
 import { base64encode } from "common/src/helpers";
 
@@ -84,7 +83,7 @@ const extendedReservation = {
 };
 
 const extendedMocks = [
-  ...mocks,
+  ...createMocks(),
   {
     request: {
       query: ReservationDocument,

apps/admin-ui/src/component/reservations/hooks/__test__/mocks.ts

@@ -1,18 +1,14 @@
 import { GraphQLError } from "graphql";
-import { addDays, addHours, set } from "date-fns";
+import { addDays, addHours, startOfDay } from "date-fns";
 import {
-  type ReservationNode,
-  Authentication,
-  ReservationKind,
-  ReservationStartInterval,
   ReservationStateChoice,
-  type ReservationUnitNode,
   UpdateStaffReservationDocument,
   RecurringReservationDocument,
   UpdateRecurringReservationDocument,
   ReservationTypeChoice,
   CustomerTypeChoice,
   type RecurringReservationQuery,
+  ReservationQuery,
 } from "@gql/gql-types";
 import { base64encode } from "common/src/helpers";
 import { toApiDateUnsafe } from "common/src/common/util";
@@ -56,22 +52,21 @@ export const MUTATION_DATA = {
   },
 };
 
-const TODAY = new Date();
-const getValidInterval = (daysToAdd: number) => {
-  const begin = set(addDays(TODAY, daysToAdd + 1), {
-    hours: 6,
-    minutes: 0,
-    seconds: 0,
-    milliseconds: 0,
-  });
+function getValidInterval(daysToAdd: number) {
+  const now = new Date();
+  const begin = addHours(addDays(startOfDay(now), daysToAdd + 1), 6);
   return [begin.toISOString(), addHours(begin, 1).toISOString()];
-};
+}
 
-function createRecurringEdges(
-  startingPk: number,
-  recurringPk: number,
-  state: ReservationStateChoice = ReservationStateChoice.Confirmed
-): NonNullable<
+function createReservationEdge({
+  startingPk,
+  recurringPk,
+  state = ReservationStateChoice.Confirmed,
+}: {
+  startingPk: number;
+  recurringPk: number;
+  state?: ReservationStateChoice;
+}): NonNullable<
   RecurringReservationQuery["recurringReservation"]
 >["reservations"] {
   const params = {
@@ -86,24 +81,36 @@ function createRecurringEdges(
     state,
   };
 
+  const begin1 = getValidInterval(0)[0];
+  const end1 = getValidInterval(0)[1];
+  const begin2 = getValidInterval(7)[0];
+  const end2 = getValidInterval(7)[1];
+  if (begin1 == null || end1 == null || begin2 == null || end2 == null) {
+    throw new Error("Invalid dates");
+  }
   return [
     {
       ...params,
-      begin: getValidInterval(0)[0],
-      end: getValidInterval(0)[1],
+      begin: begin1,
+      end: end1,
       pk: startingPk,
       id: base64encode(`ReservationNode:${startingPk}`),
     },
     {
       ...params,
-      begin: getValidInterval(7)[0],
-      end: getValidInterval(7)[1],
+      begin: begin2,
+      end: end2,
       pk: startingPk + 1,
       id: base64encode(`ReservationNode:${startingPk + 1}`),
     },
   ];
 }
 
+function convertDate(str: string) {
+  const date = new Date(str);
+  return toApiDateUnsafe(date);
+}
+
 function correctRecurringReservationQueryResult(
   startingPk: number,
   recurringPk: number,
@@ -113,17 +120,10 @@ function correctRecurringReservationQueryResult(
     allDenied?: boolean;
   }
 ) {
-  const convertDate = (str: string) => {
-    const date = new Date(str);
-    return toApiDateUnsafe(date);
-  };
-  const reservations = createRecurringEdges(
+  const reservations = createReservationEdge({
     startingPk,
     recurringPk,
-    options?.allDenied
-      ? ReservationStateChoice.Denied
-      : ReservationStateChoice.Confirmed
-  );
+  });
   const recurringReservation: NonNullable<
     RecurringReservationQuery["recurringReservation"]
   > = {
@@ -219,76 +219,79 @@ function correctRecurringReservationQueryResult(
   ];
 }
 
-export const mocks = [
-  // single reservation success
-  {
-    request: {
-      query: UpdateStaffReservationDocument,
-      variables: MUTATION_DATA,
-    },
-    result: {
-      data: {
-        staffReservationModify: { pk: 1, errors: null },
-        updateReservationWorkingMemo: {
-          workingMemo: CHANGED_WORKING_MEMO,
-          errors: null,
+export function createMocks() {
+  return [
+    // single reservation success
+    {
+      request: {
+        query: UpdateStaffReservationDocument,
+        variables: MUTATION_DATA,
+      },
+      result: {
+        data: {
+          staffReservationModify: { pk: 1, errors: null },
+          updateReservationWorkingMemo: {
+            workingMemo: CHANGED_WORKING_MEMO,
+            errors: null,
+          },
         },
       },
     },
-  },
-  // single reservation Failure mocks: networkError once then succceed
-  ...[{ fail: true }, { fail: false }].map(({ fail }) => ({
-    request: {
-      query: UpdateStaffReservationDocument,
-      variables: {
-        input: { ...MUTATION_DATA.input, pk: 101 },
-        workingMemo: { ...MUTATION_DATA.workingMemo, pk: 101 },
+    // single reservation Failure mocks: networkError once then succceed
+    ...[{ fail: true }, { fail: false }].map(({ fail }) => ({
+      request: {
+        query: UpdateStaffReservationDocument,
+        variables: {
+          input: { ...MUTATION_DATA.input, pk: 101 },
+          workingMemo: { ...MUTATION_DATA.workingMemo, pk: 101 },
+        },
       },
-    },
-    error: fail ? new Error("Error") : undefined,
-    result: !fail
-      ? {
-          data: {
-            staffReservationModify: { pk: 101, errors: null },
-            updateReservationWorkingMemo: {
-              workingMemo: CHANGED_WORKING_MEMO,
-              errors: null,
+      error: fail ? new Error("Error") : undefined,
+      result: !fail
+        ? {
+            data: {
+              staffReservationModify: { pk: 101, errors: null },
+              updateReservationWorkingMemo: {
+                workingMemo: CHANGED_WORKING_MEMO,
+                errors: null,
+              },
             },
-          },
-        }
-      : undefined,
-  })),
-  // networkError twice
-  ...[1, 2].map(() => ({
-    request: {
-      query: UpdateStaffReservationDocument,
-      variables: {
-        input: { ...MUTATION_DATA.input, pk: 102 },
-        workingMemo: { ...MUTATION_DATA.workingMemo, pk: 102 },
+          }
+        : undefined,
+    })),
+    // networkError twice
+    ...[1, 2].map(() => ({
+      request: {
+        query: UpdateStaffReservationDocument,
+        variables: {
+          input: { ...MUTATION_DATA.input, pk: 102 },
+          workingMemo: { ...MUTATION_DATA.workingMemo, pk: 102 },
+        },
       },
-    },
-    error: new Error("Error"),
-  })),
-  // graphQLError
-  {
-    request: {
-      query: UpdateStaffReservationDocument,
-      variables: {
-        input: { ...MUTATION_DATA.input, pk: 111 },
-        workingMemo: { ...MUTATION_DATA.workingMemo, pk: 111 },
+      error: new Error("Error"),
+    })),
+    // graphQLError
+    {
+      request: {
+        query: UpdateStaffReservationDocument,
+        variables: {
+          input: { ...MUTATION_DATA.input, pk: 111 },
+          workingMemo: { ...MUTATION_DATA.workingMemo, pk: 111 },
+        },
+      },
+      result: {
+        errors: [new GraphQLError("Error")],
       },
     },
-    result: {
-      errors: [new GraphQLError("Error")],
-    },
-  },
-  ...correctRecurringReservationQueryResult(21, 1),
-  ...correctRecurringReservationQueryResult(31, 2, { shouldFailOnce: true }),
-  ...correctRecurringReservationQueryResult(41, 3, { allDenied: true }),
-  ...correctRecurringReservationQueryResult(51, 4, { shouldFailAll: true }),
-];
+    ...correctRecurringReservationQueryResult(21, 1),
+    ...correctRecurringReservationQueryResult(31, 2, { shouldFailOnce: true }),
+    ...correctRecurringReservationQueryResult(41, 3, { allDenied: true }),
+    ...correctRecurringReservationQueryResult(51, 4, { shouldFailAll: true }),
+  ];
+}
 
-export const mockReservation: ReservationNode = {
+type ReservationType = NonNullable<ReservationQuery["reservation"]>;
+export const mockReservation: ReservationType = {
   pk: 1,
   begin: "2024-01-01T10:00:00+00:00",
   end: "2024-01-01T14:00:00+00:00",
@@ -302,54 +305,19 @@ export const mockReservation: ReservationNode = {
   handlingDetails: "",
 };
 
-const reservationUnit: ReservationUnitNode = {
-  pk: 1,
-  id: base64encode("ReservationUnitNode:1"),
-  allowReservationsWithoutOpeningHours: true,
-  applicationRoundTimeSlots: [],
-  applicationRounds: [],
-  bufferTimeAfter: 0,
-  bufferTimeBefore: 0,
-  authentication: Authentication.Weak,
-  canApplyFreeOfCharge: false,
-  contactInformation: "",
-  description: "",
-  equipments: [],
-  images: [],
-  isArchived: false,
-  isDraft: false,
-  name: "",
-  paymentTypes: [],
-  pricings: [],
-  purposes: [],
-  qualifiers: [],
-  requireIntroduction: false,
-  requireReservationHandling: false,
-  reservationBlockWholeDay: false,
-  reservationCancelledInstructions: "",
-  reservationConfirmedInstructions: "",
-  reservationKind: ReservationKind.DirectAndSeason,
-  reservationPendingInstructions: "",
-  reservationStartInterval: ReservationStartInterval.Interval_15Mins,
-  resources: [],
-  services: [],
-  spaces: [],
-  maxPersons: 10,
-  uuid: "be4fa7a2-05b7-11ee-be56-0242ac120004",
-};
-
-export const mockRecurringReservation: ReservationNode = {
-  ...mockReservation,
-  pk: 21,
-  id: base64encode("ReservationNode:21"),
-  recurringReservation: {
-    pk: 1,
-    created: "2021-09-01T10:00:00+00:00",
-    description: "",
-    reservations: [],
-    id: base64encode("RecurringReservationNode:1"),
-    name: "recurring",
-    reservationUnit,
-    rejectedOccurrences: [],
-  },
-};
+export function createMockRecurringReservation(props: {
+  pk: number;
+  recurringPk: number;
+}): ReservationType {
+  return {
+    ...mockReservation,
+    pk: props.pk,
+    id: base64encode(`ReservationNode:${props.pk}`),
+    recurringReservation: {
+      pk: props.recurringPk,
+      description: "",
+      id: base64encode(`RecurringReservationNode:${props.recurringPk}`),
+      name: "recurring",
+    },
+  };
+}