@flusys/nestjs-task-manager 7.1.0 → 8.0.0

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

@@ -1,700 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _testing = require("@nestjs/testing");
-const _classes = require("@flusys/nestjs-shared/classes");
-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', ()=>{
-    const mockUtilsService = {
-        clearCache: jest.fn(),
-        getCacheKey: jest.fn().mockReturnValue('cache-key'),
-        trackCacheKey: jest.fn()
-    };
-    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
-    beforeEach(()=>{
-        mockUtilsService.clearCache.mockClear();
-    });
-    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: mockUtilsService
-                },
-                {
-                    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('invalidates the task list cache and the moved task entry', async ()=>{
-            const task = buildTask({
-                id: 'task-1',
-                listId: 'list-old',
-                boardId: 'board-1'
-            });
-            mockRepo.findOne.mockResolvedValue(task);
-            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
-            await service.moveTask({
-                taskId: 'task-1',
-                targetListId: 'list-new',
-                position: 1
-            }, (0, _loggedusermock.buildMockUser)({
-                id: 'mover-1'
-            }));
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task', expect.anything());
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task', expect.anything(), 'task-1');
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
-        });
-        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();
-        });
-    });
-    describe('domain events', ()=>{
-        let publish;
-        beforeEach(()=>{
-            publish = jest.fn().mockResolvedValue(undefined);
-            _classes.EventBusRegistry.reset();
-            _classes.EventBusRegistry.setBus({
-                publish,
-                subscribe: jest.fn(),
-                close: jest.fn()
-            });
-            _classes.EventBusRegistry.configureModule('task-manager', {
-                enabled: true
-            });
-        });
-        afterEach(()=>{
-            _classes.EventBusRegistry.reset();
-        });
-        it('publishes task-manager.task.moved with the source and target lists', 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));
-            await service.moveTask({
-                taskId: 'task-1',
-                targetListId: 'list-new',
-                position: 3
-            }, (0, _loggedusermock.buildMockUser)({
-                id: 'mover-1'
-            }));
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'task-manager.task.moved',
-                payload: expect.objectContaining({
-                    ids: [
-                        'task-1'
-                    ],
-                    metadata: expect.objectContaining({
-                        boardId: 'board-1',
-                        fromListId: 'list-old',
-                        toListId: 'list-new'
-                    })
-                })
-            }));
-        });
-        it('does not publish when the task manager module has events disabled', async ()=>{
-            _classes.EventBusRegistry.configureModule('task-manager', {
-                enabled: false
-            });
-            const task = buildTask({
-                id: 'task-1',
-                listId: 'list-old',
-                boardId: 'board-1'
-            });
-            mockRepo.findOne.mockResolvedValue(task);
-            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
-            await service.moveTask({
-                taskId: 'task-1',
-                targetListId: 'list-new'
-            }, (0, _loggedusermock.buildMockUser)());
-            expect(publish).not.toHaveBeenCalled();
-        });
-    });
-});