fix: Update notification-connector tests for new architecture

- Rewrite tests to match new notification system architecture
- Add storage interface from wireframe
- Fix all test imports and mocks
- Tests now properly test the universal notification system

Author: talkstream

src/connectors/__tests__/notification-connector.test.ts

@@ -1,140 +1,265 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-import { NotificationConnector } from '@/connectors/notification/notification-connector';
-import type { ITelegramConnector } from '@/connectors/telegram/interfaces/telegram-connector.interface';
+import { NotificationConnector } from '../notification-connector';
+import type { INotificationAdapter } from '../../core/interfaces/notification';
+import { NotificationStatus } from '../../core/interfaces/notification';
+import type { ILogger } from '../../core/interfaces/logger';
+import type { IEventBus } from '../../core/interfaces/event-bus';
+import type { IKeyValueStore } from '../../core/interfaces/storage';
 
 describe('NotificationConnector', () => {
-  let notificationConnector: NotificationConnector;
-  let mockTelegramConnector: ITelegramConnector;
+  let connector: NotificationConnector;
+  let mockAdapter: INotificationAdapter;
+  let mockLogger: ILogger;
+  let mockEventBus: IEventBus;
+  let mockStorage: IKeyValueStore;
 
   beforeEach(() => {
     vi.clearAllMocks();
 
-    mockTelegramConnector = {
-      sendMessage: vi.fn().mockResolvedValue(undefined),
-    } as unknown as ITelegramConnector;
-
-    notificationConnector = new NotificationConnector(mockTelegramConnector);
+    mockAdapter = {
+      formatMessage: vi.fn().mockResolvedValue({ text: 'formatted message' }),
+      deliver: vi.fn().mockResolvedValue(undefined),
+      checkReachability: vi.fn().mockResolvedValue(true),
+      isRetryableError: vi.fn().mockReturnValue(true),
+      getUserInfo: vi.fn().mockResolvedValue({ locale: 'en' }),
+    };
+
+    mockLogger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      child: vi.fn().mockReturnThis(),
+    };
+
+    mockEventBus = {
+      emit: vi.fn(),
+      on: vi.fn(),
+      off: vi.fn(),
+      once: vi.fn(),
+    };
+
+    mockStorage = {
+      get: vi.fn().mockResolvedValue(null),
+      put: vi.fn().mockResolvedValue(undefined),
+      delete: vi.fn().mockResolvedValue(undefined),
+      list: vi.fn().mockResolvedValue({ keys: [] }),
+    };
+
+    connector = new NotificationConnector({
+      adapter: mockAdapter,
+      storage: mockStorage,
+      logger: mockLogger,
+      eventBus: mockEventBus,
+    });
   });
 
-  describe('sendNotification', () => {
+  describe('send', () => {
     it('should send notification successfully', async () => {
-      const result = await notificationConnector.sendNotification(123456, 'Test message');
-
-      expect(result).toBe(true);
-      expect(mockTelegramConnector.sendMessage).toHaveBeenCalledWith(123456, 'Test message');
-      expect(mockTelegramConnector.sendMessage).toHaveBeenCalledTimes(1);
+      const message = {
+        id: 'msg_123',
+        recipientId: 'user_123',
+        template: 'welcome',
+        category: 'system' as const,
+        priority: 'medium' as const,
+        params: { name: 'John' },
+      };
+
+      const result = await connector.send(message);
+
+      expect(result.status).toBe(NotificationStatus.SENT);
+      expect(result.messageId).toBe('msg_123');
+      expect(result.deliveredAt).toBeDefined();
+      expect(mockAdapter.deliver).toHaveBeenCalledWith('user_123', { text: 'formatted message' });
+      expect(mockEventBus.emit).toHaveBeenCalledWith('notification:sent', expect.any(Object));
     });
 
-    it('should retry on failure', async () => {
-      vi.mocked(mockTelegramConnector.sendMessage)
-        .mockRejectedValueOnce(new Error('Temporary error'))
-        .mockRejectedValueOnce(new Error('Temporary error'))
-        .mockResolvedValueOnce(undefined);
-
-      const result = await notificationConnector.sendNotification(123456, 'Test message');
-
-      expect(result).toBe(true);
-      expect(mockTelegramConnector.sendMessage).toHaveBeenCalledTimes(3);
-    });
+    it('should handle unreachable recipient', async () => {
+      vi.mocked(mockAdapter.checkReachability).mockResolvedValueOnce(false);
 
-    it('should return false after max retries', async () => {
-      vi.mocked(mockTelegramConnector.sendMessage).mockRejectedValue(new Error('Persistent error'));
+      const message = {
+        id: 'msg_123',
+        recipientId: 'user_123',
+        template: 'welcome',
+        category: 'system' as const,
+        priority: 'medium' as const,
+      };
 
-      const result = await notificationConnector.sendNotification(123456, 'Test message');
+      const result = await connector.send(message);
 
-      expect(result).toBe(false);
-      expect(mockTelegramConnector.sendMessage).toHaveBeenCalledTimes(3);
+      expect(result.status).toBe(NotificationStatus.BLOCKED);
+      expect(result.error).toBe('Recipient is not reachable');
+      expect(mockAdapter.deliver).not.toHaveBeenCalled();
+      expect(mockEventBus.emit).toHaveBeenCalledWith('notification:blocked', expect.any(Object));
     });
 
-    it('should not retry if user blocked the bot', async () => {
-      vi.mocked(mockTelegramConnector.sendMessage).mockRejectedValueOnce(
-        new Error('Bot was blocked by the user'),
+    it('should retry on retryable error', async () => {
+      const error = new Error('Temporary error');
+      vi.mocked(mockAdapter.deliver).mockRejectedValueOnce(error);
+      vi.mocked(mockAdapter.isRetryableError).mockReturnValueOnce(true);
+
+      const message = {
+        id: 'msg_123',
+        recipientId: 'user_123',
+        template: 'welcome',
+        category: 'system' as const,
+        priority: 'medium' as const,
+      };
+
+      const result = await connector.send(message);
+
+      expect(result.status).toBe(NotificationStatus.RETRY);
+      expect(result.retryCount).toBe(1);
+      expect(result.nextRetryAt).toBeDefined();
+      expect(mockEventBus.emit).toHaveBeenCalledWith(
+        'notification:failed',
+        expect.objectContaining({
+          willRetry: true,
+        }),
       );
-
-      const result = await notificationConnector.sendNotification(123456, 'Test message');
-
-      expect(result).toBe(false);
-      expect(mockTelegramConnector.sendMessage).toHaveBeenCalledTimes(1);
     });
 
-    it('should detect various blocked user errors', async () => {
-      const blockedErrors = [
-        'Bot was blocked by the user',
-        'User is deactivated',
-        'Chat not found',
-        'Forbidden: bot was blocked',
-      ];
-
-      for (const errorMessage of blockedErrors) {
-        vi.clearAllMocks();
-        vi.mocked(mockTelegramConnector.sendMessage).mockRejectedValueOnce(new Error(errorMessage));
-
-        const result = await notificationConnector.sendNotification(123456, 'Test message');
-
-        expect(result).toBe(false);
-        expect(mockTelegramConnector.sendMessage).toHaveBeenCalledTimes(1);
-      }
+    it('should fail after max retries', async () => {
+      const error = new Error('Persistent error');
+      vi.mocked(mockAdapter.deliver).mockRejectedValue(error);
+      vi.mocked(mockAdapter.isRetryableError).mockReturnValue(false);
+
+      const message = {
+        id: 'msg_123',
+        recipientId: 'user_123',
+        template: 'welcome',
+        category: 'system' as const,
+        priority: 'medium' as const,
+        metadata: { retryCount: 3 },
+      };
+
+      const result = await connector.send(message);
+
+      expect(result.status).toBe(NotificationStatus.FAILED);
+      expect(result.error).toBe('Persistent error');
+      expect(mockEventBus.emit).toHaveBeenCalledWith(
+        'notification:failed',
+        expect.objectContaining({
+          willRetry: false,
+        }),
+      );
     });
   });
 
-  describe('sendBatchNotifications', () => {
+  describe('sendBatch', () => {
     it('should send notifications in batches', async () => {
-      const notifications = Array.from({ length: 75 }, (_, i) => ({
-        userId: 100 + i,
-        message: `Message ${i}`,
+      const messages = Array.from({ length: 25 }, (_, i) => ({
+        id: `msg_${i}`,
+        recipientId: `user_${i}`,
+        template: 'announcement',
+        category: 'system' as const,
+        priority: 'low' as const,
       }));
 
-      await notificationConnector.sendBatchNotifications(notifications);
-
-      // Should be called 75 times (once for each notification)
-      expect(mockTelegramConnector.sendMessage).toHaveBeenCalledTimes(75);
-
-      // Check first and last calls
-      expect(mockTelegramConnector.sendMessage).toHaveBeenNthCalledWith(1, 100, 'Message 0');
-      expect(mockTelegramConnector.sendMessage).toHaveBeenNthCalledWith(75, 174, 'Message 74');
+      const results = await connector.sendBatch(messages, {
+        batchSize: 10,
+        delayBetweenBatches: 100,
+      });
+
+      expect(results).toHaveLength(25);
+      expect(results.every((r) => r.status === NotificationStatus.SENT)).toBe(true);
+      expect(mockAdapter.deliver).toHaveBeenCalledTimes(25);
+      expect(mockEventBus.emit).toHaveBeenCalledWith(
+        'notification:batch:started',
+        expect.any(Object),
+      );
+      expect(mockEventBus.emit).toHaveBeenCalledWith(
+        'notification:batch:completed',
+        expect.any(Object),
+      );
     });
 
-    it('should handle failures gracefully in batch', async () => {
-      // Set up mixed success/failure responses
-      vi.mocked(mockTelegramConnector.sendMessage)
-        .mockResolvedValueOnce(undefined) // First message success
-        .mockRejectedValue(new Error('Failed')); // All others fail
+    it('should handle failures in batch gracefully', async () => {
+      vi.mocked(mockAdapter.deliver)
+        .mockResolvedValueOnce(undefined)
+        .mockRejectedValueOnce(new Error('Failed'))
+        .mockResolvedValueOnce(undefined);
 
-      const notifications = [
-        { userId: 111, message: 'Message 1' },
-        { userId: 222, message: 'Message 2' },
-        { userId: 333, message: 'Message 3' },
+      const messages = [
+        {
+          id: 'msg_1',
+          recipientId: 'user_1',
+          template: 'test',
+          category: 'system' as const,
+          priority: 'low' as const,
+        },
+        {
+          id: 'msg_2',
+          recipientId: 'user_2',
+          template: 'test',
+          category: 'system' as const,
+          priority: 'low' as const,
+        },
+        {
+          id: 'msg_3',
+          recipientId: 'user_3',
+          template: 'test',
+          category: 'system' as const,
+          priority: 'low' as const,
+        },
       ];
 
-      // Just verify it completes without throwing
-      await expect(
-        notificationConnector.sendBatchNotifications(notifications),
-      ).resolves.toBeUndefined();
+      const results = await connector.sendBatch(messages, {
+        batchSize: 10,
+        delayBetweenBatches: 0,
+      });
 
-      // Verify at least the first successful call was made
-      expect(mockTelegramConnector.sendMessage).toHaveBeenCalledWith(111, 'Message 1');
+      expect(results).toHaveLength(3);
+      expect(results[0].status).toBe(NotificationStatus.SENT);
+      expect(results[1].status).toBe(NotificationStatus.RETRY);
+      expect(results[2].status).toBe(NotificationStatus.SENT);
     });
+  });
 
-    it('should delay between batches', async () => {
-      const notifications = Array.from({ length: 31 }, (_, i) => ({
-        userId: 100 + i,
-        message: `Message ${i}`,
-      }));
+  describe('isReachable', () => {
+    it('should return adapter reachability check result', async () => {
+      const result = await connector.isReachable('user_123');
+      expect(result).toBe(true);
+      expect(mockAdapter.checkReachability).toHaveBeenCalledWith('user_123');
+    });
+
+    it('should handle adapter errors gracefully', async () => {
+      vi.mocked(mockAdapter.checkReachability).mockRejectedValueOnce(new Error('Check failed'));
+
+      const result = await connector.isReachable('user_123');
+      expect(result).toBe(false);
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+  });
 
-      const start = Date.now();
-      await notificationConnector.sendBatchNotifications(notifications);
-      const duration = Date.now() - start;
+  describe('getStatus', () => {
+    it('should retrieve stored notification status', async () => {
+      const storedResult = {
+        messageId: 'msg_123',
+        status: NotificationStatus.SENT,
+        deliveredAt: new Date(),
+      };
+      vi.mocked(mockStorage.get).mockResolvedValueOnce(JSON.stringify(storedResult));
+
+      const result = await connector.getStatus('msg_123');
+      expect(result).toEqual(storedResult);
+    });
 
-      // Should have delayed at least 1000ms between batches
-      expect(duration).toBeGreaterThanOrEqual(1000);
-      expect(mockTelegramConnector.sendMessage).toHaveBeenCalledTimes(31);
+    it('should return null when status not found', async () => {
+      const result = await connector.getStatus('msg_123');
+      expect(result).toBeNull();
     });
 
-    it('should handle empty notifications array', async () => {
-      await notificationConnector.sendBatchNotifications([]);
+    it('should return null when storage not available', async () => {
+      const connectorWithoutStorage = new NotificationConnector({
+        adapter: mockAdapter,
+        logger: mockLogger,
+        eventBus: mockEventBus,
+      });
 
-      expect(mockTelegramConnector.sendMessage).not.toHaveBeenCalled();
+      const result = await connectorWithoutStorage.getStatus('msg_123');
+      expect(result).toBeNull();
     });
   });
 });