test: ✅ test coverage for setEventDates

CourtHive · Mar 29, 2024 · 8867131 · 8867131
1 parent c9ad969
commit 8867131
Show file tree

Hide file tree

Showing 3 changed files with 41 additions and 6 deletions.
diff --git a/src/mutate/events/setEventDates.ts b/src/mutate/events/setEventDates.ts
@@ -88,11 +88,12 @@ type SetEventDatesArgs = {
 
 export function setEventDates(params: SetEventDatesArgs) {
   const paramsCheck = checkRequiredParameters(params, [
-    { tournamentRecord: true },
+    { tournamentRecord: true, event: true },
     {
       [VALIDATE]: (value) => dateValidation.test(value),
-      [ANY_OF]: { startDate: false, endDate: false },
       [INVALID]: INVALID_DATE,
+      startDate: false,
+      endDate: false,
     },
     {
       [VALIDATE]: (value) => value.every((d) => dateValidation.test(d)),
@@ -119,7 +120,7 @@ export function setEventDates(params: SetEventDatesArgs) {
     const end = endDate || tournamentRecord.endDate;
     const validStart = !start || activeDates.every((d) => new Date(d) >= new Date(start));
     const validEnd = !end || activeDates.every((d) => new Date(d) <= new Date(end));
-    if (!validStart || !validEnd) return { error: INVALID_VALUES };
+    if (!validStart || !validEnd) return { error: INVALID_DATE };
   }
 
   if (startDate) {

diff --git a/src/mutate/tournaments/setTournamentDates.ts b/src/mutate/tournaments/setTournamentDates.ts
@@ -122,10 +122,12 @@ export function setTournamentDates(params: SetTournamentDatesArgs): ResultType &
 }
 
 export function setTournamentStartDate({ tournamentRecord, startDate }) {
+  if (!startDate) return { error: INVALID_DATE };
   return setTournamentDates({ tournamentRecord, startDate });
 }
 
 export function setTournamentEndDate({ tournamentRecord, endDate }) {
+  if (!endDate) return { error: INVALID_DATE };
   return setTournamentDates({ tournamentRecord, endDate });
 }
 

diff --git a/src/tests/mutations/events/setEventDates.test.ts b/src/tests/mutations/events/setEventDates.test.ts
@@ -3,7 +3,8 @@ import mocksEngine from '@Assemblies/engines/mock';
 import { expect, test } from 'vitest';
 
 import tournamentEngineSync from '@Engines/syncEngine';
-import { INVALID_DATE, MISSING_EVENT } from '@Constants/errorConditionConstants';
+import { INVALID_DATE, INVALID_VALUES, MISSING_EVENT } from '@Constants/errorConditionConstants';
+import { MON } from '@Constants/weekdayConstants';
 
 test.each([tournamentEngineSync])('can modify event.startDate and event.endDate', async (tournamentEngine) => {
   const { tournamentRecord } = mocksEngine.generateTournamentRecord();
@@ -84,8 +85,8 @@ test.each([tournamentEngineSync])(
 
     const newEventStartDate = dateStringDaysChange(startDate, -1);
     let result = await tournamentEngine.setEventStartDate({
-      eventId,
       startDate: newEventStartDate,
+      eventId,
     });
     expect(result.success).toEqual(undefined);
     expect(result.error).toEqual(INVALID_DATE);
@@ -94,8 +95,8 @@ test.each([tournamentEngineSync])(
 
     const newEventEndDate = dateStringDaysChange(endDate, 1);
     result = await tournamentEngine.setEventEndDate({
-      eventId,
       endDate: newEventEndDate,
+      eventId,
     });
     expect(result.success).toEqual(undefined);
     expect(result.error).toEqual(INVALID_DATE);
@@ -108,5 +109,36 @@ test.each([tournamentEngineSync])(
     ({ event } = await tournamentEngine.getEvent({ eventId }));
     expect(event.startDate).toEqual(startDate);
     expect(event.endDate).toEqual(endDate);
+
+    result = await tournamentEngine.setEventDates();
+    expect(result.error).toEqual(MISSING_EVENT);
+
+    result = await tournamentEngine.setEventDates({ eventId });
+    expect(result.success).toEqual(true);
+
+    result = await tournamentEngine.setEventDates({ eventId, weekdays: ['invalid'] });
+    expect(result.error).toEqual(INVALID_VALUES);
+
+    result = await tournamentEngine.setEventDates({ eventId, weekdays: [MON, MON] });
+    expect(result.error).toEqual(INVALID_VALUES);
+
+    result = await tournamentEngine.setEventDates({ eventId, weekdays: [MON] });
+    expect(result.success).toEqual(true);
+
+    let activeDates = [
+      dateStringDaysChange(startDate, -1),
+      dateStringDaysChange(startDate, 2),
+      dateStringDaysChange(startDate, 4),
+    ];
+    result = await tournamentEngine.setEventDates({ eventId, activeDates });
+    expect(result.error).toEqual(INVALID_DATE);
+
+    activeDates = [startDate, dateStringDaysChange(startDate, 2), dateStringDaysChange(startDate, 8)];
+    result = await tournamentEngine.setEventDates({ eventId, activeDates });
+    expect(result.error).toEqual(INVALID_DATE);
+
+    activeDates = [startDate, dateStringDaysChange(startDate, 2), dateStringDaysChange(startDate, 4)];
+    result = await tournamentEngine.setEventDates({ eventId, activeDates });
+    expect(result.success).toEqual(true);
   },
 );