refactor(tests): consolidate event ID validation tests using parameterized cases for improved readability and maintainability

Author: Dobrunia

test/models/eventsFactory-bulk-toggle.test.ts

@@ -45,33 +45,30 @@ describe('EventsFactory.bulkSetEventMarks', () => {
     });
   });
 
-  it('should set starred mark when enabled is true', async () => {
-    const factory = new EventsFactory(projectId);
-    const id = new ObjectId();
-
-    collectionMock.updateMany.mockResolvedValue({
-      acknowledged: true,
-      modifiedCount: 1,
-    });
-
-    const result = await factory.bulkSetEventMarks([ id.toString() ], 'starred', true);
-
-    expect(result).toEqual({
-      acknowledged: true,
-      modifiedCount: 1,
-    });
-    expect(collectionMock.updateMany).toHaveBeenCalledWith(
-      {
-        _id: { $in: [ id ] },
-        'marks.starred': { $exists: false },
+  it.each([
+    {
+      title: 'should set starred mark when enabled is true',
+      mark: 'starred',
+      enabled: true,
+      expectedQuery: {
+        markExists: false,
       },
-      expect.objectContaining({
+      expectedUpdate: expect.objectContaining({
         $set: { 'marks.starred': expect.any(Number) },
-      })
-    );
-  });
-
-  it('should clear mark when enabled is false', async () => {
+      }),
+      expectResult: true,
+    },
+    {
+      title: 'should clear mark when enabled is false',
+      mark: 'ignored',
+      enabled: false,
+      expectedQuery: {
+        markExists: true,
+      },
+      expectedUpdate: { $unset: { 'marks.ignored': '' } },
+      expectResult: false,
+    },
+  ])('$title', async ({ mark, enabled, expectedQuery, expectedUpdate, expectResult }) => {
     const factory = new EventsFactory(projectId);
     const id = new ObjectId();
 
@@ -80,14 +77,21 @@ describe('EventsFactory.bulkSetEventMarks', () => {
       modifiedCount: 1,
     });
 
-    await factory.bulkSetEventMarks([ id.toString() ], 'ignored', false);
+    const result = await factory.bulkSetEventMarks([ id.toString() ], mark, enabled);
+
+    if (expectResult) {
+      expect(result).toEqual({
+        acknowledged: true,
+        modifiedCount: 1,
+      });
+    }
 
     expect(collectionMock.updateMany).toHaveBeenCalledWith(
       {
         _id: { $in: [ id ] },
-        'marks.ignored': { $exists: true },
+        [`marks.${mark}`]: { $exists: expectedQuery.markExists },
       },
-      { $unset: { 'marks.ignored': '' } }
+      expectedUpdate
     );
   });
 

test/models/eventsFactory-bulk-update-assignee.test.ts

@@ -70,35 +70,36 @@ describe('EventsFactory.bulkUpdateAssignee', () => {
     );
   });
 
-  it('should clear assignee with null value', async () => {
-    const factory = new EventsFactory(projectId);
-    const a = new ObjectId();
-
-    collectionMock.updateMany.mockResolvedValue({
-      acknowledged: true,
-      modifiedCount: 1,
-    });
-
-    const result = await factory.bulkUpdateAssignee([ a.toString() ], null);
-
-    expect(result).toEqual({
-      acknowledged: true,
-      modifiedCount: 1,
-    });
-    expect(collectionMock.updateMany).toHaveBeenCalledWith(
-      {
-        _id: { $in: [ a ] },
-        assignee: { $ne: '' },
-      },
-      { $set: { assignee: '' } }
-    );
-  });
-
-  it('should clear assignee when assignee is undefined', async () => {
+  it.each([
+    {
+      title: 'should clear assignee with null value',
+      assignee: null,
+      expectResult: true,
+    },
+    {
+      title: 'should clear assignee when assignee is undefined',
+      assignee: undefined,
+      expectResult: false,
+    },
+  ])('$title', async ({ assignee, expectResult }) => {
     const factory = new EventsFactory(projectId);
     const a = new ObjectId();
 
-    await factory.bulkUpdateAssignee([ a.toString() ], undefined);
+    if (expectResult) {
+      collectionMock.updateMany.mockResolvedValue({
+        acknowledged: true,
+        modifiedCount: 1,
+      });
+    }
+
+    const result = await factory.bulkUpdateAssignee([ a.toString() ], assignee);
+
+    if (expectResult) {
+      expect(result).toEqual({
+        acknowledged: true,
+        modifiedCount: 1,
+      });
+    }
 
     expect(collectionMock.updateMany).toHaveBeenCalledWith(
       {

test/resolvers/bulk-events-helper.test.ts

@@ -13,13 +13,18 @@ describe('bulkEvents helper', () => {
     expect(result).toEqual([validA, validB]);
   });
 
-  it('should throw when eventIds is empty', () => {
-    expect(() => parseBulkEventIds([])).toThrow('eventIds must contain at least one id');
-  });
-
-  it('should throw when at least one id is invalid', () => {
-    expect(() => parseBulkEventIds(['507f1f77bcf86cd799439011', 'bad-id'])).toThrow(
-      'eventIds must contain only valid ids'
-    );
+  it.each([
+    {
+      title: 'should throw when eventIds is empty',
+      input: [],
+      message: 'eventIds must contain at least one id',
+    },
+    {
+      title: 'should throw when at least one id is invalid',
+      input: ['507f1f77bcf86cd799439011', 'bad-id'],
+      message: 'eventIds must contain only valid ids',
+    },
+  ])('$title', ({ input, message }) => {
+    expect(() => parseBulkEventIds(input)).toThrow(message);
   });
 });

test/resolvers/event-bulk-toggle-marks.test.ts

@@ -29,19 +29,30 @@ describe('Mutation.bulkSetEventMarks', () => {
     });
   });
 
-  it('should throw when eventIds is empty', async () => {
+  it.each([
+    {
+      title: 'should throw when eventIds is empty',
+      eventIds: [],
+      message: 'eventIds must contain at least one id',
+    },
+    {
+      title: 'should throw for invalid ids',
+      eventIds: ['507f1f77bcf86cd799439011', 'invalid-id'],
+      message: 'eventIds must contain only valid ids',
+    },
+  ])('$title', async ({ eventIds, message }) => {
     await expect(
       eventResolvers.Mutation.bulkSetEventMarks(
         {},
         {
           projectId: 'p1',
-          eventIds: [],
+          eventIds,
           mark: 'ignored',
           enabled: true,
         },
         ctx
       )
-    ).rejects.toThrow('eventIds must contain at least one id');
+    ).rejects.toThrow(message);
 
     expect(bulkSetEventMarks).not.toHaveBeenCalled();
   });
@@ -107,17 +118,4 @@ describe('Mutation.bulkSetEventMarks', () => {
     });
   });
 
-  it('should throw for invalid ids', async () => {
-    await expect(eventResolvers.Mutation.bulkSetEventMarks(
-      {},
-      {
-        projectId: 'p1',
-        eventIds: ['507f1f77bcf86cd799439011', 'invalid-id'],
-        mark: 'ignored',
-        enabled: true,
-      },
-      ctx
-    )).rejects.toThrow('eventIds must contain only valid ids');
-    expect(bulkSetEventMarks).not.toHaveBeenCalled();
-  });
 });

test/resolvers/event-bulk-visit.test.ts

@@ -29,15 +29,26 @@ describe('Mutation.bulkVisitEvents', () => {
     (getEventsFactory as unknown as jest.Mock).mockReturnValue({ bulkVisitEvents });
   });
 
-  it('should throw when eventIds is empty', async () => {
+  it.each([
+    {
+      title: 'should throw when eventIds is empty',
+      eventIds: [],
+      message: 'eventIds must contain at least one id',
+    },
+    {
+      title: 'should throw when ids contain invalid values',
+      eventIds: ['bad-1', 'bad-2'],
+      message: 'eventIds must contain only valid ids',
+    },
+  ])('$title', async ({ eventIds, message }) => {
     await expect(eventResolvers.Mutation.bulkVisitEvents(
       {},
       {
         projectId: 'p1',
-        eventIds: [],
+        eventIds,
       },
       ctx
-    )).rejects.toThrow('eventIds must contain at least one id');
+    )).rejects.toThrow(message);
 
     expect(bulkVisitEvents).not.toHaveBeenCalled();
   });
@@ -67,15 +78,4 @@ describe('Mutation.bulkVisitEvents', () => {
     });
   });
 
-  it('should throw when ids contain invalid values', async () => {
-    await expect(eventResolvers.Mutation.bulkVisitEvents(
-      {},
-      {
-        projectId: 'p1',
-        eventIds: ['bad-1', 'bad-2'],
-      },
-      ctx
-    )).rejects.toThrow('eventIds must contain only valid ids');
-    expect(bulkVisitEvents).not.toHaveBeenCalled();
-  });
 });