fix(core): Refactor certificate handling across the project

test/test.ts

@@ -1,6 +1,6 @@
 import { expect, tap } from '@push.rocks/tapbundle';
 import * as smartproxy from '../ts/index.js';
-import { testCertificates } from './helpers/certificates.js';
+import { loadTestCertificates } from './helpers/certificates.js';
 import * as https from 'https';
 import * as http from 'http';
 import { WebSocket, WebSocketServer } from 'ws';
@@ -8,6 +8,7 @@ import { WebSocket, WebSocketServer } from 'ws';
 let testProxy: smartproxy.NetworkProxy;
 let testServer: http.Server;
 let wsServer: WebSocketServer;
+let testCertificates: { privateKey: string; publicKey: string };
 
 // Helper function to make HTTPS requests
 async function makeHttpsRequest(
@@ -32,28 +33,138 @@ async function makeHttpsRequest(
 
 // Setup test environment
 tap.test('setup test environment', async () => {
+  // Load and validate certificates
+  console.log('[TEST] Loading and validating certificates');
+  testCertificates = loadTestCertificates();
+  console.log('[TEST] Certificates loaded and validated');
   // Create a test HTTP server
   testServer = http.createServer((req, res) => {
+    console.log('[TEST SERVER] Received HTTP request:', {
+      url: req.url,
+      method: req.method,
+      headers: req.headers
+    });
     res.writeHead(200, { 'Content-Type': 'text/plain' });
     res.end('Hello from test server!');
   });
 
-  // Create a WebSocket server
-  wsServer = new WebSocketServer({ noServer: true });
-  wsServer.on('connection', (ws) => {
-    ws.on('message', (message) => {
-      ws.send('Echo: ' + message);
-    });
-  });
-
-  // Handle upgrade requests
+  // Handle WebSocket upgrade requests
   testServer.on('upgrade', (request, socket, head) => {
+    console.log('[TEST SERVER] Received WebSocket upgrade request:', {
+      url: request.url,
+      method: request.method,
+      headers: {
+        host: request.headers.host,
+        upgrade: request.headers.upgrade,
+        connection: request.headers.connection,
+        'sec-websocket-key': request.headers['sec-websocket-key'],
+        'sec-websocket-version': request.headers['sec-websocket-version'],
+        'sec-websocket-protocol': request.headers['sec-websocket-protocol']
+      }
+    });
+
+    if (request.headers.upgrade?.toLowerCase() !== 'websocket') {
+      console.log('[TEST SERVER] Not a WebSocket upgrade request');
+      socket.destroy();
+      return;
+    }
+
+    console.log('[TEST SERVER] Handling WebSocket upgrade');
     wsServer.handleUpgrade(request, socket, head, (ws) => {
+      console.log('[TEST SERVER] WebSocket connection upgraded');
       wsServer.emit('connection', ws, request);
     });
   });
 
+  // Create a WebSocket server
+  console.log('[TEST SERVER] Creating WebSocket server');
+  wsServer = new WebSocketServer({
+    noServer: true,
+    perMessageDeflate: false,
+    clientTracking: true,
+    handleProtocols: () => 'echo-protocol'
+  });
+
+  wsServer.on('connection', (ws, request) => {
+    console.log('[TEST SERVER] WebSocket connection established:', {
+      url: request.url,
+      headers: {
+        host: request.headers.host,
+        upgrade: request.headers.upgrade,
+        connection: request.headers.connection,
+        'sec-websocket-key': request.headers['sec-websocket-key'],
+        'sec-websocket-version': request.headers['sec-websocket-version'],
+        'sec-websocket-protocol': request.headers['sec-websocket-protocol']
+      }
+    });
+
+    // Set up connection timeout
+    const connectionTimeout = setTimeout(() => {
+      console.error('[TEST SERVER] WebSocket connection timed out');
+      ws.terminate();
+    }, 5000);
+
+    // Clear timeout when connection is properly closed
+    const clearConnectionTimeout = () => {
+      clearTimeout(connectionTimeout);
+    };
+
+    ws.on('message', (message) => {
+      const msg = message.toString();
+      console.log('[TEST SERVER] Received message:', msg);
+      try {
+        const response = `Echo: ${msg}`;
+        console.log('[TEST SERVER] Sending response:', response);
+        ws.send(response);
+        // Clear timeout on successful message exchange
+        clearConnectionTimeout();
+      } catch (error) {
+        console.error('[TEST SERVER] Error sending message:', error);
+      }
+    });
+
+    ws.on('error', (error) => {
+      console.error('[TEST SERVER] WebSocket error:', error);
+      clearConnectionTimeout();
+    });
+
+    ws.on('close', (code, reason) => {
+      console.log('[TEST SERVER] WebSocket connection closed:', {
+        code,
+        reason: reason.toString(),
+        wasClean: code === 1000 || code === 1001
+      });
+      clearConnectionTimeout();
+    });
+
+    ws.on('ping', (data) => {
+      try {
+        console.log('[TEST SERVER] Received ping, sending pong');
+        ws.pong(data);
+      } catch (error) {
+        console.error('[TEST SERVER] Error sending pong:', error);
+      }
+    });
+
+    ws.on('pong', (data) => {
+      console.log('[TEST SERVER] Received pong');
+    });
+  });
+
+  wsServer.on('error', (error) => {
+    console.error('Test server: WebSocket server error:', error);
+  });
+
+  wsServer.on('headers', (headers) => {
+    console.log('Test server: WebSocket headers:', headers);
+  });
+
+  wsServer.on('close', () => {
+    console.log('Test server: WebSocket server closed');
+  });
+
   await new Promise<void>((resolve) => testServer.listen(3000, resolve));
+  console.log('Test server listening on port 3000');
 });
 
 tap.test('should create proxy instance', async () => {
@@ -64,7 +175,9 @@ tap.test('should create proxy instance', async () => {
 });
 
 tap.test('should start the proxy server', async () => {
+  console.log('[TEST] Starting the proxy server');
   await testProxy.start();
+  console.log('[TEST] Proxy server started');
 
   // Configure proxy with test certificates
   testProxy.updateProxyConfigs([
@@ -74,8 +187,10 @@ tap.test('should start the proxy server', async () => {
       hostName: 'push.rocks',
       publicKey: testCertificates.publicKey,
       privateKey: testCertificates.privateKey,
-    },
+    }
   ]);
+
+  console.log('[TEST] Proxy configuration updated');
 });
 
 tap.test('should route HTTPS requests based on host header', async () => {
@@ -104,41 +219,110 @@ tap.test('should handle unknown host headers', async () => {
 });
 
 tap.test('should support WebSocket connections', async () => {
+  console.log('\n[TEST] ====== WebSocket Test Started ======');
+  console.log('[TEST] Test server port:', 3000);
+  console.log('[TEST] Proxy server port:', 3001);
+  console.log('\n[TEST] Starting WebSocket test');
+
+  // First configure the proxy with test certificates
+  console.log('[TEST] Configuring proxy with test certificates');
+  testProxy.updateProxyConfigs([
+    {
+      destinationIp: '127.0.0.1',
+      destinationPort: '3000',
+      hostName: 'push.rocks',
+      publicKey: testCertificates.publicKey,
+      privateKey: testCertificates.privateKey,
+    }
+  ]);
+
   return new Promise<void>((resolve, reject) => {
-    console.log('Starting WebSocket test...');
-    const ws = new WebSocket('wss://localhost:3001', {
-      rejectUnauthorized: false,
+    console.log('[TEST] Creating WebSocket client');
+
+    // Create WebSocket client with SSL/TLS options
+    const wsUrl = 'wss://push.rocks:3001';
+    console.log('[TEST] Creating WebSocket connection to:', wsUrl);
+    
+    const ws = new WebSocket(wsUrl, {
+      rejectUnauthorized: false, // Accept self-signed certificates
+      handshakeTimeout: 5000,
+      perMessageDeflate: false,
       headers: {
-        'Host': 'push.rocks'
-      }
+        'Host': 'push.rocks',
+        'Connection': 'Upgrade',
+        'Upgrade': 'websocket',
+        'Sec-WebSocket-Version': '13'
+      },
+      protocol: 'echo-protocol',
+      agent: new https.Agent({
+        rejectUnauthorized: false // Also needed for the underlying HTTPS connection
+      })
     });
 
+    console.log('[TEST] WebSocket client created');
+
+    let resolved = false;
+    const cleanup = () => {
+      if (!resolved) {
+        resolved = true;
+        try {
+          console.log('[TEST] Cleaning up WebSocket connection');
+          ws.close();
+          resolve();
+        } catch (error) {
+          console.error('[TEST] Error during cleanup:', error);
+          reject(error);
+        }
+      }
+    };
+
     const timeout = setTimeout(() => {
-      ws.close();
+      console.error('[TEST] WebSocket test timed out');
+      cleanup();
       reject(new Error('WebSocket test timed out after 5 seconds'));
     }, 5000);
 
+    // Connection establishment events
+    ws.on('upgrade', (response) => {
+      console.log('[TEST] WebSocket upgrade response received:', {
+        headers: response.headers,
+        statusCode: response.statusCode
+      });
+    });
+
     ws.on('open', () => {
-      console.log('WebSocket connection opened');
-      ws.send('Hello WebSocket');
+      console.log('[TEST] WebSocket connection opened');
+      try {
+        console.log('[TEST] Sending test message');
+        ws.send('Hello WebSocket');
+      } catch (error) {
+        console.error('[TEST] Error sending message:', error);
+        cleanup();
+        reject(error);
+      }
     });
 
-    ws.on('message', (data) => {
-      console.log('Received message:', data.toString());
-      expect(data.toString()).toEqual('Echo: Hello WebSocket');
-      clearTimeout(timeout);
-      ws.close();
-      resolve();
+    ws.on('message', (message) => {
+      console.log('[TEST] Received message:', message.toString());
+      if (message.toString() === 'Hello WebSocket') {
+        console.log('[TEST] Message received correctly');
+        clearTimeout(timeout);
+        cleanup();
+      }
     });
 
-    ws.on('error', (err) => {
-      console.error('WebSocket error:', err);
-      clearTimeout(timeout);
-      reject(err);
+    ws.on('error', (error) => {
+      console.error('[TEST] WebSocket error:', error);
+      cleanup();
+      reject(error);
     });
 
-    ws.on('close', () => {
-      console.log('WebSocket connection closed');
+    ws.on('close', (code, reason) => {
+      console.log('[TEST] WebSocket connection closed:', {
+        code,
+        reason: reason.toString()
+      });
+      cleanup();
     });
   });
 });
@@ -160,10 +344,36 @@ tap.test('should handle custom headers', async () => {
 });
 
 tap.test('cleanup', async () => {
+  console.log('[TEST] Starting cleanup');
+
   // Clean up all servers
-  await new Promise<void>((resolve) => wsServer.close(() => resolve()));
-  await new Promise<void>((resolve) => testServer.close(() => resolve()));
+  console.log('[TEST] Terminating WebSocket clients');
+  wsServer.clients.forEach((client) => {
+    client.terminate();
+  });
+
+  console.log('[TEST] Closing WebSocket server');
+  await new Promise<void>((resolve) => wsServer.close(() => {
+    console.log('[TEST] WebSocket server closed');
+    resolve();
+  }));
+
+  console.log('[TEST] Closing test server');
+  await new Promise<void>((resolve) => testServer.close(() => {
+    console.log('[TEST] Test server closed');
+    resolve();
+  }));
+
+  console.log('[TEST] Stopping proxy');
   await testProxy.stop();
+  console.log('[TEST] Cleanup complete');
+});
+
+process.on('exit', () => {
+  console.log('[TEST] Shutting down test server');
+  testServer.close(() => console.log('[TEST] Test server shut down'));
+  wsServer.close(() => console.log('[TEST] WebSocket server shut down'));
+  testProxy.stop().then(() => console.log('[TEST] Proxy server stopped'));
 });
 
 tap.start();