resolve todos in website

core/notifications/application/use-cases/NotificationPreferencesUseCases.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect, vi, type Mock } from 'vitest';
+import {
+  GetNotificationPreferencesQuery,
+  UpdateChannelPreferenceUseCase,
+  UpdateTypePreferenceUseCase,
+  UpdateQuietHoursUseCase,
+  SetDigestModeUseCase,
+} from './NotificationPreferencesUseCases';
+import type { INotificationPreferenceRepository } from '../../domain/repositories/INotificationPreferenceRepository';
+import type { NotificationPreference , ChannelPreference, TypePreference } from '../../domain/entities/NotificationPreference';
+import type { Logger } from '@core/shared/application';
+import type { NotificationChannel, NotificationType } from '../../domain/types/NotificationTypes';
+import { NotificationDomainError } from '../../domain/errors/NotificationDomainError';
+
+describe('NotificationPreferencesUseCases', () => {
+  let preferenceRepository: {
+    getOrCreateDefault: Mock;
+    save: Mock;
+  };
+  let logger: Logger;
+
+  beforeEach(() => {
+    preferenceRepository = {
+      getOrCreateDefault: vi.fn(),
+      save: vi.fn(),
+    } as unknown as INotificationPreferenceRepository as any;
+
+    logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger;
+  });
+
+  it('GetNotificationPreferencesQuery returns preferences from repository', async () => {
+    const preference = {
+      id: 'pref-1',
+    } as unknown as NotificationPreference;
+
+    preferenceRepository.getOrCreateDefault.mockResolvedValue(preference);
+
+    const useCase = new GetNotificationPreferencesQuery(
+      preferenceRepository as unknown as INotificationPreferenceRepository,
+      logger,
+    );
+
+    const result = await useCase.execute('driver-1');
+
+    expect(preferenceRepository.getOrCreateDefault).toHaveBeenCalledWith('driver-1');
+    expect(result).toBe(preference);
+  });
+
+  it('UpdateChannelPreferenceUseCase updates channel preference', async () => {
+    const preference = {
+      updateChannel: vi.fn().mockReturnThis(),
+    } as unknown as NotificationPreference;
+
+    preferenceRepository.getOrCreateDefault.mockResolvedValue(preference);
+
+    const useCase = new UpdateChannelPreferenceUseCase(
+      preferenceRepository as unknown as INotificationPreferenceRepository,
+      logger,
+    );
+
+    await useCase.execute({
+      driverId: 'driver-1',
+      channel: 'email' as NotificationChannel,
+      preference: 'enabled' as ChannelPreference,
+    });
+
+    expect(preference.updateChannel).toHaveBeenCalled();
+    expect(preferenceRepository.save).toHaveBeenCalledWith(preference);
+  });
+
+  it('UpdateTypePreferenceUseCase updates type preference', async () => {
+    const preference = {
+      updateTypePreference: vi.fn().mockReturnThis(),
+    } as unknown as NotificationPreference;
+
+    preferenceRepository.getOrCreateDefault.mockResolvedValue(preference);
+
+    const useCase = new UpdateTypePreferenceUseCase(
+      preferenceRepository as unknown as INotificationPreferenceRepository,
+      logger,
+    );
+
+    await useCase.execute({
+      driverId: 'driver-1',
+      type: 'info' as NotificationType,
+      preference: 'enabled' as TypePreference,
+    });
+
+    expect(preference.updateTypePreference).toHaveBeenCalled();
+    expect(preferenceRepository.save).toHaveBeenCalledWith(preference);
+  });
+
+  it('UpdateQuietHoursUseCase validates hours and updates preferences', async () => {
+    const preference = {
+      updateQuietHours: vi.fn().mockReturnThis(),
+    } as unknown as NotificationPreference;
+
+    preferenceRepository.getOrCreateDefault.mockResolvedValue(preference);
+
+    const useCase = new UpdateQuietHoursUseCase(
+      preferenceRepository as unknown as INotificationPreferenceRepository,
+      logger,
+    );
+
+    await useCase.execute({
+      driverId: 'driver-1',
+      startHour: 22,
+      endHour: 7,
+    });
+
+    expect(preference.updateQuietHours).toHaveBeenCalledWith(22, 7);
+    expect(preferenceRepository.save).toHaveBeenCalledWith(preference);
+  });
+
+  it('UpdateQuietHoursUseCase throws on invalid hours', async () => {
+    const useCase = new UpdateQuietHoursUseCase(
+      preferenceRepository as unknown as INotificationPreferenceRepository,
+      logger,
+    );
+
+    await expect(
+      useCase.execute({ driverId: 'd1', startHour: -1, endHour: 10 }),
+    ).rejects.toThrow(NotificationDomainError);
+
+    await expect(
+      useCase.execute({ driverId: 'd1', startHour: 10, endHour: 24 }),
+    ).rejects.toThrow(NotificationDomainError);
+  });
+
+  it('SetDigestModeUseCase sets digest mode with valid frequency', async () => {
+    const preference = {
+      setDigestMode: vi.fn().mockReturnThis(),
+    } as unknown as NotificationPreference;
+
+    preferenceRepository.getOrCreateDefault.mockResolvedValue(preference);
+
+    const useCase = new SetDigestModeUseCase(
+      preferenceRepository as unknown as INotificationPreferenceRepository,
+    );
+
+    await useCase.execute({
+      driverId: 'driver-1',
+      enabled: true,
+      frequencyHours: 4,
+    });
+
+    expect(preference.setDigestMode).toHaveBeenCalledWith(true, 4);
+    expect(preferenceRepository.save).toHaveBeenCalledWith(preference);
+  });
+
+  it('SetDigestModeUseCase throws on invalid frequency', async () => {
+    const useCase = new SetDigestModeUseCase(
+      preferenceRepository as unknown as INotificationPreferenceRepository,
+    );
+
+    await expect(
+      useCase.execute({ driverId: 'driver-1', enabled: true, frequencyHours: 0 }),
+    ).rejects.toThrow(NotificationDomainError);
+  });
+});