@flusys/nestjs-task-manager 6.0.2 → 6.1.0

package/cjs/services/task.service.spec.js

@@ -0,0 +1,610 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _entities = require("../entities");
+const _taskactivityservice = require("./task-activity.service");
+const _taskboardservice = require("./task-board.service");
+const _taskmanagerdatasourceprovider = require("./task-manager-datasource.provider");
+const _taskservice = require("./task.service");
+function buildTask(overrides = {}) {
+    return {
+        id: 'task-uuid-1',
+        boardId: 'board-uuid-1',
+        listId: 'list-uuid-1',
+        title: 'Fix bug',
+        description: null,
+        priority: _entities.TaskPriority.MEDIUM,
+        dueDate: null,
+        position: 0,
+        reporterId: null,
+        parentTaskId: null,
+        estimatedHours: null,
+        assignees: [],
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+function mockQueryRunner(repo) {
+    const qr = {
+        connect: jest.fn().mockResolvedValue(undefined),
+        startTransaction: jest.fn().mockResolvedValue(undefined),
+        commitTransaction: jest.fn().mockResolvedValue(undefined),
+        rollbackTransaction: jest.fn().mockResolvedValue(undefined),
+        release: jest.fn().mockResolvedValue(undefined),
+        manager: {
+            save: jest.fn((_target, entities)=>Promise.resolve(entities))
+        }
+    };
+    repo.manager.connection.createQueryRunner.mockReturnValue(qr);
+    return qr;
+}
+describe('TaskService', ()=>{
+    let service;
+    let mockRepo;
+    let mockLabelJunctionRepo;
+    let mockFullLabelRepo;
+    let mockAssigneeRepo;
+    let mockBoardService;
+    let mockActivityService;
+    let mockDataSourceProvider;
+    beforeEach(async ()=>{
+        mockRepo = (0, _repositorymock.createMockRepository)();
+        mockLabelJunctionRepo = (0, _repositorymock.createMockRepository)();
+        mockFullLabelRepo = (0, _repositorymock.createMockRepository)();
+        mockAssigneeRepo = (0, _repositorymock.createMockRepository)();
+        mockLabelJunctionRepo.find.mockResolvedValue([]);
+        mockFullLabelRepo.find.mockResolvedValue([]);
+        mockAssigneeRepo.createQueryBuilder.mockReturnValue({
+            ...(0, _repositorymock.createMockQueryBuilder)(),
+            select: jest.fn().mockReturnThis(),
+            addSelect: jest.fn().mockReturnThis(),
+            leftJoin: jest.fn().mockReturnThis(),
+            where: jest.fn().mockReturnThis(),
+            getRawMany: jest.fn().mockResolvedValue([])
+        });
+        mockBoardService = {
+            isBoardMember: jest.fn().mockResolvedValue(true)
+        };
+        mockActivityService = {
+            log: jest.fn().mockResolvedValue(undefined)
+        };
+        mockDataSourceProvider = {
+            getRepository: jest.fn((entity)=>{
+                if (entity === _entities.TaskTaskLabel) return Promise.resolve(mockLabelJunctionRepo);
+                if (entity === _entities.TaskLabel) return Promise.resolve(mockFullLabelRepo);
+                if (entity === _entities.TaskAssignee) return Promise.resolve(mockAssigneeRepo);
+                return Promise.resolve(mockRepo);
+            }),
+            getDataSource: jest.fn()
+        };
+        const module = await _testing.Test.createTestingModule({
+            providers: [
+                _taskservice.TaskService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: _modules.UtilsService,
+                    useValue: {
+                        clearCache: jest.fn(),
+                        getCacheKey: jest.fn(),
+                        trackCacheKey: jest.fn()
+                    }
+                },
+                {
+                    provide: _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                },
+                {
+                    provide: _taskboardservice.TaskBoardService,
+                    useValue: mockBoardService
+                },
+                {
+                    provide: _taskactivityservice.TaskActivityService,
+                    useValue: mockActivityService
+                }
+            ]
+        }).compile();
+        service = await module.resolve(_taskservice.TaskService);
+    });
+    describe('convertSingleDtoToEntity / insert (create path)', ()=>{
+        it('creates a task with default priority, position 0 and reporterId from the current user', async ()=>{
+            mockQueryRunner(mockRepo);
+            const result = await service.insert({
+                boardId: 'board-1',
+                listId: 'list-1',
+                title: 'New Task'
+            }, (0, _loggedusermock.buildMockUser)({
+                id: 'reporter-1'
+            }));
+            expect(result).toEqual(expect.objectContaining({
+                boardId: 'board-1',
+                listId: 'list-1',
+                title: 'New Task',
+                priority: 'MEDIUM',
+                position: 0,
+                reporterId: 'reporter-1'
+            }));
+        });
+        it('respects an explicit priority and dueDate on create', async ()=>{
+            mockQueryRunner(mockRepo);
+            const result = await service.insert({
+                boardId: 'board-1',
+                listId: 'list-1',
+                title: 'Urgent Task',
+                priority: _entities.TaskPriority.URGENT,
+                dueDate: '2026-12-31'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result).toEqual(expect.objectContaining({
+                priority: 'URGENT',
+                dueDate: '2026-12-31'
+            }));
+        });
+        it('validates every assignee is a board member and throws BadRequestException otherwise', async ()=>{
+            mockQueryRunner(mockRepo);
+            mockBoardService.isBoardMember.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+            await expect(service.insert({
+                boardId: 'board-1',
+                listId: 'list-1',
+                title: 'Task',
+                assigneeIds: [
+                    'member-1',
+                    'stranger-1'
+                ]
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+        it('allows creation when all assignees are board members', async ()=>{
+            mockQueryRunner(mockRepo);
+            mockBoardService.isBoardMember.mockResolvedValue(true);
+            await expect(service.insert({
+                boardId: 'board-1',
+                listId: 'list-1',
+                title: 'Task',
+                assigneeIds: [
+                    'member-1'
+                ]
+            }, (0, _loggedusermock.buildMockUser)())).resolves.toBeDefined();
+            expect(mockBoardService.isBoardMember).toHaveBeenCalledWith('board-1', 'member-1');
+        });
+        it('logs a "task.created" activity after a successful insert', async ()=>{
+            mockQueryRunner(mockRepo);
+            const result = await service.insert({
+                boardId: 'board-1',
+                listId: 'list-1',
+                title: 'New Task'
+            }, (0, _loggedusermock.buildMockUser)({
+                id: 'reporter-1'
+            }));
+            expect(mockActivityService.log).toHaveBeenCalledWith(result.id, 'board-1', 'reporter-1', 'task.created', null, {
+                title: 'New Task'
+            });
+        });
+        it('syncs labels via the junction repository on create when labelIds are provided', async ()=>{
+            mockQueryRunner(mockRepo);
+            mockLabelJunctionRepo.create.mockImplementation((data)=>data);
+            const result = await service.insert({
+                boardId: 'board-1',
+                listId: 'list-1',
+                title: 'Labeled Task',
+                labelIds: [
+                    'label-1',
+                    'label-2'
+                ]
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockLabelJunctionRepo.delete).toHaveBeenCalledWith({
+                taskId: result.id
+            });
+            expect(mockLabelJunctionRepo.save).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    taskId: result.id,
+                    labelId: 'label-1'
+                }),
+                expect.objectContaining({
+                    taskId: result.id,
+                    labelId: 'label-2'
+                })
+            ]);
+        });
+        it('syncs assignees via the assignee repository on create when assigneeIds are provided', async ()=>{
+            mockQueryRunner(mockRepo);
+            mockAssigneeRepo.create.mockImplementation((data)=>data);
+            const result = await service.insert({
+                boardId: 'board-1',
+                listId: 'list-1',
+                title: 'Assigned Task',
+                assigneeIds: [
+                    'user-1'
+                ]
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockAssigneeRepo.save).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    taskId: result.id,
+                    userId: 'user-1'
+                })
+            ]);
+        });
+    });
+    describe('convertSingleDtoToEntity / update (update path)', ()=>{
+        it('throws NotFoundException when updating a task that does not exist', async ()=>{
+            mockQueryRunner(mockRepo);
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.update({
+                id: 'missing',
+                title: 'Renamed'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+        it('merges update fields onto the existing entity, preserving position and reporterId', async ()=>{
+            mockQueryRunner(mockRepo);
+            const existing = buildTask({
+                id: 'task-1',
+                title: 'Old title',
+                position: 7,
+                reporterId: 'orig-reporter'
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            const result = await service.update({
+                id: 'task-1',
+                title: 'New title'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result).toEqual(expect.objectContaining({
+                id: 'task-1',
+                title: 'New title',
+                position: 7,
+                reporterId: 'orig-reporter'
+            }));
+        });
+        it('clears description when explicitly set to null on update', async ()=>{
+            mockQueryRunner(mockRepo);
+            const existing = buildTask({
+                id: 'task-1',
+                description: 'Old description'
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            const result = await service.update({
+                id: 'task-1',
+                description: null
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.description).toBeNull();
+        });
+        it('re-validates assignee board membership when assigneeIds change on update', async ()=>{
+            mockQueryRunner(mockRepo);
+            const existing = buildTask({
+                id: 'task-1'
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            mockBoardService.isBoardMember.mockResolvedValue(false);
+            await expect(service.update({
+                id: 'task-1',
+                assigneeIds: [
+                    'not-a-member'
+                ]
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+        it('only syncs labels/assignees on update when the respective dto fields are present', async ()=>{
+            mockQueryRunner(mockRepo);
+            const existing = buildTask({
+                id: 'task-1'
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            await service.update({
+                id: 'task-1',
+                title: 'Just a rename'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockLabelJunctionRepo.delete).not.toHaveBeenCalled();
+            expect(mockAssigneeRepo.delete).not.toHaveBeenCalled();
+        });
+    });
+    describe('getFilterQuery', ()=>{
+        it('filters by boardId, listId and priority using andWhere', async ()=>{
+            const qb = (0, _repositorymock.createMockQueryBuilder)();
+            await service.getFilterQuery(qb, {
+                boardId: 'board-1',
+                listId: 'list-1',
+                priority: 'HIGH'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(qb.andWhere).toHaveBeenCalledWith('task.boardId = :boardId', {
+                boardId: 'board-1'
+            });
+            expect(qb.andWhere).toHaveBeenCalledWith('task.listId = :listId', {
+                listId: 'list-1'
+            });
+            expect(qb.andWhere).toHaveBeenCalledWith('task.priority = :priority', {
+                priority: 'HIGH'
+            });
+        });
+        it('joins the assignee table and filters by assigneeId', async ()=>{
+            const qb = (0, _repositorymock.createMockQueryBuilder)();
+            qb.innerJoin = jest.fn().mockReturnThis();
+            await service.getFilterQuery(qb, {
+                assigneeId: 'user-1'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(qb.innerJoin).toHaveBeenCalledWith('task_assignee', 'ta', 'ta.task_id = task.id');
+            expect(qb.andWhere).toHaveBeenCalledWith('ta.user_id = :assigneeUserId', {
+                assigneeUserId: 'user-1'
+            });
+        });
+        it('ignores unknown filter keys', async ()=>{
+            const qb = (0, _repositorymock.createMockQueryBuilder)();
+            await service.getFilterQuery(qb, {
+                unknownKey: 'value'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(qb.andWhere).not.toHaveBeenCalled();
+        });
+    });
+    describe('moveTask', ()=>{
+        it('moves a task to a target list and given position, logging "task.moved"', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                listId: 'list-old',
+                boardId: 'board-1',
+                position: 0
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
+            const result = await service.moveTask({
+                taskId: 'task-1',
+                targetListId: 'list-new',
+                position: 3
+            }, (0, _loggedusermock.buildMockUser)({
+                id: 'mover-1'
+            }));
+            expect(result.listId).toBe('list-new');
+            expect(result.position).toBe(3);
+            expect(result.updatedById).toBe('mover-1');
+            expect(mockActivityService.log).toHaveBeenCalledWith('task-1', 'board-1', 'mover-1', 'task.moved', {
+                listId: 'list-old'
+            }, {
+                listId: 'list-new'
+            });
+        });
+        it('defaults position to 0 (first position) when no position is given', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                listId: 'list-old'
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
+            const result = await service.moveTask({
+                taskId: 'task-1',
+                targetListId: 'list-new'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.position).toBe(0);
+        });
+        it('supports moving to the last position of a target list via an explicit high position value', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                listId: 'list-old'
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
+            const result = await service.moveTask({
+                taskId: 'task-1',
+                targetListId: 'list-new',
+                position: 99
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.position).toBe(99);
+        });
+        it('supports moving within the same list (reordering, not a cross-list move)', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                listId: 'list-same',
+                boardId: 'board-1',
+                position: 0
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
+            const result = await service.moveTask({
+                taskId: 'task-1',
+                targetListId: 'list-same',
+                position: 2
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.listId).toBe('list-same');
+            expect(result.position).toBe(2);
+            expect(mockActivityService.log).toHaveBeenCalledWith('task-1', 'board-1', expect.anything(), 'task.moved', {
+                listId: 'list-same'
+            }, {
+                listId: 'list-same'
+            });
+        });
+        it('throws NotFoundException when the task to move does not exist', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.moveTask({
+                taskId: 'missing',
+                targetListId: 'list-new'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+        it('excludes soft-deleted tasks from being moved', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.moveTask({
+                taskId: 'deleted-task',
+                targetListId: 'list-new'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    id: 'deleted-task',
+                    deletedAt: expect.anything()
+                }
+            });
+        });
+    });
+    describe('assignTask', ()=>{
+        it('assigns board members to a task and logs "task.assigned" with old/new assignee ids', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                boardId: 'board-1'
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
+            mockAssigneeRepo.find.mockResolvedValue([
+                {
+                    userId: 'old-user'
+                }
+            ]);
+            mockAssigneeRepo.create.mockImplementation((data)=>data);
+            mockBoardService.isBoardMember.mockResolvedValue(true);
+            const result = await service.assignTask({
+                taskId: 'task-1',
+                assigneeIds: [
+                    'new-user-1',
+                    'new-user-2'
+                ]
+            }, (0, _loggedusermock.buildMockUser)({
+                id: 'assigner-1'
+            }));
+            expect(mockAssigneeRepo.delete).toHaveBeenCalledWith({
+                taskId: 'task-1'
+            });
+            expect(mockAssigneeRepo.save).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    taskId: 'task-1',
+                    userId: 'new-user-1'
+                }),
+                expect.objectContaining({
+                    taskId: 'task-1',
+                    userId: 'new-user-2'
+                })
+            ]);
+            expect(mockActivityService.log).toHaveBeenCalledWith('task-1', 'board-1', 'assigner-1', 'task.assigned', {
+                assigneeIds: [
+                    'old-user'
+                ]
+            }, {
+                assigneeIds: [
+                    'new-user-1',
+                    'new-user-2'
+                ]
+            });
+            expect(result.updatedById).toBe('assigner-1');
+        });
+        it('supports unassigning all users by passing an empty assigneeIds array', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                boardId: 'board-1'
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
+            mockAssigneeRepo.find.mockResolvedValue([
+                {
+                    userId: 'old-user'
+                }
+            ]);
+            await service.assignTask({
+                taskId: 'task-1',
+                assigneeIds: []
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockAssigneeRepo.delete).toHaveBeenCalledWith({
+                taskId: 'task-1'
+            });
+            expect(mockAssigneeRepo.save).not.toHaveBeenCalled();
+        });
+        it('throws BadRequestException when any assignee is not a board member', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                boardId: 'board-1'
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockBoardService.isBoardMember.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+            await expect(service.assignTask({
+                taskId: 'task-1',
+                assigneeIds: [
+                    'member-1',
+                    'stranger-1'
+                ]
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+            expect(mockAssigneeRepo.delete).not.toHaveBeenCalled();
+        });
+        it('throws NotFoundException when the task does not exist', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.assignTask({
+                taskId: 'missing',
+                assigneeIds: [
+                    'user-1'
+                ]
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+        it('returns the task with freshly loaded assignees populated', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                boardId: 'board-1'
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
+            mockAssigneeRepo.find.mockResolvedValue([]);
+            const rawRows = [
+                {
+                    userId: 'new-user-1',
+                    userName: 'New User'
+                }
+            ];
+            mockAssigneeRepo.createQueryBuilder.mockReturnValue({
+                select: jest.fn().mockReturnThis(),
+                addSelect: jest.fn().mockReturnThis(),
+                leftJoin: jest.fn().mockReturnThis(),
+                where: jest.fn().mockReturnThis(),
+                getRawMany: jest.fn().mockResolvedValue(rawRows)
+            });
+            const result = await service.assignTask({
+                taskId: 'task-1',
+                assigneeIds: [
+                    'new-user-1'
+                ]
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.assignees).toEqual([
+                {
+                    userId: 'new-user-1',
+                    userName: 'New User'
+                }
+            ]);
+        });
+    });
+    describe('getAll', ()=>{
+        it('loads labels and assignees for every returned task', async ()=>{
+            const tasks = [
+                buildTask({
+                    id: 'task-1'
+                }),
+                buildTask({
+                    id: 'task-2'
+                })
+            ];
+            const superGetAllSpy = jest.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(service)), 'getAll').mockResolvedValue({
+                data: tasks,
+                total: 2
+            });
+            mockLabelJunctionRepo.find.mockResolvedValue([]);
+            mockAssigneeRepo.createQueryBuilder.mockReturnValue({
+                select: jest.fn().mockReturnThis(),
+                addSelect: jest.fn().mockReturnThis(),
+                leftJoin: jest.fn().mockReturnThis(),
+                where: jest.fn().mockReturnThis(),
+                getRawMany: jest.fn().mockResolvedValue([])
+            });
+            const result = await service.getAll('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toHaveLength(2);
+            expect(mockLabelJunctionRepo.find).toHaveBeenCalled();
+            expect(mockAssigneeRepo.createQueryBuilder).toHaveBeenCalled();
+            superGetAllSpy.mockRestore();
+        });
+        it('returns an empty result set without querying label/assignee tables when there are no tasks', async ()=>{
+            const superGetAllSpy = jest.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(service)), 'getAll').mockResolvedValue({
+                data: [],
+                total: 0
+            });
+            const result = await service.getAll('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toEqual([]);
+            expect(mockLabelJunctionRepo.find).not.toHaveBeenCalled();
+            superGetAllSpy.mockRestore();
+        });
+    });
+});