@flusys/nestjs-event-manager 7.1.0 → 8.0.0

package/cjs/services/event-manager-helper.service.spec.js

@@ -1,327 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _common = require("@nestjs/common");
-const _nestjsshared = require("@flusys/nestjs-shared");
-const _repositorymock = require("@test-utils/mocks/repository.mock");
-const _config = require("../config");
-const _entities = require("../entities");
-const _eventmanagerhelperservice = require("./event-manager-helper.service");
-function buildEvent(overrides = {}) {
-    return {
-        id: 'event-uuid-1',
-        title: 'Sprint Planning',
-        description: null,
-        eventDate: '2026-04-03',
-        startTime: '09:00',
-        endTime: '10:00',
-        isAllDay: false,
-        recurrenceType: _nestjsshared.RecurrenceType.NONE,
-        recurrenceEndDate: null,
-        weekDays: null,
-        color: '#3B82F6',
-        meetingLink: null,
-        isActive: true,
-        createdAt: new Date('2026-01-01T00:00:00Z'),
-        updatedAt: new Date('2026-01-01T00:00:00Z'),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-function buildParticipant(overrides = {}) {
-    return {
-        id: 'participant-uuid-1',
-        eventId: 'event-uuid-1',
-        userId: 'user-uuid-1',
-        status: _nestjsshared.ParticipantStatus.PENDING,
-        isOrganizer: false,
-        createdAt: new Date('2026-01-01T00:00:00Z'),
-        updatedAt: new Date('2026-01-01T00:00:00Z'),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-describe('EventManagerHelperService', ()=>{
-    let service;
-    let mockEventRepo;
-    let mockParticipantRepo;
-    let mockConfigService;
-    let mockDataSourceProvider;
-    let mockUtilsService;
-    // `getRawMany` isn't part of the shared MockQueryBuilder — the participant queries in this
-    // service use `.getRawMany()`, so we augment the shared mock query builder instances here.
-    let mockEventQb;
-    let mockParticipantQb;
-    beforeEach(()=>{
-        mockEventRepo = (0, _repositorymock.createMockRepository)();
-        mockParticipantRepo = (0, _repositorymock.createMockRepository)();
-        mockEventQb = mockEventRepo.createQueryBuilder();
-        mockEventQb.getRawMany = jest.fn();
-        mockParticipantQb = mockParticipantRepo.createQueryBuilder();
-        mockParticipantQb.getRawMany = jest.fn();
-        mockConfigService = {
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false),
-            getDefaultColor: jest.fn().mockReturnValue('#3B82F6')
-        };
-        const fakeDataSource = {
-            getRepository: jest.fn((entity)=>entity === _entities.EventParticipant ? mockParticipantRepo : mockEventRepo)
-        };
-        mockDataSourceProvider = {
-            getDataSource: jest.fn().mockResolvedValue(fakeDataSource)
-        };
-        mockUtilsService = {
-            clearCache: jest.fn()
-        };
-        service = new _eventmanagerhelperservice.EventManagerHelperService({}, mockUtilsService, mockConfigService, mockDataSourceProvider);
-    });
-    describe('createEvent', ()=>{
-        it('creates a timed event with the given fields and clears the cache', async ()=>{
-            const saved = buildEvent();
-            mockEventRepo.save.mockResolvedValue(saved);
-            mockParticipantRepo.save.mockResolvedValue([]);
-            const result = await service.createEvent({
-                title: 'Sprint Planning',
-                eventDate: '2026-04-03',
-                startTime: '09:00',
-                endTime: '10:00'
-            });
-            expect(mockEventRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                title: 'Sprint Planning',
-                startTime: '09:00',
-                endTime: '10:00',
-                isAllDay: false,
-                recurrenceType: _nestjsshared.RecurrenceType.NONE,
-                color: '#3B82F6'
-            }));
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('event', {});
-            expect(result.id).toBe(saved.id);
-            expect(result.companyId).toBeNull();
-        });
-        it('forces symbolic 00:00 / 23:59 markers for all-day events regardless of supplied times', async ()=>{
-            const saved = buildEvent({
-                isAllDay: true,
-                startTime: '00:00',
-                endTime: '23:59'
-            });
-            mockEventRepo.save.mockResolvedValue(saved);
-            await service.createEvent({
-                title: 'Company Holiday',
-                eventDate: '2026-12-25',
-                startTime: '09:00',
-                endTime: '17:00',
-                isAllDay: true
-            });
-            expect(mockEventRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                isAllDay: true,
-                startTime: '00:00',
-                endTime: '23:59'
-            }));
-        });
-        it('attaches companyId only when the company feature is enabled and a companyId is supplied', async ()=>{
-            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
-            const saved = buildEvent();
-            mockEventRepo.save.mockResolvedValue(saved);
-            await service.createEvent({
-                title: 'Sprint Planning',
-                eventDate: '2026-04-03',
-                startTime: '09:00',
-                endTime: '10:00',
-                companyId: 'company-uuid-1'
-            });
-            expect(mockEventRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                companyId: 'company-uuid-1'
-            }));
-        });
-        it('does not attach companyId when the company feature is disabled, even if supplied', async ()=>{
-            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
-            const saved = buildEvent();
-            mockEventRepo.save.mockResolvedValue(saved);
-            await service.createEvent({
-                title: 'Sprint Planning',
-                eventDate: '2026-04-03',
-                startTime: '09:00',
-                endTime: '10:00',
-                companyId: 'company-uuid-1'
-            });
-            const savedArg = mockEventRepo.save.mock.calls[0][0];
-            expect(savedArg).not.toHaveProperty('companyId');
-        });
-        it('adds the organizer and all participants with PENDING status, de-duplicated', async ()=>{
-            const saved = buildEvent();
-            mockEventRepo.save.mockResolvedValue(saved);
-            mockParticipantRepo.save.mockResolvedValue([]);
-            await service.createEvent({
-                title: 'Sprint Planning',
-                eventDate: '2026-04-03',
-                startTime: '09:00',
-                endTime: '10:00',
-                organizerId: 'organizer-uuid-1',
-                participantIds: [
-                    'organizer-uuid-1',
-                    'participant-uuid-2'
-                ]
-            });
-            const savedParticipants = mockParticipantRepo.save.mock.calls[0][0];
-            expect(savedParticipants).toHaveLength(2);
-            expect(savedParticipants).toEqual(expect.arrayContaining([
-                expect.objectContaining({
-                    userId: 'organizer-uuid-1',
-                    isOrganizer: true,
-                    status: _nestjsshared.ParticipantStatus.PENDING
-                }),
-                expect.objectContaining({
-                    userId: 'participant-uuid-2',
-                    isOrganizer: false,
-                    status: _nestjsshared.ParticipantStatus.PENDING
-                })
-            ]));
-        });
-        it('skips participant creation entirely when no organizer or participants are given', async ()=>{
-            const saved = buildEvent();
-            mockEventRepo.save.mockResolvedValue(saved);
-            await service.createEvent({
-                title: 'Sprint Planning',
-                eventDate: '2026-04-03',
-                startTime: '09:00',
-                endTime: '10:00'
-            });
-            expect(mockParticipantRepo.save).not.toHaveBeenCalled();
-        });
-    });
-    describe('updateParticipantStatus', ()=>{
-        it('updates the status of an existing participant', async ()=>{
-            const participant = buildParticipant({
-                status: _nestjsshared.ParticipantStatus.PENDING
-            });
-            mockParticipantRepo.findOne.mockResolvedValue(participant);
-            mockParticipantRepo.save.mockResolvedValue({
-                ...participant,
-                status: _nestjsshared.ParticipantStatus.ACCEPTED
-            });
-            await service.updateParticipantStatus('participant-uuid-1', _nestjsshared.ParticipantStatus.ACCEPTED);
-            expect(mockParticipantRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                status: _nestjsshared.ParticipantStatus.ACCEPTED
-            }));
-        });
-        it('throws NotFoundException with the correct messageKey when the participant does not exist', async ()=>{
-            mockParticipantRepo.findOne.mockResolvedValue(null);
-            await expect(service.updateParticipantStatus('missing-uuid', _nestjsshared.ParticipantStatus.ACCEPTED)).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: _config.EVENT_PARTICIPANT_MESSAGES.NOT_FOUND
-                })
-            });
-            await expect(service.updateParticipantStatus('missing-uuid', _nestjsshared.ParticipantStatus.ACCEPTED)).rejects.toBeInstanceOf(_common.NotFoundException);
-        });
-    });
-    describe('getEventsForUser', ()=>{
-        it('returns an empty list without querying events when the user has no participant rows', async ()=>{
-            mockParticipantQb.getRawMany.mockResolvedValue([]);
-            const result = await service.getEventsForUser('user-uuid-1', '2026-04-01', '2026-04-30');
-            expect(result).toEqual([]);
-            expect(mockEventQb.getMany).not.toHaveBeenCalled();
-            expect(mockEventQb.where).not.toHaveBeenCalled();
-        });
-        it('queries events scoped to the participant event ids and date range', async ()=>{
-            mockParticipantQb.getRawMany.mockResolvedValue([
-                {
-                    ep_event_id: 'event-uuid-1'
-                }
-            ]);
-            const events = [
-                buildEvent()
-            ];
-            mockEventQb.getMany.mockResolvedValue(events);
-            const result = await service.getEventsForUser('user-uuid-1', '2026-04-01', '2026-04-30');
-            const eventQb = mockEventQb;
-            expect(eventQb.where).toHaveBeenCalledWith('event.id IN (:...eventIds)', {
-                eventIds: [
-                    'event-uuid-1'
-                ]
-            });
-            expect(eventQb.andWhere).toHaveBeenCalledWith('event.eventDate <= :endDate', {
-                endDate: '2026-04-30'
-            });
-            expect(eventQb.andWhere).toHaveBeenCalledWith('event.eventDate >= :startDate', {
-                startDate: '2026-04-01'
-            });
-            expect(result).toHaveLength(1);
-            expect(result[0].id).toBe('event-uuid-1');
-        });
-        it('handles a zero-length range (startDate === endDate)', async ()=>{
-            mockParticipantQb.getRawMany.mockResolvedValue([
-                {
-                    ep_event_id: 'event-uuid-1'
-                }
-            ]);
-            mockEventQb.getMany.mockResolvedValue([
-                buildEvent()
-            ]);
-            const result = await service.getEventsForUser('user-uuid-1', '2026-04-03', '2026-04-03');
-            const eventQb = mockEventQb;
-            expect(eventQb.andWhere).toHaveBeenCalledWith('event.eventDate <= :endDate', {
-                endDate: '2026-04-03'
-            });
-            expect(eventQb.andWhere).toHaveBeenCalledWith('event.eventDate >= :startDate', {
-                startDate: '2026-04-03'
-            });
-            expect(result).toHaveLength(1);
-        });
-        it('scopes the query to the company when the company feature is enabled and a companyId is given', async ()=>{
-            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
-            mockParticipantQb.getRawMany.mockResolvedValue([
-                {
-                    ep_event_id: 'event-uuid-1'
-                }
-            ]);
-            mockEventQb.getMany.mockResolvedValue([
-                buildEvent()
-            ]);
-            await service.getEventsForUser('user-uuid-1', '2026-04-01', '2026-04-30', 'company-uuid-1');
-            const eventQb = mockEventQb;
-            expect(eventQb.andWhere).toHaveBeenCalledWith('event.companyId = :companyId', {
-                companyId: 'company-uuid-1'
-            });
-        });
-        it('does not scope the query to the company when the company feature is disabled', async ()=>{
-            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
-            mockParticipantQb.getRawMany.mockResolvedValue([
-                {
-                    ep_event_id: 'event-uuid-1'
-                }
-            ]);
-            mockEventQb.getMany.mockResolvedValue([
-                buildEvent()
-            ]);
-            await service.getEventsForUser('user-uuid-1', '2026-04-01', '2026-04-30', 'company-uuid-1');
-            const eventQb = mockEventQb;
-            const companyCalls = eventQb.andWhere.mock.calls.filter((call)=>call[0] === 'event.companyId = :companyId');
-            expect(companyCalls).toHaveLength(0);
-        });
-        it('requests the correct entity for the company feature toggle', async ()=>{
-            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
-            mockParticipantQb.getRawMany.mockResolvedValue([]);
-            await service.getEventsForUser('user-uuid-1', '2026-04-01', '2026-04-30');
-            const fakeDataSource = await mockDataSourceProvider.getDataSource();
-            expect(fakeDataSource.getRepository).toHaveBeenCalledWith(_entities.EventWithCompany);
-        });
-    });
-    describe('getEventById', ()=>{
-        it('returns the mapped event when found', async ()=>{
-            mockEventRepo.findOne.mockResolvedValue(buildEvent());
-            const result = await service.getEventById('event-uuid-1');
-            expect(result?.id).toBe('event-uuid-1');
-        });
-        it('returns null when the event does not exist', async ()=>{
-            mockEventRepo.findOne.mockResolvedValue(null);
-            const result = await service.getEventById('missing-uuid');
-            expect(result).toBeNull();
-        });
-    });
-});