onbuzz 4.9.13 → 4.10.0

package/src/interfaces/terminal/__tests__/smoke/connection.test.js

@@ -1,350 +1,341 @@
-/**
- * Connection Management - Smoke Tests
- * Verifies that connection management modules can be imported and basic functionality works
- */
-
-import { describe, test, expect } from '@jest/globals';
-
-describe('Connection Management - Imports', () => {
-  test('useConnection hook can be imported', async () => {
-    const { useConnection } = await import('../../state/useConnection.js');
-
-    expect(useConnection).toBeDefined();
-    expect(typeof useConnection).toBe('function');
-  });
-
-  test('useConnection is default export', async () => {
-    const module = await import('../../state/useConnection.js');
-
-    expect(module.default).toBeDefined();
-    expect(typeof module.default).toBe('function');
-    expect(module.default).toBe(module.useConnection);
-  });
-});
-
-describe('Connection Management - Constants', () => {
-  test('CONNECTION_STATUS constants are defined', async () => {
-    const { CONNECTION_STATUS } = await import('../../config/constants.js');
-
-    expect(CONNECTION_STATUS).toBeDefined();
-    expect(CONNECTION_STATUS.CONNECTING).toBe('connecting');
-    expect(CONNECTION_STATUS.CONNECTED).toBe('connected');
-    expect(CONNECTION_STATUS.DISCONNECTED).toBe('disconnected');
-    expect(CONNECTION_STATUS.RECONNECTING).toBe('reconnecting');
-  });
-
-  test('CONNECTION_STATUS is alias for CONNECTION_STATE', async () => {
-    const { CONNECTION_STATUS, CONNECTION_STATE } = await import('../../config/constants.js');
-
-    expect(CONNECTION_STATUS).toBe(CONNECTION_STATE);
-  });
-
-  test('RECONNECT_CONFIG constants are defined', async () => {
-    const { RECONNECT_CONFIG } = await import('../../config/constants.js');
-
-    expect(RECONNECT_CONFIG).toBeDefined();
-    expect(RECONNECT_CONFIG.INITIAL_DELAY).toBeDefined();
-    expect(RECONNECT_CONFIG.MAX_DELAY).toBeDefined();
-    expect(RECONNECT_CONFIG.BACKOFF_MULTIPLIER).toBeDefined();
-    expect(RECONNECT_CONFIG.MAX_ATTEMPTS).toBeDefined();
-  });
-
-  test('RECONNECT_CONFIG values are reasonable', async () => {
-    const { RECONNECT_CONFIG } = await import('../../config/constants.js');
-
-    // Initial delay should be > 0
-    expect(RECONNECT_CONFIG.INITIAL_DELAY).toBeGreaterThan(0);
-    
-    // Max delay should be > initial delay
-    expect(RECONNECT_CONFIG.MAX_DELAY).toBeGreaterThan(RECONNECT_CONFIG.INITIAL_DELAY);
-    
-    // Backoff multiplier should be > 1 for exponential growth
-    expect(RECONNECT_CONFIG.BACKOFF_MULTIPLIER).toBeGreaterThan(1);
-    
-    // Max attempts should be reasonable (not 0 or negative)
-    expect(RECONNECT_CONFIG.MAX_ATTEMPTS).toBeGreaterThan(0);
-  });
-});
-
-describe('Connection Management - Integration', () => {
-  test('useConnection hook integrates with SessionManager and WebSocketManager', async () => {
-    const { useConnection } = await import('../../state/useConnection.js');
-    const { SessionManager } = await import('../../api/session.js');
-    const { WebSocketManager } = await import('../../api/websocket.js');
-
-    // Create dependencies
-    const sessionManager = new SessionManager('localhost', 8080);
-    const wsManager = new WebSocketManager('localhost', 8080);
-
-    // Verify all components exist
-    expect(sessionManager).toBeDefined();
-    expect(wsManager).toBeDefined();
-
-    // useConnection expects these as parameters
-    // (we can't actually call the hook outside React, but we verify the interface)
-    expect(typeof useConnection).toBe('function');
-  });
-
-  test('Full connection stack can be imported together', async () => {
-    const [
-      constantsModule,
-      sessionModule,
-      websocketModule,
-      connectionModule,
-    ] = await Promise.all([
-      import('../../config/constants.js'),
-      import('../../api/session.js'),
-      import('../../api/websocket.js'),
-      import('../../state/useConnection.js'),
-    ]);
-
-    // Verify all modules loaded
-    expect(constantsModule.CONNECTION_STATUS).toBeDefined();
-    expect(constantsModule.RECONNECT_CONFIG).toBeDefined();
-    expect(sessionModule.SessionManager).toBeDefined();
-    expect(websocketModule.WebSocketManager).toBeDefined();
-    expect(connectionModule.useConnection).toBeDefined();
-  });
-});
-
-describe('Connection Management - Hook Interface Verification', () => {
-  test('useConnection returns expected interface shape', async () => {
-    const { useConnection } = await import('../../state/useConnection.js');
-
-    // We can verify the function signature
-    expect(useConnection.length).toBe(2); // sessionManager, wsManager
-  });
-});
-
-describe('Connection Management - Status Values', () => {
-  test('CONNECTION_STATUS values are lowercase strings', async () => {
-    const { CONNECTION_STATUS } = await import('../../config/constants.js');
-
-    expect(typeof CONNECTION_STATUS.CONNECTING).toBe('string');
-    expect(typeof CONNECTION_STATUS.CONNECTED).toBe('string');
-    expect(typeof CONNECTION_STATUS.DISCONNECTED).toBe('string');
-    expect(typeof CONNECTION_STATUS.RECONNECTING).toBe('string');
-
-    expect(CONNECTION_STATUS.CONNECTING).toBe(CONNECTION_STATUS.CONNECTING.toLowerCase());
-    expect(CONNECTION_STATUS.CONNECTED).toBe(CONNECTION_STATUS.CONNECTED.toLowerCase());
-  });
-
-  test('CONNECTION_STATUS has all required states', async () => {
-    const { CONNECTION_STATUS } = await import('../../config/constants.js');
-
-    const states = Object.keys(CONNECTION_STATUS);
-    expect(states).toContain('CONNECTING');
-    expect(states).toContain('CONNECTED');
-    expect(states).toContain('DISCONNECTED');
-    expect(states).toContain('RECONNECTING');
-  });
-});
-
-describe('Connection Management - Exponential Backoff Logic', () => {
-  test('Exponential backoff delay calculation works correctly', async () => {
-    const { RECONNECT_CONFIG } = await import('../../config/constants.js');
-
-    // Simulate exponential backoff calculation
-    const getReconnectDelay = (attempt) => {
-      return Math.min(
-        RECONNECT_CONFIG.INITIAL_DELAY * Math.pow(RECONNECT_CONFIG.BACKOFF_MULTIPLIER, attempt),
-        RECONNECT_CONFIG.MAX_DELAY
-      );
-    };
-
-    // Test increasing delays
-    const delay0 = getReconnectDelay(0);
-    const delay1 = getReconnectDelay(1);
-    const delay2 = getReconnectDelay(2);
-
-    expect(delay0).toBe(RECONNECT_CONFIG.INITIAL_DELAY);
-    expect(delay1).toBeGreaterThan(delay0);
-    expect(delay2).toBeGreaterThan(delay1);
-  });
-
-  test('Exponential backoff respects max delay', async () => {
-    const { RECONNECT_CONFIG } = await import('../../config/constants.js');
-
-    // Simulate exponential backoff calculation
-    const getReconnectDelay = (attempt) => {
-      return Math.min(
-        RECONNECT_CONFIG.INITIAL_DELAY * Math.pow(RECONNECT_CONFIG.BACKOFF_MULTIPLIER, attempt),
-        RECONNECT_CONFIG.MAX_DELAY
-      );
-    };
-
-    // Test with very large attempt number
-    const delayLarge = getReconnectDelay(100);
-
-    // Should be capped at MAX_DELAY
-    expect(delayLarge).toBe(RECONNECT_CONFIG.MAX_DELAY);
-    expect(delayLarge).toBeLessThanOrEqual(RECONNECT_CONFIG.MAX_DELAY);
-  });
-});
-
-describe('Connection Management - Session State', () => {
-  test('Session state should track validity', async () => {
-    // Mock session state
-    let sessionId = null;
-    let sessionValid = false;
-    let sessionExpiration = null;
-
-    // Simulate session initialization
-    sessionId = 'test-session-123';
-    sessionValid = true;
-    sessionExpiration = Date.now() + 3600000; // 1 hour from now
-
-    expect(sessionId).toBeDefined();
-    expect(sessionValid).toBe(true);
-    expect(sessionExpiration).toBeGreaterThan(Date.now());
-  });
-
-  test('Session state should invalidate', async () => {
-    // Mock session state
-    let sessionId = 'test-session-123';
-    let sessionValid = true;
-
-    // Simulate session invalidation
-    sessionId = null;
-    sessionValid = false;
-
-    expect(sessionId).toBeNull();
-    expect(sessionValid).toBe(false);
-  });
-});
-
-describe('Connection Management - Connection Metrics', () => {
-  test('Connection uptime can be tracked', async () => {
-    // Mock uptime tracking
-    const connectionStartTime = Date.now();
-    
-    // Wait a bit
-    await new Promise(resolve => setTimeout(resolve, 100));
-    
-    const uptime = Date.now() - connectionStartTime;
-    
-    expect(uptime).toBeGreaterThan(0);
-    expect(uptime).toBeGreaterThanOrEqual(100);
-  });
-
-  test('Connection metrics track timestamps', async () => {
-    // Mock connection metrics
-    const lastConnectedAt = Date.now();
-    
-    // Wait a bit
-    await new Promise(resolve => setTimeout(resolve, 50));
-    
-    const lastDisconnectedAt = Date.now();
-    
-    expect(lastConnectedAt).toBeDefined();
-    expect(lastDisconnectedAt).toBeDefined();
-    expect(lastDisconnectedAt).toBeGreaterThan(lastConnectedAt);
-  });
-
-  test('Reconnection attempts can be tracked', async () => {
-    // Mock reconnection attempt tracking
-    let reconnectAttempts = 0;
-    
-    // Simulate failed attempts
-    reconnectAttempts += 1;
-    expect(reconnectAttempts).toBe(1);
-    
-    reconnectAttempts += 1;
-    expect(reconnectAttempts).toBe(2);
-    
-    // Reset on successful connection
-    reconnectAttempts = 0;
-    expect(reconnectAttempts).toBe(0);
-  });
-});
-
-describe('Connection Management - Connection Status Transitions', () => {
-  test('Connection status transitions follow valid flow', async () => {
-    const { CONNECTION_STATUS } = await import('../../config/constants.js');
-
-    // Valid transition: DISCONNECTED -> CONNECTING -> CONNECTED
-    let status = CONNECTION_STATUS.DISCONNECTED;
-    expect(status).toBe('disconnected');
-
-    status = CONNECTION_STATUS.CONNECTING;
-    expect(status).toBe('connecting');
-
-    status = CONNECTION_STATUS.CONNECTED;
-    expect(status).toBe('connected');
-
-    // Valid transition: CONNECTED -> DISCONNECTED -> RECONNECTING -> CONNECTED
-    status = CONNECTION_STATUS.DISCONNECTED;
-    expect(status).toBe('disconnected');
-
-    status = CONNECTION_STATUS.RECONNECTING;
-    expect(status).toBe('reconnecting');
-
-    status = CONNECTION_STATUS.CONNECTED;
-    expect(status).toBe('connected');
-  });
-});
-
-describe('Connection Management - WebSocket Event Integration', () => {
-  test('WebSocketManager has event emitter methods', async () => {
-    const { WebSocketManager } = await import('../../api/websocket.js');
-
-    const wsManager = new WebSocketManager('localhost', 8080);
-
-    // Verify event emitter methods exist
-    expect(wsManager.on).toBeDefined();
-    expect(wsManager.off).toBeDefined();
-    expect(typeof wsManager.on).toBe('function');
-    expect(typeof wsManager.off).toBe('function');
-  });
-});
-
-describe('Connection Management - Max Attempts Limit', () => {
-  test('Reconnection should stop after max attempts', async () => {
-    const { RECONNECT_CONFIG } = await import('../../config/constants.js');
-
-    // Mock reconnection attempt tracking
-    let reconnectAttempts = 0;
-
-    // Simulate reconnection attempts
-    for (let i = 0; i < RECONNECT_CONFIG.MAX_ATTEMPTS + 5; i++) {
-      if (reconnectAttempts < RECONNECT_CONFIG.MAX_ATTEMPTS) {
-        reconnectAttempts += 1;
-      } else {
-        // Should stop incrementing
-        break;
-      }
-    }
-
-    // Should not exceed max attempts
-    expect(reconnectAttempts).toBe(RECONNECT_CONFIG.MAX_ATTEMPTS);
-    expect(reconnectAttempts).toBeLessThanOrEqual(RECONNECT_CONFIG.MAX_ATTEMPTS);
-  });
-});
-
-describe('Connection Management - Connection Info', () => {
-  test('Connection info should contain all metrics', async () => {
-    const { CONNECTION_STATUS } = await import('../../config/constants.js');
-
-    // Mock connection info
-    const connectionInfo = {
-      status: CONNECTION_STATUS.CONNECTED,
-      isConnected: true,
-      isReconnecting: false,
-      sessionId: 'test-session-123',
-      sessionValid: true,
-      sessionExpiration: Date.now() + 3600000,
-      uptime: 5000,
-      lastConnectedAt: Date.now() - 5000,
-      lastDisconnectedAt: null,
-      reconnectAttempts: 0,
-    };
-
-    // Verify all fields present
-    expect(connectionInfo.status).toBeDefined();
-    expect(connectionInfo.isConnected).toBe(true);
-    expect(connectionInfo.isReconnecting).toBe(false);
-    expect(connectionInfo.sessionId).toBeDefined();
-    expect(connectionInfo.sessionValid).toBe(true);
-    expect(connectionInfo.uptime).toBeGreaterThan(0);
-  });
-});
+/**
+ * Connection Management - Smoke Tests
+ * Verifies that connection management modules can be imported and basic functionality works
+ */
+
+import { describe, test, expect } from '@jest/globals';
+
+describe('Connection Management - Imports', () => {
+  test('useConnection hook can be imported', async () => {
+    const { useConnection } = await import('../../state/useConnection.js');
+
+    expect(useConnection).toBeDefined();
+    expect(typeof useConnection).toBe('function');
+  });
+
+  test('useConnection is default export', async () => {
+    const module = await import('../../state/useConnection.js');
+
+    expect(module.default).toBeDefined();
+    expect(typeof module.default).toBe('function');
+    expect(module.default).toBe(module.useConnection);
+  });
+});
+
+describe('Connection Management - Constants', () => {
+  test('CONNECTION_STATUS constants are defined', async () => {
+    const { CONNECTION_STATUS } = await import('../../config/constants.js');
+
+    expect(CONNECTION_STATUS).toBeDefined();
+    expect(CONNECTION_STATUS.CONNECTING).toBe('connecting');
+    expect(CONNECTION_STATUS.CONNECTED).toBe('connected');
+    expect(CONNECTION_STATUS.DISCONNECTED).toBe('disconnected');
+    expect(CONNECTION_STATUS.RECONNECTING).toBe('reconnecting');
+  });
+
+  test('CONNECTION_STATUS is alias for CONNECTION_STATE', async () => {
+    const { CONNECTION_STATUS, CONNECTION_STATE } = await import('../../config/constants.js');
+
+    expect(CONNECTION_STATUS).toBe(CONNECTION_STATE);
+  });
+
+  test('RECONNECT_CONFIG constants are defined', async () => {
+    const { RECONNECT_CONFIG } = await import('../../config/constants.js');
+
+    expect(RECONNECT_CONFIG).toBeDefined();
+    expect(RECONNECT_CONFIG.INITIAL_DELAY).toBeDefined();
+    expect(RECONNECT_CONFIG.MAX_DELAY).toBeDefined();
+    expect(RECONNECT_CONFIG.BACKOFF_MULTIPLIER).toBeDefined();
+    expect(RECONNECT_CONFIG.MAX_ATTEMPTS).toBeDefined();
+  });
+
+  test('RECONNECT_CONFIG values are reasonable', async () => {
+    const { RECONNECT_CONFIG } = await import('../../config/constants.js');
+
+    // Initial delay should be > 0
+    expect(RECONNECT_CONFIG.INITIAL_DELAY).toBeGreaterThan(0);
+    
+    // Max delay should be > initial delay
+    expect(RECONNECT_CONFIG.MAX_DELAY).toBeGreaterThan(RECONNECT_CONFIG.INITIAL_DELAY);
+    
+    // Backoff multiplier should be > 1 for exponential growth
+    expect(RECONNECT_CONFIG.BACKOFF_MULTIPLIER).toBeGreaterThan(1);
+    
+    // Max attempts should be reasonable (not 0 or negative)
+    expect(RECONNECT_CONFIG.MAX_ATTEMPTS).toBeGreaterThan(0);
+  });
+});
+
+describe('Connection Management - Integration', () => {
+  test('useConnection hook integrates with SessionManager and WebSocketManager', async () => {
+    const { useConnection } = await import('../../state/useConnection.js');
+    const { SessionManager } = await import('../../api/session.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    // Create dependencies
+    const sessionManager = new SessionManager('localhost', 8080);
+    const wsManager = new WebSocketManager('localhost', 8080);
+
+    // Verify all components exist
+    expect(sessionManager).toBeDefined();
+    expect(wsManager).toBeDefined();
+
+    // useConnection expects these as parameters
+    // (we can't actually call the hook outside React, but we verify the interface)
+    expect(typeof useConnection).toBe('function');
+  });
+
+  test('Full connection stack can be imported together', async () => {
+    const [
+      constantsModule,
+      sessionModule,
+      websocketModule,
+      connectionModule,
+    ] = await Promise.all([
+      import('../../config/constants.js'),
+      import('../../api/session.js'),
+      import('../../api/websocket.js'),
+      import('../../state/useConnection.js'),
+    ]);
+
+    // Verify all modules loaded
+    expect(constantsModule.CONNECTION_STATUS).toBeDefined();
+    expect(constantsModule.RECONNECT_CONFIG).toBeDefined();
+    expect(sessionModule.SessionManager).toBeDefined();
+    expect(websocketModule.WebSocketManager).toBeDefined();
+    expect(connectionModule.useConnection).toBeDefined();
+  });
+});
+
+describe('Connection Management - Hook Interface Verification', () => {
+  test('useConnection returns expected interface shape', async () => {
+    const { useConnection } = await import('../../state/useConnection.js');
+
+    // We can verify the function signature
+    expect(useConnection.length).toBe(2); // sessionManager, wsManager
+  });
+});
+
+describe('Connection Management - Status Values', () => {
+  test('CONNECTION_STATUS values are lowercase strings', async () => {
+    const { CONNECTION_STATUS } = await import('../../config/constants.js');
+
+    expect(typeof CONNECTION_STATUS.CONNECTING).toBe('string');
+    expect(typeof CONNECTION_STATUS.CONNECTED).toBe('string');
+    expect(typeof CONNECTION_STATUS.DISCONNECTED).toBe('string');
+    expect(typeof CONNECTION_STATUS.RECONNECTING).toBe('string');
+
+    expect(CONNECTION_STATUS.CONNECTING).toBe(CONNECTION_STATUS.CONNECTING.toLowerCase());
+    expect(CONNECTION_STATUS.CONNECTED).toBe(CONNECTION_STATUS.CONNECTED.toLowerCase());
+  });
+
+  test('CONNECTION_STATUS has all required states', async () => {
+    const { CONNECTION_STATUS } = await import('../../config/constants.js');
+
+    const states = Object.keys(CONNECTION_STATUS);
+    expect(states).toContain('CONNECTING');
+    expect(states).toContain('CONNECTED');
+    expect(states).toContain('DISCONNECTED');
+    expect(states).toContain('RECONNECTING');
+  });
+});
+
+describe('Connection Management - Exponential Backoff Logic', () => {
+  test('Exponential backoff delay calculation works correctly', async () => {
+    const { RECONNECT_CONFIG } = await import('../../config/constants.js');
+
+    // Simulate exponential backoff calculation
+    const getReconnectDelay = (attempt) => {
+      return Math.min(
+        RECONNECT_CONFIG.INITIAL_DELAY * Math.pow(RECONNECT_CONFIG.BACKOFF_MULTIPLIER, attempt),
+        RECONNECT_CONFIG.MAX_DELAY
+      );
+    };
+
+    // Test increasing delays
+    const delay0 = getReconnectDelay(0);
+    const delay1 = getReconnectDelay(1);
+    const delay2 = getReconnectDelay(2);
+
+    expect(delay0).toBe(RECONNECT_CONFIG.INITIAL_DELAY);
+    expect(delay1).toBeGreaterThan(delay0);
+    expect(delay2).toBeGreaterThan(delay1);
+  });
+
+  test('Exponential backoff respects max delay', async () => {
+    const { RECONNECT_CONFIG } = await import('../../config/constants.js');
+
+    // Simulate exponential backoff calculation
+    const getReconnectDelay = (attempt) => {
+      return Math.min(
+        RECONNECT_CONFIG.INITIAL_DELAY * Math.pow(RECONNECT_CONFIG.BACKOFF_MULTIPLIER, attempt),
+        RECONNECT_CONFIG.MAX_DELAY
+      );
+    };
+
+    // Test with very large attempt number
+    const delayLarge = getReconnectDelay(100);
+
+    // Should be capped at MAX_DELAY
+    expect(delayLarge).toBe(RECONNECT_CONFIG.MAX_DELAY);
+    expect(delayLarge).toBeLessThanOrEqual(RECONNECT_CONFIG.MAX_DELAY);
+  });
+});
+
+describe('Connection Management - Session State', () => {
+  test('Session state should track validity', async () => {
+    // Simulate session initialization
+    let sessionId = 'test-session-123';
+    let sessionValid = true;
+    let sessionExpiration = Date.now() + 3600000; // 1 hour from now
+
+    expect(sessionId).toBeDefined();
+    expect(sessionValid).toBe(true);
+    expect(sessionExpiration).toBeGreaterThan(Date.now());
+  });
+
+  test('Session state should invalidate', async () => {
+    // Simulate session invalidation
+    let sessionId = null;
+    let sessionValid = false;
+
+    expect(sessionId).toBeNull();
+    expect(sessionValid).toBe(false);
+  });
+});
+
+describe('Connection Management - Connection Metrics', () => {
+  test('Connection uptime can be tracked', async () => {
+    // Mock uptime tracking
+    const connectionStartTime = Date.now();
+    
+    // Wait a bit
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    const uptime = Date.now() - connectionStartTime;
+    
+    expect(uptime).toBeGreaterThan(0);
+    expect(uptime).toBeGreaterThanOrEqual(100);
+  });
+
+  test('Connection metrics track timestamps', async () => {
+    // Mock connection metrics
+    const lastConnectedAt = Date.now();
+    
+    // Wait a bit
+    await new Promise(resolve => setTimeout(resolve, 50));
+    
+    const lastDisconnectedAt = Date.now();
+    
+    expect(lastConnectedAt).toBeDefined();
+    expect(lastDisconnectedAt).toBeDefined();
+    expect(lastDisconnectedAt).toBeGreaterThan(lastConnectedAt);
+  });
+
+  test('Reconnection attempts can be tracked', async () => {
+    // Mock reconnection attempt tracking
+    let reconnectAttempts = 0;
+    
+    // Simulate failed attempts
+    reconnectAttempts += 1;
+    expect(reconnectAttempts).toBe(1);
+    
+    reconnectAttempts += 1;
+    expect(reconnectAttempts).toBe(2);
+    
+    // Reset on successful connection
+    reconnectAttempts = 0;
+    expect(reconnectAttempts).toBe(0);
+  });
+});
+
+describe('Connection Management - Connection Status Transitions', () => {
+  test('Connection status transitions follow valid flow', async () => {
+    const { CONNECTION_STATUS } = await import('../../config/constants.js');
+
+    // Valid transition: DISCONNECTED -> CONNECTING -> CONNECTED
+    let status = CONNECTION_STATUS.DISCONNECTED;
+    expect(status).toBe('disconnected');
+
+    status = CONNECTION_STATUS.CONNECTING;
+    expect(status).toBe('connecting');
+
+    status = CONNECTION_STATUS.CONNECTED;
+    expect(status).toBe('connected');
+
+    // Valid transition: CONNECTED -> DISCONNECTED -> RECONNECTING -> CONNECTED
+    status = CONNECTION_STATUS.DISCONNECTED;
+    expect(status).toBe('disconnected');
+
+    status = CONNECTION_STATUS.RECONNECTING;
+    expect(status).toBe('reconnecting');
+
+    status = CONNECTION_STATUS.CONNECTED;
+    expect(status).toBe('connected');
+  });
+});
+
+describe('Connection Management - WebSocket Event Integration', () => {
+  test('WebSocketManager has event emitter methods', async () => {
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    const wsManager = new WebSocketManager('localhost', 8080);
+
+    // Verify event emitter methods exist
+    expect(wsManager.on).toBeDefined();
+    expect(wsManager.off).toBeDefined();
+    expect(typeof wsManager.on).toBe('function');
+    expect(typeof wsManager.off).toBe('function');
+  });
+});
+
+describe('Connection Management - Max Attempts Limit', () => {
+  test('Reconnection should stop after max attempts', async () => {
+    const { RECONNECT_CONFIG } = await import('../../config/constants.js');
+
+    // Mock reconnection attempt tracking
+    let reconnectAttempts = 0;
+
+    // Simulate reconnection attempts
+    for (let i = 0; i < RECONNECT_CONFIG.MAX_ATTEMPTS + 5; i++) {
+      if (reconnectAttempts < RECONNECT_CONFIG.MAX_ATTEMPTS) {
+        reconnectAttempts += 1;
+      } else {
+        // Should stop incrementing
+        break;
+      }
+    }
+
+    // Should not exceed max attempts
+    expect(reconnectAttempts).toBe(RECONNECT_CONFIG.MAX_ATTEMPTS);
+    expect(reconnectAttempts).toBeLessThanOrEqual(RECONNECT_CONFIG.MAX_ATTEMPTS);
+  });
+});
+
+describe('Connection Management - Connection Info', () => {
+  test('Connection info should contain all metrics', async () => {
+    const { CONNECTION_STATUS } = await import('../../config/constants.js');
+
+    // Mock connection info
+    const connectionInfo = {
+      status: CONNECTION_STATUS.CONNECTED,
+      isConnected: true,
+      isReconnecting: false,
+      sessionId: 'test-session-123',
+      sessionValid: true,
+      sessionExpiration: Date.now() + 3600000,
+      uptime: 5000,
+      lastConnectedAt: Date.now() - 5000,
+      lastDisconnectedAt: null,
+      reconnectAttempts: 0,
+    };
+
+    // Verify all fields present
+    expect(connectionInfo.status).toBeDefined();
+    expect(connectionInfo.isConnected).toBe(true);
+    expect(connectionInfo.isReconnecting).toBe(false);
+    expect(connectionInfo.sessionId).toBeDefined();
+    expect(connectionInfo.sessionValid).toBe(true);
+    expect(connectionInfo.uptime).toBeGreaterThan(0);
+  });
+});