http-request-manager 18.15.34 → 18.16.1

package/src/lib/services/ws-manager-service/websocket-services-complete.spec.ts

@@ -1,596 +0,0 @@
-/**
- * WebSocket Services Test Suite
- * Based on RequestManagerWsDemoComponent and related services
- * Tests StateServiceDemo, MessageServiceDemo, NotificationServiceDemo
- */
-import { TestBed } from '@angular/core/testing';
-import { of } from 'rxjs';
-import { HTTPManagerStateService } from '../../services/request-manager-state-service/http-manager-state.store';
-import { HTTPManagerService } from '../../services/request-manager-services/http-manager.service';
-import { DatabaseManagerService } from '../../services/database-manager-service/database.manager.service';
-import { LocalStorageManagerService } from '../../services/local-storage-manager-service/local-storage-manager.service';
-import { WebSocketManagerService } from '../../services/ws-manager-service/websocket-service';
-import { MessageTrackerService } from '../../services/ws-manager-service/message-tracker.service';
-import { UtilsService } from '../../services/utils/utils.service';
-import { LoggerService } from '../../services/utils/logger.service';
-
-// Mock Demo Services since they are not in the library core
-class StateServiceDemo {
-  constructor(private httpManagerState: HTTPManagerStateService<any>) {}
-  updateConnection(server: string, wsServer: string, token: string, user: any, path?: any) {
-    this.httpManagerState.setApiRequestOptions({ server, path: path || ['ai', 'tests'], ws: { id: (path || ['ai', 'tests']).join('/'), wsServer, jwtToken: token, user } } as any);
-    this.httpManagerState.userAction$.subscribe((action: any) => {});
-  }
-  getAllChannels() { this.httpManagerState.getAllChannels(); }
-  subscribeToChannel(c: string) { this.httpManagerState.subscribeToChannel(c); }
-  unsubscribeFromChannel(c: string) { this.httpManagerState.unsubscribeFromChannel(c); }
-  createNotificationChannel(c: string) { this.httpManagerState.createNotificationChannel(c); }
-  getNotificationChannels() { this.httpManagerState.getNotificationChannels(); }
-  getTodaysNotificationChannels() { this.httpManagerState.getTodaysNotificationChannels(); }
-  definePreviousNotificationChannels() { /* Not implemented in store */ }
-  subscribeToNotificationChannel(c: string, o: any = {}, u: any = {}) { this.httpManagerState.subscribeToNotificationChannel(c, o, u); }
-  unsubscribeFromNotificationChannel(c: string) { this.httpManagerState.unsubscribeFromNotificationChannel(c); }
-  sendNotification(c: string, m: any) { this.httpManagerState.sendNotification(c, m); }
-  getData() { this.httpManagerState.fetchRecords(); }
-  addData(d: any) { this.httpManagerState.createRecord(d, undefined); }
-  updateData(d: any) { this.httpManagerState.updateRecord(d, undefined); }
-  deleteData(id: any) { this.httpManagerState.deleteRecord(undefined); }
-  clearRecords() { this.httpManagerState.clearRecords(); }
-}
-
-class MessageServiceDemo {
-  constructor(private httpManagerState: HTTPManagerStateService<any>) {}
-  createChannel(c: string) { this.httpManagerState.createChannel(c.startsWith('PUB-') ? c : 'PUB-' + c); }
-  getAllChannels() { this.httpManagerState.getAllChannels(); }
-  subscribeToChannel(c: string) { this.httpManagerState.subscribeToChannel(c.startsWith('PUB-') ? c : 'PUB-' + c); }
-  unsubscribeFromChannel(c: string) { this.httpManagerState.unsubscribeFromChannel(c.startsWith('PUB-') ? c : 'PUB-' + c); }
-  sendMessage(m: any, c?: string[]) { this.httpManagerState.wsMessaging(m, c); }
-  get channels$() { return this.httpManagerState.channels$; }
-  get subscribedChannels$() { return this.httpManagerState.subscribedChannels$; }
-  get communicationMessages$() { return this.httpManagerState.communicationMessages$; }
-  get latestCommunicationMessages$() { return this.httpManagerState.latestCommunicationMessages$; }
-  get connectionStatus$() { return this.httpManagerState.connectionStatus$; }
-  get user$() { return this.httpManagerState.user$; }
-  get data$() { return this.httpManagerState.data$; }
-}
-
-class NotificationServiceDemo {
-  constructor(private httpManagerState: HTTPManagerStateService<any>) {}
-  createNotificationChannel(c: string) { this.httpManagerState.createNotificationChannel(c); }
-  getNotificationChannels() { this.httpManagerState.getNotificationChannels(); }
-  getTodaysNotificationChannels() { this.httpManagerState.getTodaysNotificationChannels(); }
-  definePreviousNotificationChannels() { /* Not implemented in store */ }
-  subscribeToNotificationChannel(c: string, o: any = {}, u: any = {}) { this.httpManagerState.subscribeToNotificationChannel(c, o, u); }
-  unsubscribeFromNotificationChannel(c: string) { this.httpManagerState.unsubscribeFromNotificationChannel(c); }
-  sendNotification(c: string, m: any) { this.httpManagerState.sendNotification(c, m); }
-  get subscribedNotificationChannels$() { return this.httpManagerState.subscribedChannels$; }
-  get notificationChannels$() { return this.httpManagerState.notificationChannels$; }
-  get todaysNotificationChannels$() { return this.httpManagerState.todaysNotificationChannels$; }
-  get notificationMessages$() { return this.httpManagerState.notificationMessages$; }
-  get latestNotification$() { return this.httpManagerState.latestNotification$; }
-  get connectionStatus$() { return this.httpManagerState.connectionStatus$; }
-}
-
-describe('WebSocket Services - Complete Test Suite', () => {
-  let stateService: StateServiceDemo;
-  let messageService: MessageServiceDemo;
-  let notificationService: NotificationServiceDemo;
-  let httpManagerStateSpy: jasmine.SpyObj<HTTPManagerStateService<any>>;
-  let httpManagerServiceSpy: jasmine.SpyObj<HTTPManagerService<any>>;
-  let dbManagerSpy: jasmine.SpyObj<DatabaseManagerService>;
-  let localStorageManagerSpy: jasmine.SpyObj<LocalStorageManagerService>;
-  let wsManagerSpy: jasmine.SpyObj<WebSocketManagerService>;
-  let messageTrackerSpy: jasmine.SpyObj<MessageTrackerService>;
-  let utilsSpy: jasmine.SpyObj<UtilsService>;
-  let loggerSpy: jasmine.SpyObj<LoggerService>;
-
-  const mockServer = 'https://api.example.com';
-  const mockWsServer = 'wss://ws.example.com';
-  const mockJwtToken = 'test-jwt-token';
-  const mockUser = { id: 'user123', name: 'Test User', email: 'test@example.com' };
-  const mockPath = ['ai', 'tests'];
-
-  beforeEach(() => {
-    httpManagerStateSpy = jasmine.createSpyObj('HTTPManagerStateService', [
-      'setApiRequestOptions', 'getData', 'fetchRecords', 'fetchRecord',
-      'createRecord', 'updateRecord', 'deleteRecord', 'clearRecords',
-      'subscribeToChannel', 'unsubscribeFromChannel', 'createChannel', 'getAllChannels',
-      'createNotificationChannel', 'getNotificationChannels', 'getTodaysNotificationChannels',
-      'definePreviousNotificationChannels', 'subscribeToNotificationChannel', 'unsubscribeFromNotificationChannel', 'sendNotification', 'wsMessaging'
-    ], {
-      data$: jasmine.createSpy('data$'),
-      isPending$: jasmine.createSpy('isPending$'),
-      error$: jasmine.createSpy('error$'),
-      connectionStatus$: jasmine.createSpy('connectionStatus$'),
-      wsRetryAttempts$: jasmine.createSpy('wsRetryAttempts$'),
-      wsNextRetry$: jasmine.createSpy('wsNextRetry$'),
-      user$: jasmine.createSpy('user$'),
-      channels$: jasmine.createSpy('channels$'),
-      messages$: jasmine.createSpy('messages$'),
-      subscribedChannels$: jasmine.createSpy('subscribedChannels$'),
-      communicationMessages$: jasmine.createSpy('communicationMessages$'),
-      latestCommunicationMessages$: jasmine.createSpy('latestCommunicationMessages$'),
-      notificationMessages$: jasmine.createSpy('notificationMessages$'),
-      latestNotification$: jasmine.createSpy('latestNotification$'),
-      notificationChannels$: jasmine.createSpy('notificationChannels$'),
-      todaysNotificationChannels$: jasmine.createSpy('todaysNotificationChannels$'),
-      userAction$: { subscribe: jasmine.createSpy('subscribe') },
-      userList$: jasmine.createSpy('userList$')
-    });
-
-    httpManagerServiceSpy = jasmine.createSpyObj('HTTPManagerService', [
-      'getRequest', 'postRequest', 'putRequest', 'deleteRequest',
-      'connect', 'disconnect', 'subscribeToChannel', 'unsubscribeFromChannel',
-      'getAllChannels', 'createChannel', 'deleteChannel', 'getUsersInChannel',
-      'createNotificationChannel', 'getNotificationChannels', 'getTodaysNotificationChannels',
-      'subscribeToNotificationChannel', 'unsubscribeFromNotificationChannel', 'sendNotification'
-    ], {
-      isPending$: jasmine.createSpy('isPending$'),
-      countdown$: jasmine.createSpy('countdown$'),
-      error$: jasmine.createSpy('error$'),
-      connectionStatus$: jasmine.createSpy('connectionStatus$'),
-      messages$: jasmine.createSpy('messages$'),
-      subscribedChannels$: jasmine.createSpy('subscribedChannels$')
-    });
-
-    dbManagerSpy = jasmine.createSpyObj('DatabaseManagerService', [
-      'createDatabaseTable', 'getDatabaseTables', 'hasDatabaseTable',
-      'getTableRecords', 'createTableRecord', 'updateTableRecord', 'deleteTableRecord'
-    ]);
-
-    localStorageManagerSpy = jasmine.createSpyObj('LocalStorageManagerService', [
-      'createStore', 'updateStore', 'store$', 'stores$'
-    ]);
-
-    wsManagerSpy = jasmine.createSpyObj('WebSocketManagerService', [
-      'connect', 'disconnect', 'subscribeToChannel', 'unsubscribeFromChannel',
-      'sendBroadcast', 'sendMessageInChannel', 'sendChannelMessage',
-      'getSubscribedChannels', 'addSubscribedChannel'
-    ], {
-      connectionStatus$: jasmine.createSpy('connectionStatus$'),
-      isConnected: jasmine.createSpy('isConnected').and.returnValue(true)
-    });
-
-    messageTrackerSpy = jasmine.createSpyObj('MessageTrackerService', [
-      'subscribeToChannel'
-    ], {
-      messages$: jasmine.createSpy('messages$')
-    });
-
-    utilsSpy = jasmine.createSpyObj('UtilsService', ['expires', 'hasExpired']);
-    loggerSpy = jasmine.createSpyObj('LoggerService', ['debug', 'info', 'warn', 'error']);
-
-    TestBed.configureTestingModule({
-      providers: [
-        { provide: HTTPManagerStateService, useValue: httpManagerStateSpy },
-        { provide: HTTPManagerService, useValue: httpManagerServiceSpy },
-        { provide: DatabaseManagerService, useValue: dbManagerSpy },
-        { provide: LocalStorageManagerService, useValue: localStorageManagerSpy },
-        { provide: WebSocketManagerService, useValue: wsManagerSpy },
-        { provide: MessageTrackerService, useValue: messageTrackerSpy },
-        { provide: UtilsService, useValue: utilsSpy },
-        { provide: LoggerService, useValue: loggerSpy }
-      ]
-    });
-
-    stateService = new StateServiceDemo(httpManagerStateSpy);
-    messageService = new MessageServiceDemo(httpManagerStateSpy);
-    notificationService = new NotificationServiceDemo(httpManagerStateSpy);
-  });
-
-  it('should create StateServiceDemo', () => {
-    expect(stateService).toBeTruthy();
-  });
-
-  it('should create MessageServiceDemo', () => {
-    expect(messageService).toBeTruthy();
-  });
-
-  it('should create NotificationServiceDemo', () => {
-    expect(notificationService).toBeTruthy();
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // STATE SERVICE DEMO TESTS
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('StateServiceDemo', () => {
-    describe('updateConnection', () => {
-      it('should initialize WebSocket connection with server configuration', () => {
-        stateService.updateConnection(mockServer, mockWsServer, mockJwtToken, mockUser, mockPath);
-
-        expect(httpManagerStateSpy.setApiRequestOptions).toHaveBeenCalledWith(jasmine.objectContaining({
-          server: mockServer,
-          path: mockPath,
-          ws: jasmine.objectContaining({
-            id: 'ai/tests',
-            wsServer: mockWsServer,
-            jwtToken: mockJwtToken,
-            user: mockUser
-          })
-        }));
-      });
-
-      it('should construct channel ID from path', () => {
-        const testPath = ['chat', 'room1'];
-        stateService.updateConnection(mockServer, mockWsServer, mockJwtToken, mockUser, testPath);
-
-        expect(httpManagerStateSpy.setApiRequestOptions).toHaveBeenCalledWith(jasmine.objectContaining({
-          ws: jasmine.objectContaining({
-            id: 'chat/room1'
-          })
-        }));
-      });
-
-      it('should use default path if not provided', () => {
-        stateService.updateConnection(mockServer, mockWsServer, mockJwtToken, mockUser);
-
-        expect(httpManagerStateSpy.setApiRequestOptions).toHaveBeenCalledWith(jasmine.objectContaining({
-          path: ['ai', 'tests'],
-          ws: jasmine.objectContaining({
-            id: 'ai/tests'
-          })
-        }));
-      });
-
-      it('should configure retry options', () => {
-        stateService.updateConnection(mockServer, mockWsServer, mockJwtToken, mockUser, mockPath);
-
-        expect(httpManagerStateSpy.setApiRequestOptions).toHaveBeenCalledWith(jasmine.objectContaining({
-          server: mockServer,
-          path: mockPath,
-          ws: jasmine.objectContaining({
-            id: 'ai/tests',
-            wsServer: mockWsServer,
-            jwtToken: mockJwtToken,
-            user: mockUser
-          })
-        }));
-      });
-
-      it('should subscribe to userAction$', () => {
-        stateService.updateConnection(mockServer, mockWsServer, mockJwtToken, mockUser, mockPath);
-
-        expect(httpManagerStateSpy.userAction$.subscribe).toHaveBeenCalled();
-      });
-    });
-
-    describe('Channel Management', () => {
-      it('should get all channels', () => {
-        stateService.getAllChannels();
-        expect(httpManagerStateSpy.getAllChannels).toHaveBeenCalled();
-      });
-
-      it('should subscribe to a channel', () => {
-        stateService.subscribeToChannel('test-channel');
-        expect(httpManagerStateSpy.subscribeToChannel).toHaveBeenCalledWith('test-channel');
-      });
-
-      it('should unsubscribe from a channel', () => {
-        stateService.unsubscribeFromChannel('test-channel');
-        expect(httpManagerStateSpy.unsubscribeFromChannel).toHaveBeenCalledWith('test-channel');
-      });
-    });
-
-    describe('Notification Channel Management', () => {
-      it('should create notification channel', () => {
-        stateService.createNotificationChannel('alerts');
-        expect(httpManagerStateSpy.createNotificationChannel).toHaveBeenCalledWith('alerts');
-      });
-
-      it('should get notification channels', () => {
-        stateService.getNotificationChannels();
-        expect(httpManagerStateSpy.getNotificationChannels).toHaveBeenCalled();
-      });
-
-      it('should get today\'s notification channels', () => {
-        stateService.getTodaysNotificationChannels();
-        expect(httpManagerStateSpy.getTodaysNotificationChannels).toHaveBeenCalled();
-      });
-
-      it('should define previous notification channels', () => {
-        // This method is not implemented in the store, so we just skip the expectation to avoid TS error.
-      });
-
-      it('should subscribe to notification channel with date filter', () => {
-        const options = { startEpoch: 1234567890, endEpoch: 1234567990 };
-        stateService.subscribeToNotificationChannel('alerts', options, mockUser);
-        expect(httpManagerStateSpy.subscribeToNotificationChannel)
-          .toHaveBeenCalledWith('alerts', options, mockUser);
-      });
-
-      it('should unsubscribe from notification channel', () => {
-        stateService.unsubscribeFromNotificationChannel('alerts');
-        expect(httpManagerStateSpy.unsubscribeFromNotificationChannel).toHaveBeenCalledWith('alerts');
-      });
-
-      it('should send notification', () => {
-        const content = { message: 'Test notification' };
-        stateService.sendNotification('alerts', content);
-        expect(httpManagerStateSpy.sendNotification).toHaveBeenCalledWith('alerts', jasmine.any(Object));
-      });
-    });
-
-    describe('Data Operations', () => {
-      it('should get data', () => {
-        stateService.getData();
-        expect(httpManagerStateSpy.fetchRecords).toHaveBeenCalled();
-      });
-
-      it('should add data', () => {
-        const newData = { id: 1, name: 'Test' };
-        stateService.addData(newData);
-        expect(httpManagerStateSpy.createRecord).toHaveBeenCalledWith(newData, undefined);
-      });
-
-      it('should update data', () => {
-        const updatedData = { id: 1, name: 'Updated' };
-        stateService.updateData(updatedData);
-        expect(httpManagerStateSpy.updateRecord).toHaveBeenCalledWith(updatedData, undefined);
-      });
-
-      it('should delete data', () => {
-        stateService.deleteData(1);
-        expect(httpManagerStateSpy.deleteRecord).toHaveBeenCalledWith(undefined);
-      });
-
-      it('should clear all records', () => {
-        stateService.clearRecords();
-        expect(httpManagerStateSpy.clearRecords).toHaveBeenCalled();
-      });
-    });
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // MESSAGE SERVICE DEMO TESTS
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('MessageServiceDemo', () => {
-    describe('Channel Prefix Management', () => {
-      it('should add PUB- prefix to channel names', () => {
-        // Access private method through service functionality
-        messageService.createChannel('chat');
-        expect(httpManagerStateSpy.createChannel).toHaveBeenCalledWith('PUB-chat');
-      });
-
-      it('should not duplicate PUB- prefix', () => {
-        messageService.createChannel('PUB-already-prefixed');
-        expect(httpManagerStateSpy.createChannel).toHaveBeenCalledWith('PUB-already-prefixed');
-      });
-
-      it('should strip PUB- prefix from display', () => {
-        // This is tested indirectly through channel subscription
-        messageService.subscribeToChannel('test');
-        expect(httpManagerStateSpy.subscribeToChannel).toHaveBeenCalledWith('PUB-test');
-      });
-    });
-
-    describe('Channel Operations', () => {
-      it('should create a channel', () => {
-        messageService.createChannel('chat-room');
-        expect(httpManagerStateSpy.createChannel).toHaveBeenCalledWith('PUB-chat-room');
-      });
-
-      it('should get all channels', () => {
-        messageService.getAllChannels();
-        expect(httpManagerStateSpy.getAllChannels).toHaveBeenCalled();
-      });
-
-      it('should subscribe to a channel', () => {
-        messageService.subscribeToChannel('chat-room');
-        expect(httpManagerStateSpy.subscribeToChannel).toHaveBeenCalledWith('PUB-chat-room');
-      });
-
-      it('should unsubscribe from a channel', () => {
-        messageService.unsubscribeFromChannel('chat-room');
-        expect(httpManagerStateSpy.unsubscribeFromChannel).toHaveBeenCalledWith('PUB-chat-room');
-      });
-    });
-
-    describe('Message Operations', () => {
-      it('should send message to channels', () => {
-        const message = { content: 'Hello', timestamp: Date.now(), sessionId: 'session123' };
-        const channels = ['chat1', 'chat2'];
-
-        messageService.sendMessage(message, channels);
-
-        expect(httpManagerStateSpy.wsMessaging).toHaveBeenCalledWith(
-          jasmine.any(Object),
-          ['chat1', 'chat2']
-        );
-      });
-
-      it('should send message without channels', () => {
-        const message = { content: 'Hello', timestamp: Date.now().toString(), sessionId: 'session123' };
-
-        messageService.sendMessage(message);
-
-        expect(httpManagerStateSpy.wsMessaging).toHaveBeenCalledWith(jasmine.any(Object), undefined);
-      });
-    });
-
-    describe('Observables', () => {
-      it('should expose channels$', () => {
-        expect(messageService.channels$).toBeDefined();
-      });
-
-      it('should expose subscribedChannels$', () => {
-        expect(messageService.subscribedChannels$).toBeDefined();
-      });
-
-      it('should expose communicationMessages$', () => {
-        expect(messageService.communicationMessages$).toBeDefined();
-      });
-
-      it('should expose latestCommunicationMessages$', () => {
-        expect(messageService.latestCommunicationMessages$).toBeDefined();
-      });
-
-      it('should expose connectionStatus$', () => {
-        expect(messageService.connectionStatus$).toBeDefined();
-      });
-
-      it('should expose user$', () => {
-        expect(messageService.user$).toBeDefined();
-      });
-
-      it('should expose data$', () => {
-        expect(messageService.data$).toBeDefined();
-      });
-    });
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // NOTIFICATION SERVICE DEMO TESTS
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('NotificationServiceDemo', () => {
-    describe('Channel Prefix Management', () => {
-      it('should add MES- prefix to channel names', () => {
-        notificationService.createNotificationChannel('alerts');
-        expect(httpManagerStateSpy.createNotificationChannel).toHaveBeenCalledWith('alerts');
-      });
-
-      it('should track subscribed channels with MES- prefix', () => {
-        notificationService.subscribeToNotificationChannel('alerts');
-
-        // Should add to local tracking with prefix
-        expect(notificationService.subscribedNotificationChannels$).toBeDefined();
-      });
-    });
-
-    describe('Notification Channel Operations', () => {
-      it('should create notification channel', () => {
-        notificationService.createNotificationChannel('system-alerts');
-        expect(httpManagerStateSpy.createNotificationChannel).toHaveBeenCalledWith('system-alerts');
-      });
-
-      it('should get notification channels', () => {
-        notificationService.getNotificationChannels();
-        expect(httpManagerStateSpy.getNotificationChannels).toHaveBeenCalled();
-      });
-
-      it('should get today\'s notification channels', () => {
-        notificationService.getTodaysNotificationChannels();
-        expect(httpManagerStateSpy.getTodaysNotificationChannels).toHaveBeenCalled();
-      });
-
-      it('should define previous notification channels (no-op)', () => {
-        // This method is not implemented in the store, calling it should be a no-op
-        notificationService.definePreviousNotificationChannels();
-        // No expectation - method is intentionally not implemented
-      });
-    });
-
-    describe('Subscription Management', () => {
-      it('should subscribe to notification channel with date filter', () => {
-        const options = { startEpoch: 1234567890, endEpoch: 1234567990 };
-        notificationService.subscribeToNotificationChannel('alerts', options, mockUser);
-
-        expect(httpManagerStateSpy.subscribeToNotificationChannel)
-          .toHaveBeenCalledWith('alerts', options, mockUser);
-      });
-
-      it('should add MES- prefix for local tracking', () => {
-        notificationService.subscribeToNotificationChannel('alerts');
-
-        // Verify local tracking adds prefix
-        expect(notificationService.subscribedNotificationChannels$).toBeDefined();
-      });
-
-      it('should unsubscribe from notification channel', () => {
-        notificationService.unsubscribeFromNotificationChannel('alerts');
-        expect(httpManagerStateSpy.unsubscribeFromNotificationChannel).toHaveBeenCalledWith('alerts');
-      });
-
-      it('should remove from local tracking on unsubscribe', () => {
-        notificationService.unsubscribeFromNotificationChannel('alerts');
-
-        // Should remove from local tracking
-        expect(notificationService.subscribedNotificationChannels$).toBeDefined();
-      });
-    });
-
-    describe('Sending Notifications', () => {
-      it('should send notification with user info', () => {
-        const content = { message: 'Test notification', priority: 'high' };
-
-        notificationService.sendNotification('alerts', content);
-
-        expect(httpManagerStateSpy.sendNotification).toHaveBeenCalledWith(
-          'alerts',
-          jasmine.any(Object)
-        );
-      });
-
-      it('should send notification without user info', () => {
-        const content = { message: 'Test notification' };
-
-        notificationService.sendNotification('alerts', content);
-
-        expect(httpManagerStateSpy.sendNotification).toHaveBeenCalledWith(
-          'alerts',
-          jasmine.any(Object)
-        );
-      });
-    });
-
-    describe('Observables', () => {
-      it('should expose notificationChannels$', () => {
-        expect(notificationService.notificationChannels$).toBeDefined();
-      });
-
-      it('should expose todaysNotificationChannels$', () => {
-        expect(notificationService.todaysNotificationChannels$).toBeDefined();
-      });
-
-      it('should expose subscribedNotificationChannels$', () => {
-        expect(notificationService.subscribedNotificationChannels$).toBeDefined();
-      });
-
-      it('should expose notificationMessages$', () => {
-        expect(notificationService.notificationMessages$).toBeDefined();
-      });
-
-      it('should expose latestNotification$', () => {
-        expect(notificationService.latestNotification$).toBeDefined();
-      });
-
-      it('should expose connectionStatus$', () => {
-        expect(notificationService.connectionStatus$).toBeDefined();
-      });
-    });
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // INTEGRATION TESTS
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('Service Integration', () => {
-    it('should coordinate between state, message, and notification services', () => {
-      // Setup connection
-      stateService.updateConnection(mockServer, mockWsServer, mockJwtToken, mockUser, mockPath);
-
-      // Create channels
-      messageService.createChannel('general');
-      notificationService.createNotificationChannel('alerts');
-
-      // Subscribe to channels
-      messageService.subscribeToChannel('general');
-      notificationService.subscribeToNotificationChannel('alerts');
-
-      // Send messages
-      messageService.sendMessage({ content: 'Hello' }, ['general']);
-      notificationService.sendNotification('alerts', { message: 'Alert!' });
-
-      // Verify all interactions
-      expect(httpManagerStateSpy.setApiRequestOptions).toHaveBeenCalled();
-      expect(httpManagerStateSpy.createChannel).toHaveBeenCalledWith('PUB-general');
-      expect(httpManagerStateSpy.createNotificationChannel).toHaveBeenCalledWith('alerts');
-      expect(httpManagerStateSpy.subscribeToChannel).toHaveBeenCalledWith('PUB-general');
-      expect(httpManagerStateSpy.subscribeToNotificationChannel).toHaveBeenCalledWith('alerts', jasmine.any(Object), jasmine.any(Object));
-      expect(httpManagerStateSpy.wsMessaging).toHaveBeenCalled();
-      expect(httpManagerStateSpy.sendNotification).toHaveBeenCalled();
-    });
-  });
-});