@flusys/nestjs-notification 7.1.0 → 8.0.0

package/fesm/services/notification.service.spec.js

@@ -1,556 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { EventBusRegistry } from '@flusys/nestjs-shared/classes';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { NotificationService } from './notification.service';
-import { NotificationConfigService } from './notification-config.service';
-import { NotificationDataSourceProvider } from './notification-datasource.provider';
-import { NotificationGateway } from '../gateways';
-import { Notification, NotificationWithCompany } from '../entities';
-function buildNotification(overrides = {}) {
-    return {
-        id: 'notif-uuid-1',
-        userId: 'user-uuid-1',
-        type: 'info',
-        title: 'Title',
-        message: 'Message',
-        data: null,
-        isRead: false,
-        readAt: null,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-function createMockQuery() {
-    return {
-        andWhere: jest.fn().mockReturnThis(),
-        addSelect: jest.fn().mockReturnThis(),
-        orderBy: jest.fn().mockReturnThis()
-    };
-}
-describe('NotificationService', ()=>{
-    let service;
-    let mockRepo;
-    let mockConfig;
-    let mockGateway;
-    async function buildService(withGateway = true, companyFeatureEnabled = false) {
-        mockRepo = createMockRepository();
-        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
-        mockConfig = {
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(companyFeatureEnabled)
-        };
-        mockGateway = {
-            emitToUser: jest.fn(),
-            emitToUserInCompany: jest.fn()
-        };
-        const providers = [
-            NotificationService,
-            {
-                provide: 'CACHE_INSTANCE',
-                useValue: {}
-            },
-            {
-                provide: UtilsService,
-                useValue: {
-                    clearCache: jest.fn().mockResolvedValue(undefined)
-                }
-            },
-            {
-                provide: NotificationConfigService,
-                useValue: mockConfig
-            },
-            {
-                provide: NotificationDataSourceProvider,
-                useValue: mockDataSourceProvider
-            }
-        ];
-        if (withGateway) {
-            providers.push({
-                provide: NotificationGateway,
-                useValue: mockGateway
-            });
-        }
-        const module = await Test.createTestingModule({
-            providers
-        }).compile();
-        const resolved = await module.resolve(NotificationService);
-        resolved.repository = mockRepo;
-        return resolved;
-    }
-    beforeEach(async ()=>{
-        service = await buildService();
-    });
-    describe('entity selection', ()=>{
-        it('uses Notification when the company feature is disabled', async ()=>{
-            const built = await buildService(true, false);
-            expect(built['_entity']).toBe(Notification);
-        });
-        it('uses NotificationWithCompany when the company feature is enabled', async ()=>{
-            const built = await buildService(true, true);
-            expect(built['_entity']).toBe(NotificationWithCompany);
-        });
-    });
-    describe('convertSingleDtoToEntity', ()=>{
-        it('builds a new entity for create (no id present)', async ()=>{
-            const user = buildMockUser();
-            const dto = {
-                userId: user.id,
-                title: 'Hello',
-                type: 'success'
-            };
-            const entity = await service.convertSingleDtoToEntity(dto, user);
-            expect(entity).toMatchObject({
-                userId: user.id,
-                title: 'Hello',
-                type: 'success',
-                isRead: false
-            });
-        });
-        it('defaults type to "info" when not provided', async ()=>{
-            const user = buildMockUser();
-            const entity = await service.convertSingleDtoToEntity({
-                userId: user.id,
-                title: 'Hi'
-            }, user);
-            expect(entity.type).toBe('info');
-        });
-        it('merges into the existing entity when updating by id', async ()=>{
-            const existing = buildNotification({
-                id: 'notif-1',
-                title: 'Old title'
-            });
-            mockRepo.findOne.mockResolvedValue(existing);
-            const user = buildMockUser();
-            const entity = await service.convertSingleDtoToEntity({
-                id: 'notif-1',
-                title: 'New title'
-            }, user);
-            expect(mockRepo.findOne).toHaveBeenCalledWith({
-                where: {
-                    id: 'notif-1'
-                }
-            });
-            expect(entity.title).toBe('New title');
-            expect(entity.isRead).toBe(false);
-        });
-        it('throws NotFoundException when updating an id that does not exist', async ()=>{
-            mockRepo.findOne.mockResolvedValue(null);
-            await expect(service.convertSingleDtoToEntity({
-                id: 'missing-id',
-                title: 'X'
-            }, buildMockUser())).rejects.toThrow();
-        });
-        it('includes companyId from the dto when the company feature is enabled', async ()=>{
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const user = buildMockUser({
-                companyId: 'company-user'
-            });
-            const entity = await service.convertSingleDtoToEntity({
-                userId: user.id,
-                title: 'Hi',
-                companyId: 'company-dto'
-            }, user);
-            expect(entity.companyId).toBe('company-dto');
-        });
-        it('falls back to the user companyId when the dto has none and the company feature is enabled', async ()=>{
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const user = buildMockUser({
-                companyId: 'company-user'
-            });
-            const entity = await service.convertSingleDtoToEntity({
-                userId: user.id,
-                title: 'Hi'
-            }, user);
-            expect(entity.companyId).toBe('company-user');
-        });
-        it('does not set companyId when the company feature is disabled', async ()=>{
-            const user = buildMockUser({
-                companyId: 'company-user'
-            });
-            const entity = await service.convertSingleDtoToEntity({
-                userId: user.id,
-                title: 'Hi',
-                companyId: 'company-dto'
-            }, user);
-            expect(entity.companyId).toBeUndefined();
-        });
-    });
-    describe('getFilterQuery', ()=>{
-        it('adds an isRead filter when provided as boolean', async ()=>{
-            const query = createMockQuery();
-            await service.getFilterQuery(query, {
-                isRead: true
-            }, buildMockUser());
-            expect(query.andWhere).toHaveBeenCalledWith('notification.isRead = :isRead', {
-                isRead: true
-            });
-        });
-        it('adds a type filter when provided', async ()=>{
-            const query = createMockQuery();
-            await service.getFilterQuery(query, {
-                type: 'success'
-            }, buildMockUser());
-            expect(query.andWhere).toHaveBeenCalledWith('notification.type = :type', {
-                type: 'success'
-            });
-        });
-        it('adds a userId filter when provided', async ()=>{
-            const query = createMockQuery();
-            await service.getFilterQuery(query, {
-                userId: 'user-9'
-            }, buildMockUser());
-            expect(query.andWhere).toHaveBeenCalledWith('notification.userId = :userId', {
-                userId: 'user-9'
-            });
-        });
-        it('ignores unrecognized filter keys', async ()=>{
-            const query = createMockQuery();
-            await service.getFilterQuery(query, {
-                unknownField: 'x'
-            }, buildMockUser());
-            expect(query.andWhere).not.toHaveBeenCalled();
-        });
-        it('ignores a non-boolean isRead value', async ()=>{
-            const query = createMockQuery();
-            await service.getFilterQuery(query, {
-                isRead: 'true'
-            }, buildMockUser());
-            expect(query.andWhere).not.toHaveBeenCalled();
-        });
-    });
-    describe('getSelectQuery', ()=>{
-        it('always selects createdAt and updatedAt in addition to requested fields', async ()=>{
-            const query = createMockQuery();
-            await service.getSelectQuery(query, buildMockUser(), [
-                'title',
-                'message'
-            ]);
-            expect(query.addSelect).toHaveBeenCalledWith([
-                'notification.title',
-                'notification.message',
-                'notification.createdAt',
-                'notification.updatedAt'
-            ]);
-        });
-        it('selects only createdAt/updatedAt when no fields are requested', async ()=>{
-            const query = createMockQuery();
-            await service.getSelectQuery(query, buildMockUser(), undefined);
-            expect(query.addSelect).toHaveBeenCalledWith([
-                'notification.createdAt',
-                'notification.updatedAt'
-            ]);
-        });
-        it('deduplicates fields already included in the always-selected set', async ()=>{
-            const query = createMockQuery();
-            await service.getSelectQuery(query, buildMockUser(), [
-                'createdAt'
-            ]);
-            expect(query.addSelect).toHaveBeenCalledWith([
-                'notification.createdAt',
-                'notification.updatedAt'
-            ]);
-        });
-    });
-    describe('getExtraManipulateQuery', ()=>{
-        it('scopes the query to the current user', async ()=>{
-            const query = createMockQuery();
-            const user = buildMockUser();
-            await service.getExtraManipulateQuery(query, {}, user);
-            expect(query.andWhere).toHaveBeenCalledWith('notification.userId = :currentUserId', {
-                currentUserId: user.id
-            });
-        });
-        it('applies the company filter when the company feature is enabled', async ()=>{
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const query = createMockQuery();
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            await service.getExtraManipulateQuery(query, {}, user);
-            expect(query.andWhere).toHaveBeenCalledWith('notification.companyId = :companyId', {
-                companyId: 'company-1'
-            });
-        });
-        it('defaults to ordering by createdAt DESC when no sort is provided', async ()=>{
-            const query = createMockQuery();
-            await service.getExtraManipulateQuery(query, {}, buildMockUser());
-            expect(query.orderBy).toHaveBeenCalledWith('notification.createdAt', 'DESC');
-        });
-        it('does not apply a default sort when the caller already specified one', async ()=>{
-            const query = createMockQuery();
-            await service.getExtraManipulateQuery(query, {
-                sort: {
-                    title: 'ASC'
-                }
-            }, buildMockUser());
-            expect(query.orderBy).not.toHaveBeenCalled();
-        });
-        it('does not scope by user when no user is provided', async ()=>{
-            const query = createMockQuery();
-            await service.getExtraManipulateQuery(query, {}, null);
-            expect(query.andWhere).not.toHaveBeenCalledWith(expect.stringContaining('currentUserId'), expect.anything());
-        });
-    });
-    describe('afterInsertOperation', ()=>{
-        it('emits a notification:new event for each inserted entity', async ()=>{
-            const entities = [
-                buildNotification({
-                    id: 'n1'
-                }),
-                buildNotification({
-                    id: 'n2'
-                })
-            ];
-            await service.afterInsertOperation(entities, {}, buildMockUser(), {});
-            expect(mockGateway.emitToUser).toHaveBeenCalledTimes(2);
-            expect(mockGateway.emitToUser).toHaveBeenCalledWith('user-uuid-1', 'notification:new', expect.objectContaining({
-                id: 'n1'
-            }));
-        });
-        it('uses emitToUserInCompany when the entity has a companyId and the company feature is enabled', async ()=>{
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const entities = [
-                buildNotification({
-                    id: 'n1',
-                    companyId: 'company-1'
-                })
-            ];
-            await service.afterInsertOperation(entities, {}, buildMockUser(), {});
-            expect(mockGateway.emitToUserInCompany).toHaveBeenCalledWith('user-uuid-1', 'company-1', 'notification:new', expect.any(Object));
-        });
-    });
-    describe('markAsRead', ()=>{
-        it('marks a matching notification as read and returns it', async ()=>{
-            const user = buildMockUser();
-            const notification = buildNotification({
-                id: 'notif-1',
-                userId: user.id,
-                isRead: false
-            });
-            mockRepo.findOne.mockResolvedValue(notification);
-            mockRepo.save.mockResolvedValue({
-                ...notification,
-                isRead: true
-            });
-            const result = await service.markAsRead('notif-1', user);
-            expect(mockRepo.findOne).toHaveBeenCalledWith({
-                where: {
-                    id: 'notif-1',
-                    userId: user.id
-                }
-            });
-            expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                isRead: true,
-                readAt: expect.any(Date)
-            }));
-            expect(result.isRead).toBe(true);
-            expect(mockGateway.emitToUser).toHaveBeenCalledWith(user.id, 'notification:read', {
-                id: 'notif-1'
-            });
-        });
-        it('throws NotFoundException when the notification does not belong to the user or does not exist', async ()=>{
-            mockRepo.findOne.mockResolvedValue(null);
-            await expect(service.markAsRead('missing-id', buildMockUser())).rejects.toThrow();
-            expect(mockRepo.save).not.toHaveBeenCalled();
-        });
-        it('emits to the company-scoped room when the notification has a companyId', async ()=>{
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            const notification = buildNotification({
-                id: 'notif-1',
-                userId: user.id,
-                companyId: 'company-1'
-            });
-            mockRepo.findOne.mockResolvedValue(notification);
-            mockRepo.save.mockResolvedValue({
-                ...notification,
-                isRead: true
-            });
-            await service.markAsRead('notif-1', user);
-            expect(mockGateway.emitToUserInCompany).toHaveBeenCalledWith(user.id, 'company-1', 'notification:read', {
-                id: 'notif-1'
-            });
-        });
-    });
-    describe('markAllAsRead', ()=>{
-        it('marks all unread notifications as read for the user and returns the affected count', async ()=>{
-            const user = buildMockUser();
-            mockRepo.update.mockResolvedValue({
-                affected: 4,
-                raw: {},
-                generatedMaps: []
-            });
-            const count = await service.markAllAsRead(user);
-            expect(mockRepo.update).toHaveBeenCalledWith({
-                userId: user.id,
-                isRead: false
-            }, {
-                isRead: true,
-                readAt: expect.any(Date)
-            });
-            expect(count).toBe(4);
-            expect(mockGateway.emitToUser).toHaveBeenCalledWith(user.id, 'notification:read-all', {});
-        });
-        it('returns 0 when there is nothing to update (zero unread notifications)', async ()=>{
-            mockRepo.update.mockResolvedValue({
-                affected: 0,
-                raw: {},
-                generatedMaps: []
-            });
-            const count = await service.markAllAsRead(buildMockUser());
-            expect(count).toBe(0);
-        });
-        it('returns 0 when affected is undefined/null', async ()=>{
-            mockRepo.update.mockResolvedValue({
-                affected: undefined,
-                raw: {},
-                generatedMaps: []
-            });
-            const count = await service.markAllAsRead(buildMockUser());
-            expect(count).toBe(0);
-        });
-        it('scopes the update by companyId when the company feature is enabled', async ()=>{
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            mockRepo.update.mockResolvedValue({
-                affected: 1,
-                raw: {},
-                generatedMaps: []
-            });
-            await service.markAllAsRead(user);
-            expect(mockRepo.update).toHaveBeenCalledWith({
-                userId: user.id,
-                isRead: false,
-                companyId: 'company-1'
-            }, expect.any(Object));
-        });
-    });
-    describe('getUnreadCount', ()=>{
-        it('returns the unread count for the user', async ()=>{
-            const user = buildMockUser();
-            mockRepo.count.mockResolvedValue(7);
-            const count = await service.getUnreadCount(user);
-            expect(mockRepo.count).toHaveBeenCalledWith({
-                where: {
-                    userId: user.id,
-                    isRead: false
-                }
-            });
-            expect(count).toBe(7);
-        });
-        it('returns 0 for a user with no unread notifications', async ()=>{
-            mockRepo.count.mockResolvedValue(0);
-            const count = await service.getUnreadCount(buildMockUser());
-            expect(count).toBe(0);
-        });
-        it('scopes the count by companyId when the company feature is enabled', async ()=>{
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            mockRepo.count.mockResolvedValue(2);
-            await service.getUnreadCount(user);
-            expect(mockRepo.count).toHaveBeenCalledWith({
-                where: {
-                    userId: user.id,
-                    isRead: false,
-                    companyId: 'company-1'
-                }
-            });
-        });
-    });
-    describe('without a bound gateway', ()=>{
-        it('does not throw when marking as read and no gateway is registered', async ()=>{
-            const noGatewayService = await buildService(false);
-            const user = buildMockUser();
-            const notification = buildNotification({
-                id: 'notif-1',
-                userId: user.id
-            });
-            mockRepo.findOne.mockResolvedValue(notification);
-            mockRepo.save.mockResolvedValue({
-                ...notification,
-                isRead: true
-            });
-            await expect(noGatewayService.markAsRead('notif-1', user)).resolves.toBeDefined();
-        });
-    });
-    describe('domain events', ()=>{
-        let publish;
-        beforeEach(()=>{
-            publish = jest.fn().mockResolvedValue(undefined);
-            EventBusRegistry.reset();
-            EventBusRegistry.setBus({
-                publish,
-                subscribe: jest.fn(),
-                close: jest.fn()
-            });
-            EventBusRegistry.configureModule('notification', {
-                enabled: true
-            });
-        });
-        afterEach(()=>{
-            EventBusRegistry.reset();
-        });
-        it('publishes notification.notification.read when one is marked read', async ()=>{
-            const user = buildMockUser();
-            const notification = buildNotification({
-                id: 'notif-1',
-                userId: user.id,
-                isRead: false
-            });
-            mockRepo.findOne.mockResolvedValue(notification);
-            mockRepo.save.mockResolvedValue({
-                ...notification,
-                isRead: true
-            });
-            await service.markAsRead('notif-1', user);
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'notification.notification.read',
-                payload: expect.objectContaining({
-                    ids: [
-                        'notif-1'
-                    ]
-                })
-            }));
-        });
-        it('publishes notification.notification.all-read with the affected count', async ()=>{
-            mockRepo.update.mockResolvedValue({
-                affected: 4,
-                raw: {},
-                generatedMaps: []
-            });
-            await service.markAllAsRead(buildMockUser());
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'notification.notification.all-read',
-                payload: expect.objectContaining({
-                    metadata: {
-                        count: 4
-                    }
-                })
-            }));
-        });
-        it('does not publish when the notification module has events disabled', async ()=>{
-            EventBusRegistry.configureModule('notification', {
-                enabled: false
-            });
-            mockRepo.update.mockResolvedValue({
-                affected: 1,
-                raw: {},
-                generatedMaps: []
-            });
-            await service.markAllAsRead(buildMockUser());
-            expect(publish).not.toHaveBeenCalled();
-        });
-    });
-});