tests: Added unit test for checklist item member use-cases

Author: OscarS05

api/src/application/use-cases/checklist-item-member/AddMemberToItemUseCase.js

@@ -7,6 +7,9 @@ class AddMemberToItemUseCase {
   }
 
   async execute(checklistItemId, availableMembersToBeAddedIds) {
+    if (!checklistItemId) throw new Error('checklistItemId was not provided');
+    if (availableMembersToBeAddedIds?.length === 0) return [];
+
     const checklistItemMemberEntities = availableMembersToBeAddedIds.map(
       (pmId) =>
         new ChecklistItemMemberEntity({

api/src/application/use-cases/checklist-item-member/DeleteChecklistItemUseCase.js

@@ -4,10 +4,21 @@ class DeleteChecklistItemUseCase {
   }
 
   async execute(checklistItemId, projectMemberId) {
-    return this.checklistItemMemberRepository.delete(
+    if (!checklistItemId) throw new Error('checklistItemId was not provided');
+    if (!projectMemberId) throw new Error('projectMemberId was not provided');
+
+    const result = await this.checklistItemMemberRepository.delete(
       checklistItemId,
       projectMemberId,
     );
+
+    if (result === 0) {
+      throw new Error(
+        'Something went wrong removing the checklist item member',
+      );
+    }
+
+    return result;
   }
 }
 

api/src/application/use-cases/checklist-item-member/GetAllByProjectMemberUseCase.js

@@ -7,18 +7,20 @@ class GetAllByProjectMemberUseCase {
   }
 
   async execute(checklistItemId, projectMemberIds) {
-    if (!checklistItemId) throw boom.badData('checklistItemId is required');
-    if (!Array.isArray(projectMemberIds) || projectMemberIds.length === 0)
-      throw boom.badData('projectMemberIds must be a non-empty array');
+    if (!checklistItemId)
+      throw boom.badData('checklistItemId was not provided');
+    if (!Array.isArray(projectMemberIds))
+      throw boom.badData('projectMemberIds was not provided');
+    if (projectMemberIds?.length === 0) return [];
 
     const checklistItemMembers =
       await this.checklistItemMemberRepository.findAllByProjectMember(
         checklistItemId,
         projectMemberIds,
       );
-    return checklistItemMembers.map(
-      (member) => new ChecklistItemMemberDto(member),
-    );
+    return checklistItemMembers?.length > 0
+      ? checklistItemMembers.map((member) => new ChecklistItemMemberDto(member))
+      : [];
   }
 }
 

api/src/application/use-cases/checklist-item-member/GetAllItemMembersUseCase.js

@@ -6,12 +6,14 @@ class GetAllItemMembersUseCase {
   }
 
   async execute(checklistItemId) {
+    if (!checklistItemId) throw new Error('checklistItemId was not provided');
+
     const checklistItemMembers =
       await this.checklistItemMemberRepository.findAll(checklistItemId);
 
     return checklistItemMembers?.length > 0
       ? checklistItemMembers.map((m) => {
-          const formattedMembers = m.get({ plain: true });
+          const formattedMembers = m?.get ? m.get({ plain: true }) : m;
           return new ChecklistItemMemberDto({
             ...formattedMembers,
             name:

api/src/application/use-cases/checklist-item-member/GetItemMembersByIdsUseCase.js

@@ -6,6 +6,9 @@ class GetItemMembersByIdsUseCase {
   }
 
   async execute(checklistItemId, checklistItemMemberIds) {
+    if (!checklistItemId) throw new Error('checklistItemId was not provided');
+    if (checklistItemMemberIds?.length === 0) return [];
+
     const members = await this.checklistItemMemberRepository.getByIds(
       checklistItemId,
       checklistItemMemberIds,

tests/unit/checklist-item-member/AddMemberToItemUseCase.test.js

@@ -0,0 +1,92 @@
+jest.mock('uuid', () => ({
+  v4: jest.fn(),
+}));
+
+const { v4: uuid } = require('uuid');
+
+const AddMemberToItemUseCase = require('../../../api/src/application/use-cases/checklist-item-member/AddMemberToItemUseCase');
+const ChecklistItemMemberDto = require('../../../api/src/application/dtos/checklist-item-member.dto');
+const {
+  createChecklistItem,
+  createChecklistItemMember,
+} = require('../../fake-data/fake-entities');
+
+describe('AddMemberToItemUseCase', () => {
+  const fakeChecklistItemId = createChecklistItem().id;
+  const fakeChecklistItemMemberId = 'fake-uuid';
+
+  let availableMembersToBeAddedIds;
+  let createdChecklistItemMembers;
+  let mockChecklistItemMemberRepository;
+  let addMemberToItemUseCase;
+
+  beforeAll(() => {
+    uuid.mockReturnValue(fakeChecklistItemMemberId);
+  });
+
+  beforeEach(() => {
+    availableMembersToBeAddedIds = [createChecklistItemMember()];
+
+    createdChecklistItemMembers = [
+      createChecklistItemMember({ id: fakeChecklistItemMemberId }),
+    ];
+
+    mockChecklistItemMemberRepository = {
+      bulkCreate: jest.fn().mockResolvedValue(createdChecklistItemMembers),
+    };
+
+    addMemberToItemUseCase = new AddMemberToItemUseCase({
+      checklistItemMemberRepository: mockChecklistItemMemberRepository,
+    });
+  });
+
+  test('It should return a created checklist item member', async () => {
+    const result = await addMemberToItemUseCase.execute(
+      fakeChecklistItemId,
+      availableMembersToBeAddedIds,
+    );
+
+    expect(mockChecklistItemMemberRepository.bulkCreate).toHaveBeenCalledTimes(
+      1,
+    );
+    expect(result).toMatchObject(
+      createdChecklistItemMembers.map(
+        (member) => new ChecklistItemMemberDto(member),
+      ),
+    );
+  });
+
+  test('It should return an error because checklistItemId was not provided', async () => {
+    await expect(
+      addMemberToItemUseCase.execute(null, availableMembersToBeAddedIds),
+    ).rejects.toThrow(/was not provided/);
+    expect(mockChecklistItemMemberRepository.bulkCreate).not.toHaveBeenCalled();
+  });
+
+  test('It should return an error because availableMembersToBeAddedIds is an empty array', async () => {
+    const result = await addMemberToItemUseCase.execute(
+      fakeChecklistItemId,
+      [],
+    );
+    expect(mockChecklistItemMemberRepository.bulkCreate).not.toHaveBeenCalled();
+    expect(result).toEqual([]);
+  });
+
+  test('It should return an empty array because the create operation failed', async () => {
+    mockChecklistItemMemberRepository.bulkCreate.mockResolvedValue([]);
+
+    const result = await addMemberToItemUseCase.execute(
+      fakeChecklistItemId,
+      availableMembersToBeAddedIds,
+    );
+
+    expect(mockChecklistItemMemberRepository.bulkCreate).toHaveBeenCalledTimes(
+      1,
+    );
+    expect(result).toEqual([]);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+});

tests/unit/checklist-item-member/DeleteChecklistItemMemberUseCase.test.js

@@ -0,0 +1,60 @@
+const DeleteChecklistItemUseCase = require('../../../api/src/application/use-cases/checklist-item-member/DeleteChecklistItemUseCase');
+const { createChecklistItem } = require('../../fake-data/fake-entities');
+
+describe('DeleteChecklistItemUseCase', () => {
+  const fakeChecklistItemId = createChecklistItem().id;
+  const fakeProjectMemberId = 'fake-uuid';
+
+  let mockChecklistItemMemberRepository;
+  let deleteChecklistItemUseCase;
+
+  beforeEach(() => {
+    mockChecklistItemMemberRepository = {
+      delete: jest.fn().mockResolvedValue(1),
+    };
+
+    deleteChecklistItemUseCase = new DeleteChecklistItemUseCase({
+      checklistItemMemberRepository: mockChecklistItemMemberRepository,
+    });
+  });
+
+  test('It should return a 1', async () => {
+    const result = await deleteChecklistItemUseCase.execute(
+      fakeChecklistItemId,
+      fakeProjectMemberId,
+    );
+
+    expect(mockChecklistItemMemberRepository.delete).toHaveBeenCalledTimes(1);
+    expect(result).toBe(1);
+  });
+
+  test('It should return an error because checklistItemId was not provided', async () => {
+    await expect(
+      deleteChecklistItemUseCase.execute(null, fakeProjectMemberId),
+    ).rejects.toThrow(/was not provided/);
+    expect(mockChecklistItemMemberRepository.delete).not.toHaveBeenCalled();
+  });
+
+  test('It should return an error because ProjectMemberId was not provided', async () => {
+    await expect(
+      deleteChecklistItemUseCase.execute(fakeChecklistItemId, null),
+    ).rejects.toThrow(/was not provided/);
+    expect(mockChecklistItemMemberRepository.delete).not.toHaveBeenCalled();
+  });
+
+  test('It should return an empty array because the create operation did not find anything', async () => {
+    mockChecklistItemMemberRepository.delete.mockResolvedValue(0);
+
+    await expect(
+      deleteChecklistItemUseCase.execute(
+        fakeChecklistItemId,
+        fakeProjectMemberId,
+      ),
+    ).rejects.toThrow(/Something went wrong/);
+    expect(mockChecklistItemMemberRepository.delete).toHaveBeenCalledTimes(1);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+});

tests/unit/checklist-item-member/GetAllByProjectMemberUseCase.test.js

@@ -0,0 +1,94 @@
+const GetAllByProjectMemberUseCase = require('../../../api/src/application/use-cases/checklist-item-member/GetAllByProjectMemberUseCase');
+const ChecklistItemMemberDto = require('../../../api/src/application/dtos/checklist-item-member.dto');
+const {
+  createChecklistItem,
+  createChecklistItemMember,
+  createProjectMember,
+} = require('../../fake-data/fake-entities');
+
+describe('GetAllByProjectMemberUseCase', () => {
+  const fakeChecklistItemId = createChecklistItem().id;
+  // const fakeChecklistItemMemberId = 'fake-uuid';
+
+  let fakeProjectMemberIds;
+  let dbResponse;
+  let mockChecklistItemMemberRepository;
+  let getAllByProjectMemberUseCase;
+
+  beforeEach(() => {
+    fakeProjectMemberIds = [createProjectMember().id, createProjectMember().id];
+    dbResponse = [createChecklistItemMember(), createChecklistItemMember()];
+
+    mockChecklistItemMemberRepository = {
+      findAllByProjectMember: jest.fn().mockResolvedValue(dbResponse),
+    };
+
+    getAllByProjectMemberUseCase = new GetAllByProjectMemberUseCase({
+      checklistItemMemberRepository: mockChecklistItemMemberRepository,
+    });
+  });
+
+  test('It should return a checklist item members', async () => {
+    const result = await getAllByProjectMemberUseCase.execute(
+      fakeChecklistItemId,
+      fakeProjectMemberIds,
+    );
+
+    expect(
+      mockChecklistItemMemberRepository.findAllByProjectMember,
+    ).toHaveBeenCalledTimes(1);
+    expect(result).toMatchObject(
+      dbResponse.map((member) => new ChecklistItemMemberDto(member)),
+    );
+  });
+
+  test('It should return an error because ProjectMemberIds was not provided', async () => {
+    await expect(
+      getAllByProjectMemberUseCase.execute(null, fakeProjectMemberIds),
+    ).rejects.toThrow(/was not provided/);
+    expect(
+      mockChecklistItemMemberRepository.findAllByProjectMember,
+    ).not.toHaveBeenCalled();
+  });
+
+  test('It should return an error because ProjectMemberIds was not provided', async () => {
+    await expect(
+      getAllByProjectMemberUseCase.execute(fakeChecklistItemId, {}),
+    ).rejects.toThrow(/was not provided/);
+    expect(
+      mockChecklistItemMemberRepository.findAllByProjectMember,
+    ).not.toHaveBeenCalled();
+  });
+
+  test('It should return an error because ProjectMemberIds was not provided', async () => {
+    const result = await getAllByProjectMemberUseCase.execute(
+      fakeChecklistItemId,
+      [],
+    );
+
+    expect(
+      mockChecklistItemMemberRepository.findAllByProjectMember,
+    ).not.toHaveBeenCalled();
+    expect(result).toEqual([]);
+  });
+
+  test('It should return an empty array because the create operation did not find anything', async () => {
+    mockChecklistItemMemberRepository.findAllByProjectMember.mockResolvedValue(
+      [],
+    );
+
+    const result = await getAllByProjectMemberUseCase.execute(
+      fakeChecklistItemId,
+      fakeProjectMemberIds,
+    );
+
+    expect(
+      mockChecklistItemMemberRepository.findAllByProjectMember,
+    ).toHaveBeenCalledTimes(1);
+    expect(result).toEqual([]);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+});