@joystick.js/db-canary 0.0.0-canary.2209

package/tests/server/cluster/cluster.test.js

@@ -0,0 +1,248 @@
+import test from 'ava';
+import net from 'net';
+import { encode_message } from '../../../src/server/lib/tcp_protocol.js';
+import { start_cluster } from '../../../src/server/cluster/index.js';
+
+const create_test_settings = () => ({
+  authentication: {
+    password_hash: '$2b$10$test.hash.for.testing.purposes.only'
+  }
+});
+
+test.beforeEach(() => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify(create_test_settings());
+});
+
+test.afterEach(() => {
+  delete process.env.JOYSTICK_DB_SETTINGS;
+});
+
+const send_message = (socket, op, data = {}) => {
+  const message = { op, data };
+  const encoded = encode_message(message);
+  socket.write(encoded);
+};
+
+const wait_for_response = (socket) => {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error('Response timeout'));
+    }, 10000);
+    
+    socket.once('data', (data) => {
+      clearTimeout(timeout);
+      resolve(data);
+    });
+  });
+};
+
+test.serial('cluster starts and accepts connections', async (t) => {
+  // Set test environment for faster worker shutdown
+  process.env.NODE_ENV = 'test';
+  
+  const master = start_cluster({
+    worker_count: 2,
+    port: 1984
+  });
+  
+  let client = null;
+  
+  try {
+    // Wait longer for cluster to fully initialize
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    
+    client = new net.Socket();
+    client.setKeepAlive(false);
+    client.setTimeout(5000);
+    
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        client.destroy();
+        reject(new Error('Connection timeout'));
+      }, 5000);
+      
+      client.connect(1984, 'localhost', () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      
+      client.on('error', (err) => {
+        clearTimeout(timeout);
+        client.destroy();
+        reject(err);
+      });
+      
+      client.on('timeout', () => {
+        clearTimeout(timeout);
+        client.destroy();
+        reject(new Error('Socket timeout'));
+      });
+    });
+    
+    send_message(client, 'ping');
+    const response = await wait_for_response(client);
+    
+    t.truthy(response);
+    
+  } finally {
+    // Ensure client is properly closed
+    if (client) {
+      try {
+        client.end();
+        await new Promise(resolve => setTimeout(resolve, 100));
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+      try {
+        client.destroy();
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+    
+    // Shutdown master and wait for complete cleanup
+    try {
+      await master.shutdown();
+    } catch (error) {
+      // Ignore shutdown errors in tests
+    }
+    
+    // Force aggressive cleanup with longer wait
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    // Force garbage collection if available
+    if (global.gc) {
+      global.gc();
+    }
+  }
+});
+
+test.serial('cluster handles multiple concurrent connections', async (t) => {
+  // Set test environment for faster worker shutdown
+  process.env.NODE_ENV = 'test';
+  
+  const master = start_cluster({
+    worker_count: 2,
+    port: 1985
+  });
+  
+  const clients = [];
+  
+  try {
+    // Wait longer for cluster to fully initialize
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    
+    const connection_promises = [];
+    
+    for (let i = 0; i < 5; i++) {
+      const client = new net.Socket();
+      client.setKeepAlive(false);
+      client.setTimeout(5000);
+      clients.push(client);
+      
+      connection_promises.push(
+        new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            client.destroy();
+            reject(new Error('Connection timeout'));
+          }, 5000);
+          
+          client.connect(1985, 'localhost', () => {
+            clearTimeout(timeout);
+            resolve();
+          });
+          
+          client.on('error', (err) => {
+            clearTimeout(timeout);
+            client.destroy();
+            reject(err);
+          });
+          
+          client.on('timeout', () => {
+            clearTimeout(timeout);
+            client.destroy();
+            reject(new Error('Socket timeout'));
+          });
+        })
+      );
+    }
+    
+    await Promise.all(connection_promises);
+    
+    const ping_promises = clients.map(client => {
+      send_message(client, 'ping');
+      return wait_for_response(client);
+    });
+    
+    const responses = await Promise.all(ping_promises);
+    
+    t.is(responses.length, 5);
+    
+  } finally {
+    // Ensure all clients are properly closed
+    for (const client of clients) {
+      try {
+        client.end();
+        await new Promise(resolve => setTimeout(resolve, 50));
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+      try {
+        client.destroy();
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+    
+    // Shutdown master and wait for complete cleanup
+    try {
+      await master.shutdown();
+    } catch (error) {
+      // Ignore shutdown errors in tests
+    }
+    
+    // Force aggressive cleanup with longer wait
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    // Force garbage collection if available
+    if (global.gc) {
+      global.gc();
+    }
+  }
+});
+
+test.serial('cluster stats are available', async (t) => {
+  // Set test environment for faster worker shutdown
+  process.env.NODE_ENV = 'test';
+  
+  const master = start_cluster({
+    worker_count: 2,
+    port: 1986
+  });
+  
+  try {
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    const stats = master.get_cluster_stats();
+    
+    t.is(typeof stats, 'object');
+    t.is(stats.worker_count, 2);
+    t.is(typeof stats.master_pid, 'number');
+    t.is(Array.isArray(stats.workers), true);
+  } finally {
+    // Shutdown master and wait for complete cleanup
+    try {
+      await master.shutdown();
+    } catch (error) {
+      // Ignore shutdown errors in tests
+    }
+    
+    // Force aggressive cleanup with longer wait
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    // Force garbage collection if available
+    if (global.gc) {
+      global.gc();
+    }
+  }
+});