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

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

@@ -0,0 +1,577 @@
+import test from 'ava';
+import net from 'net';
+import cluster from 'cluster';
+import { encode_message, create_message_parser } from '../../../src/server/lib/tcp_protocol.js';
+import { start_cluster } from '../../../src/server/cluster/index.js';
+import { setup_authentication, reset_auth_state } from '../../../src/server/lib/auth_manager.js';
+
+const create_test_settings = () => ({
+  port: 1983,
+  cluster: true,
+  worker_count: 2,
+  authentication: {},
+  backup: { enabled: false },
+  replication: { enabled: false, role: "primary" },
+  auto_indexing: { enabled: true, threshold: 100 },
+  performance: {
+    monitoring_enabled: true,
+    log_slow_queries: true,
+    slow_query_threshold_ms: 1000
+  },
+  logging: { level: "info", structured: true }
+});
+
+const cleanup_cluster_state = async () => {
+  // Force kill any remaining workers from previous tests
+  for (const worker_id in cluster.workers) {
+    const worker = cluster.workers[worker_id];
+    if (worker && !worker.isDead()) {
+      try {
+        worker.kill('SIGKILL');
+      } catch (error) {
+        // Ignore kill errors
+      }
+    }
+  }
+  
+  // Clear cluster workers map
+  for (const worker_id in cluster.workers) {
+    delete cluster.workers[worker_id];
+  }
+  
+  // Remove all cluster event listeners to prevent cross-test interference
+  cluster.removeAllListeners();
+  
+  // Wait longer for cleanup to complete
+  await new Promise(resolve => setTimeout(resolve, 500));
+};
+
+test.beforeEach(async () => {
+  reset_auth_state();
+  shared_password = null; // Reset shared password for each test
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify(create_test_settings());
+  
+  // Clean up any lingering cluster state
+  await cleanup_cluster_state();
+});
+
+test.afterEach(async () => {
+  reset_auth_state();
+  shared_password = null; // Reset shared password after each test
+  delete process.env.JOYSTICK_DB_SETTINGS;
+  
+  // Clean up cluster state after each test
+  await cleanup_cluster_state();
+});
+
+const create_client = (port) => {
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(port, 'localhost');
+    const parser = create_message_parser();
+    
+    client.on('connect', () => {
+      resolve({
+        client,
+        send: (data) => {
+          const encoded = encode_message(data);
+          client.write(encoded);
+        },
+        receive: () => {
+          return new Promise((resolve, reject) => {
+            const handler = (data) => {
+              try {
+                const messages = parser.parse_messages(data);
+                for (const message of messages) {
+                  client.off('data', handler);
+                  client.off('close', close_handler);
+                  client.off('error', error_handler);
+                  resolve(message);
+                  return;
+                }
+              } catch (error) {
+                // Continue listening
+              }
+            };
+            
+            const close_handler = () => {
+              client.off('data', handler);
+              client.off('error', error_handler);
+              reject(new Error('Connection closed before receiving response'));
+            };
+            
+            const error_handler = (error) => {
+              client.off('data', handler);
+              client.off('close', close_handler);
+              reject(error);
+            };
+            
+            client.on('data', handler);
+            client.on('close', close_handler);
+            client.on('error', error_handler);
+          });
+        },
+        close: () => {
+          client.end();
+        }
+      });
+    });
+    
+    client.on('error', reject);
+  });
+};
+
+let shared_password = null;
+
+const authenticate_client = async (client) => {
+  // Setup authentication only once and reuse the password
+  if (!shared_password) {
+    shared_password = setup_authentication();
+  }
+  
+  client.send({ op: 'authentication', data: { password: shared_password } });
+  const auth_response = await client.receive();
+  
+  if (auth_response.ok !== 1) {
+    throw new Error(`Authentication failed: ${auth_response.error || 'Unknown error'}`);
+  }
+  
+  return shared_password;
+};
+
+test.serial('master node handles read operations - find_one', async (t) => {
+  process.env.NODE_ENV = 'test';
+  
+  const master = start_cluster({
+    worker_count: 1,
+    port: 1990
+  });
+  
+  let client = null;
+  
+  try {
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    
+    client = await create_client(1990);
+    
+    // Authenticate using setup flow
+    await authenticate_client(client);
+    
+    // Insert a document first
+    client.send({ 
+      op: 'insert_one', 
+      data: { 
+        collection: 'test_master_reads', 
+        document: { name: 'test_doc', value: 42 } 
+      } 
+    });
+    const insert_response = await client.receive();
+    t.is(insert_response.ok, 1);
+    
+    // Wait a bit before the read operation to ensure write is fully committed
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    // Test find_one operation (read operation)
+    client.send({ 
+      op: 'find_one', 
+      data: { 
+        collection: 'test_master_reads', 
+        filter: { name: 'test_doc' } 
+      } 
+    });
+    const find_response = await client.receive();
+    t.is(find_response.ok, 1);
+    t.truthy(find_response.name, 'Response should have name field');
+    t.is(find_response.name, 'test_doc');
+    t.is(find_response.value, 42);
+    
+  } finally {
+    if (client) {
+      try {
+        client.close();
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+    
+    // Wait for any pending operations to complete before shutdown
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    try {
+      await master.shutdown();
+    } catch (error) {
+      // Ignore shutdown errors in tests
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    if (global.gc) {
+      global.gc();
+    }
+  }
+});
+
+test.serial('master node handles read operations - find', async (t) => {
+  process.env.NODE_ENV = 'test';
+  
+  const master = start_cluster({
+    worker_count: 1,
+    port: 1991
+  });
+  
+  let client = null;
+  
+  try {
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    
+    client = await create_client(1991);
+    
+    // Authenticate using setup flow
+    await authenticate_client(client);
+    
+    // Insert multiple documents with longer wait between inserts
+    client.send({ 
+      op: 'insert_one', 
+      data: { 
+        collection: 'test_master_find', 
+        document: { category: 'test', value: 1 } 
+      } 
+    });
+    const insert1_response = await client.receive();
+    t.is(insert1_response.ok, 1);
+    
+    // Wait longer between inserts to ensure proper commit
+    await new Promise(resolve => setTimeout(resolve, 200));
+    
+    client.send({ 
+      op: 'insert_one', 
+      data: { 
+        collection: 'test_master_find', 
+        document: { category: 'test', value: 2 } 
+      } 
+    });
+    const insert2_response = await client.receive();
+    t.is(insert2_response.ok, 1);
+    
+    // Wait longer to ensure both documents are fully committed
+    await new Promise(resolve => setTimeout(resolve, 300));
+    
+    // Test find operation (read operation)
+    client.send({ 
+      op: 'find', 
+      data: { 
+        collection: 'test_master_find', 
+        filter: { category: 'test' } 
+      } 
+    });
+    const find_response = await client.receive();
+    t.is(find_response.ok, 1);
+    t.is(Array.isArray(find_response.documents), true);
+    t.is(find_response.documents.length >= 2, true);
+    
+  } finally {
+    if (client) {
+      try {
+        client.close();
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+    
+    // Wait for any pending operations to complete before shutdown
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    try {
+      await master.shutdown();
+    } catch (error) {
+      // Ignore shutdown errors in tests
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    if (global.gc) {
+      global.gc();
+    }
+  }
+});
+
+test.serial('master node handles read operations - get_indexes', async (t) => {
+  process.env.NODE_ENV = 'test';
+  
+  const master = start_cluster({
+    worker_count: 1,
+    port: 1992
+  });
+  
+  let client = null;
+  
+  try {
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    
+    client = await create_client(1992);
+    
+    // Authenticate using setup flow
+    await authenticate_client(client);
+    
+    // Create an index first
+    client.send({ 
+      op: 'create_index', 
+      data: { 
+        collection: 'test_master_indexes', 
+        field: 'name',
+        options: {}
+      } 
+    });
+    const create_index_response = await client.receive();
+    t.is(create_index_response.ok, 1);
+    
+    // Test get_indexes operation (read operation)
+    client.send({ 
+      op: 'get_indexes', 
+      data: { 
+        collection: 'test_master_indexes'
+      } 
+    });
+    const get_indexes_response = await client.receive();
+    t.is(get_indexes_response.ok, 1);
+    t.is(Array.isArray(get_indexes_response.indexes), true);
+    t.is(get_indexes_response.indexes.length, 1);
+    t.is(get_indexes_response.indexes[0].field, 'name');
+    
+  } finally {
+    if (client) {
+      try {
+        client.close();
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+    
+    // Wait for any pending operations to complete before shutdown
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    try {
+      await master.shutdown();
+    } catch (error) {
+      // Ignore shutdown errors in tests
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    if (global.gc) {
+      global.gc();
+    }
+  }
+});
+
+test.serial('master node handles mixed read and write operations', async (t) => {
+  process.env.NODE_ENV = 'test';
+  
+  const master = start_cluster({
+    worker_count: 2,
+    port: 1993
+  });
+  
+  let client = null;
+  
+  try {
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    
+    client = await create_client(1993);
+    
+    // Authenticate using setup flow
+    await authenticate_client(client);
+    
+    // Mixed operations sequence with proper waits
+    
+    // Use unique document name to avoid conflicts with previous test runs
+    const unique_doc_name = `doc1_${Date.now()}`;
+    
+    // 1. Write: Insert document
+    client.send({ 
+      op: 'insert_one', 
+      data: { 
+        collection: 'test_mixed_ops', 
+        document: { name: unique_doc_name, status: 'active' } 
+      } 
+    });
+    const insert_response = await client.receive();
+    t.is(insert_response.ok, 1);
+    
+    // Wait for write to commit
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    // 2. Read: Find the document
+    client.send({ 
+      op: 'find_one', 
+      data: { 
+        collection: 'test_mixed_ops', 
+        filter: { name: unique_doc_name } 
+      } 
+    });
+    const find_response = await client.receive();
+    t.is(find_response.ok, 1);
+    t.is(find_response.name, unique_doc_name);
+    t.is(find_response.status, 'active');
+    
+    // 3. Write: Update document
+    client.send({ 
+      op: 'update_one', 
+      data: { 
+        collection: 'test_mixed_ops', 
+        filter: { name: unique_doc_name },
+        update: { $set: { status: 'updated' } }
+      } 
+    });
+    const update_response = await client.receive();
+    t.is(update_response.ok, 1);
+    t.is(update_response.modified_count, 1);
+    
+    // Wait for update to commit
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    // 4. Read: Verify update
+    client.send({ 
+      op: 'find_one', 
+      data: { 
+        collection: 'test_mixed_ops', 
+        filter: { name: unique_doc_name } 
+      } 
+    });
+    const find_updated_response = await client.receive();
+    t.is(find_updated_response.ok, 1);
+    t.is(find_updated_response.status, 'updated');
+    
+    // 5. Write: Create index
+    client.send({ 
+      op: 'create_index', 
+      data: { 
+        collection: 'test_mixed_ops', 
+        field: 'status',
+        options: {}
+      } 
+    });
+    const create_index_response = await client.receive();
+    t.is(create_index_response.ok, 1);
+    
+    // 6. Read: Get indexes
+    client.send({ 
+      op: 'get_indexes', 
+      data: { 
+        collection: 'test_mixed_ops'
+      } 
+    });
+    const get_indexes_response = await client.receive();
+    t.is(get_indexes_response.ok, 1);
+    t.is(get_indexes_response.indexes.length, 1);
+    
+  } finally {
+    if (client) {
+      try {
+        client.close();
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+    
+    // Wait for any pending operations to complete before shutdown
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    try {
+      await master.shutdown();
+    } catch (error) {
+      // Ignore shutdown errors in tests
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    if (global.gc) {
+      global.gc();
+    }
+  }
+});
+
+test.serial('master node handles concurrent read and write operations', async (t) => {
+  process.env.NODE_ENV = 'test';
+  
+  const master = start_cluster({
+    worker_count: 2,
+    port: 1994
+  });
+  
+  const clients = [];
+  
+  try {
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    
+    // Create multiple clients and authenticate each one separately
+    for (let i = 0; i < 3; i++) {
+      const client = await create_client(1994);
+      await authenticate_client(client);
+      clients.push(client);
+      
+      // Wait between client connections to avoid auth conflicts
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    
+    // Sequential operations instead of concurrent to avoid auth conflicts
+    
+    // Client 1: Write operation
+    clients[0].send({ 
+      op: 'insert_one', 
+      data: { 
+        collection: 'test_concurrent', 
+        document: { id: 1, type: 'write' } 
+      } 
+    });
+    const insert_result = await clients[0].receive();
+    t.is(insert_result.ok, 1);
+    
+    // Wait for write to commit
+    await new Promise(resolve => setTimeout(resolve, 200));
+    
+    // Client 2: Read operation
+    clients[1].send({ 
+      op: 'find', 
+      data: { 
+        collection: 'test_concurrent', 
+        filter: {} 
+      } 
+    });
+    const find_result = await clients[1].receive();
+    t.is(find_result.ok, 1);
+    
+    // Client 3: Index operation
+    clients[2].send({ 
+      op: 'get_indexes', 
+      data: { 
+        collection: 'test_concurrent'
+      } 
+    });
+    const indexes_result = await clients[2].receive();
+    t.is(indexes_result.ok, 1);
+    
+  } finally {
+    for (const client of clients) {
+      try {
+        client.close();
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+    
+    // Wait for any pending operations to complete before shutdown
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    try {
+      await master.shutdown();
+    } catch (error) {
+      // Ignore shutdown errors in tests
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    if (global.gc) {
+      global.gc();
+    }
+  }
+});