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

package/tests/server/integration/production_safety_integration.test.js

@@ -0,0 +1,358 @@
+import test from 'ava';
+import net from 'net';
+import { create_server } from '../../../src/server/index.js';
+import { encode_message, create_message_parser } from '../../../src/server/lib/tcp_protocol.js';
+import { initialize_database } from '../../../src/server/lib/query_engine.js';
+import { setup_authentication } from '../../../src/server/lib/auth_manager.js';
+
+let server;
+let port;
+let shared_password;
+
+test.before(async () => {
+  try {
+    // Clean up authentication file for fresh tests
+    try {
+      const { unlinkSync } = await import('fs');
+      unlinkSync('authentication.json');
+    } catch (error) {
+      // File doesn't exist, which is fine
+    }
+    
+    // Initialize database for testing
+    initialize_database();
+    
+    // Create server
+    server = await create_server();
+    
+    // Start server on random port
+    await new Promise((resolve, reject) => {
+      server.listen(0, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        
+        port = server.address().port;
+        resolve();
+      });
+    });
+    
+    // Set up authentication once for all tests
+    const { client, send, receive, close } = await create_client();
+    try {
+      send({ op: 'setup' });
+      const setup_response = await receive();
+      if (setup_response.ok === 1 || setup_response.ok === true) {
+        shared_password = setup_response.password;
+      }
+    } finally {
+      close();
+    }
+  } catch (error) {
+    throw error;
+  }
+});
+
+test.after.always(async () => {
+  if (server) {
+    await server.cleanup();
+    server.close();
+  }
+});
+
+const create_client = () => {
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(port, 'localhost');
+    const parser = create_message_parser();
+    let responses = [];
+    
+    client.on('connect', () => {
+      resolve({
+        client,
+        send: (data) => {
+          const encoded = encode_message(data);
+          client.write(encoded);
+        },
+        receive: () => {
+          return new Promise((resolve) => {
+            const handler = (data) => {
+              try {
+                const messages = parser.parse_messages(data);
+                for (const message of messages) {
+                  // Message is already decoded from MessagePack, no need to JSON.parse
+                  responses.push(message);
+                  client.off('data', handler);
+                  resolve(message);
+                  return;
+                }
+              } catch (error) {
+                // Continue listening
+              }
+            };
+            client.on('data', handler);
+          });
+        },
+        close: () => {
+          client.end();
+        }
+      });
+    });
+    
+    client.on('error', reject);
+  });
+};
+
+test('production safety - ping operation returns ok: 1', async t => {
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    send({ op: 'ping' });
+    const response = await receive();
+    
+    t.is(response.ok, 1);
+  } finally {
+    close();
+  }
+});
+
+test('production safety - admin stats include comprehensive monitoring', async t => {
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // Authenticate using shared password
+    send({ op: 'authentication', data: { password: shared_password } });
+    const auth_response = await receive();
+    t.is(auth_response.ok, 1);
+    
+    // Get admin stats
+    send({ op: 'admin', data: { admin_action: 'stats' } });
+    const stats_response = await receive();
+    
+    t.is(stats_response.ok, 1);
+    
+    // Check comprehensive stats structure
+    t.truthy(stats_response.server);
+    t.truthy(stats_response.memory);
+    t.truthy(stats_response.database);
+    t.truthy(stats_response.performance);
+    t.truthy(stats_response.system);
+    t.truthy(stats_response.connections);
+    t.truthy(stats_response.authentication);
+    
+    // Check server stats
+    t.true(typeof stats_response.server.uptime === 'number');
+    t.true(typeof stats_response.server.uptime_formatted === 'string');
+    t.true(typeof stats_response.server.node_version === 'string');
+    t.true(typeof stats_response.server.platform === 'string');
+    t.true(typeof stats_response.server.arch === 'string');
+    t.true(typeof stats_response.server.pid === 'number');
+    
+    // Check memory stats
+    t.true(typeof stats_response.memory.rss_mb === 'number');
+    t.true(typeof stats_response.memory.heap_total_mb === 'number');
+    t.true(typeof stats_response.memory.heap_used_mb === 'number');
+    t.true(typeof stats_response.memory.heap_used_percent === 'number');
+    t.true(typeof stats_response.memory.external_mb === 'number');
+    
+    // Check database stats
+    t.true(typeof stats_response.database.map_size_mb === 'number');
+    t.true(typeof stats_response.database.used_space_mb === 'number');
+    t.true(typeof stats_response.database.usage_percent === 'number');
+    
+    // Check performance stats
+    t.true(typeof stats_response.performance.ops_per_second === 'number');
+    t.true(typeof stats_response.performance.avg_response_time_ms === 'number');
+    
+    // Check system stats
+    t.true(typeof stats_response.system.node_version === 'string');
+    t.true(typeof stats_response.system.platform === 'string');
+    t.true(typeof stats_response.system.arch === 'string');
+    t.true(typeof stats_response.system.pid === 'number');
+    
+    // Check connection stats
+    t.true(typeof stats_response.connections.total_connections === 'number');
+    t.true(typeof stats_response.connections.max_connections === 'number');
+    
+    // Check authentication stats
+    t.true(typeof stats_response.authentication.authenticated_clients === 'number');
+  } finally {
+    close();
+  }
+});
+
+test('production safety - request timeout handling', async t => {
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // Authenticate using shared password
+    send({ op: 'authentication', data: { password: shared_password } });
+    const auth_response = await receive();
+    t.is(auth_response.ok, 1);
+    
+    // Send a normal operation that should complete quickly
+    send({ op: 'insert_one', data: { collection: 'test_timeout', document: { name: 'test' } } });
+    const response = await receive();
+    
+    t.is(response.ok, 1);
+    t.truthy(response.inserted_id);
+  } finally {
+    close();
+  }
+});
+
+test('production safety - connection limits', async t => {
+  // This test verifies that connection management is working
+  // We can't easily test the actual limit without creating 1000+ connections
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    send({ op: 'ping' });
+    const response = await receive();
+    
+    t.is(response.ok, 1);
+    
+    // Connection should be tracked
+    // We can verify this by checking that the connection was accepted
+    t.pass();
+  } finally {
+    close();
+  }
+});
+
+test('production safety - structured logging for operations', async t => {
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // Authenticate using shared password
+    send({ op: 'authentication', data: { password: shared_password } });
+    const auth_response = await receive();
+    t.is(auth_response.ok, 1);
+    
+    // Perform database operation that should be logged
+    send({ op: 'insert_one', data: { collection: 'test_logging', document: { name: 'test_log' } } });
+    const response = await receive();
+    
+    t.is(response.ok, 1);
+    t.truthy(response.inserted_id);
+    
+    // The operation should have been logged with structured format
+    // We can't easily verify the log output in tests, but we can verify the operation succeeded
+    t.pass();
+  } finally {
+    close();
+  }
+});
+
+test('production safety - error handling and categorization', async t => {
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // Authenticate using shared password
+    send({ op: 'authentication', data: { password: shared_password } });
+    const auth_response = await receive();
+    t.is(auth_response.ok, 1);
+    
+    // Try an operation that should fail
+    send({ op: 'insert_one', data: { collection: '', document: { name: 'test' } } });
+    const response = await receive();
+    
+    t.is(response.ok, 0);
+    t.truthy(response.error);
+    t.true(response.error.includes('Collection name is required'));
+  } finally {
+    close();
+  }
+});
+
+test('production safety - performance metrics tracking', async t => {
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // Authenticate using shared password
+    send({ op: 'authentication', data: { password: shared_password } });
+    const auth_response = await receive();
+    t.is(auth_response.ok, 1);
+    
+    // Perform several operations to generate metrics
+    for (let i = 0; i < 5; i++) {
+      send({ op: 'insert_one', data: { collection: 'test_metrics', document: { index: i } } });
+      await receive();
+    }
+    
+    // Get stats to verify metrics are being tracked
+    send({ op: 'admin', data: { admin_action: 'stats' } });
+    const stats_response = await receive();
+    
+    t.is(stats_response.ok, 1);
+    t.true(typeof stats_response.performance.ops_per_second === 'number');
+    t.true(typeof stats_response.performance.avg_response_time_ms === 'number');
+  } finally {
+    close();
+  }
+});
+
+test('production safety - memory and resource monitoring', async t => {
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // Authenticate using shared password
+    send({ op: 'authentication', data: { password: shared_password } });
+    const auth_response = await receive();
+    t.is(auth_response.ok, 1);
+    
+    // Get stats to verify resource monitoring
+    send({ op: 'admin', data: { admin_action: 'stats' } });
+    const stats_response = await receive();
+    
+    t.is(stats_response.ok, 1);
+    
+    // Verify memory monitoring
+    t.true(stats_response.memory.rss_mb > 0);
+    t.true(stats_response.memory.heap_total_mb > 0);
+    t.true(stats_response.memory.heap_used_mb > 0);
+    t.true(stats_response.memory.heap_used_percent >= 0 && stats_response.memory.heap_used_percent <= 100);
+    
+    // Verify database resource monitoring
+    t.true(stats_response.database.map_size_mb >= 0);
+    t.true(stats_response.database.used_space_mb >= 0);
+    t.true(stats_response.database.usage_percent >= 0 && stats_response.database.usage_percent <= 100);
+    
+    // Verify system resource monitoring
+    t.true(stats_response.system.cpu_user_ms >= 0);
+    t.true(stats_response.system.cpu_system_ms >= 0);
+  } finally {
+    close();
+  }
+});
+
+test('production safety - connection management stats', async t => {
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // Authenticate using shared password
+    send({ op: 'authentication', data: { password: shared_password } });
+    const auth_response = await receive();
+    t.is(auth_response.ok, 1);
+    
+    // Get stats to verify connection management
+    send({ op: 'admin', data: { admin_action: 'stats' } });
+    const stats_response = await receive();
+    
+    t.is(stats_response.ok, 1);
+    
+    // Verify connection stats
+    t.true(typeof stats_response.connections.total_connections === 'number');
+    t.true(typeof stats_response.connections.max_connections === 'number');
+    t.true(typeof stats_response.connections.total_requests === 'number');
+    t.true(typeof stats_response.connections.idle_timeout_ms === 'number');
+    t.true(typeof stats_response.connections.request_timeout_ms === 'number');
+    
+    t.true(stats_response.connections.total_connections >= 1); // At least our connection
+    t.is(stats_response.connections.max_connections, 1000); // Default max
+    t.is(stats_response.connections.idle_timeout_ms, 10 * 60 * 1000); // 10 minutes
+    t.is(stats_response.connections.request_timeout_ms, 5 * 1000); // 5 seconds
+  } finally {
+    close();
+  }
+});

package/tests/server/integration/replication_integration.test.js

@@ -0,0 +1,227 @@
+import test from 'ava';
+import fs from 'fs';
+import net from 'net';
+import { create_server } from '../../../src/server/index.js';
+import { setup_authentication, reset_auth_state } from '../../../src/server/lib/auth_manager.js';
+import { initialize_database } from '../../../src/server/lib/query_engine.js';
+import { encode_message, create_message_parser } from '../../../src/server/lib/tcp_protocol.js';
+
+const AUTH_FILE_PATH = './settings.db.json';
+
+// Shared server instance
+let shared_server = null;
+let shared_port = null;
+let shared_password = null;
+
+test.before(async () => {
+  // Set test environment
+  process.env.NODE_ENV = 'test';
+  
+  // Reset auth state and clean up any existing auth files
+  reset_auth_state();
+  if (fs.existsSync(AUTH_FILE_PATH)) {
+    fs.unlinkSync(AUTH_FILE_PATH);
+  }
+  
+  // Initialize database for testing
+  initialize_database();
+  
+  // Create shared server instance
+  shared_server = await create_server();
+  
+  // Start server on random port
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error('Server start timeout'));
+    }, 5000);
+    
+    shared_server.listen(0, (error) => {
+      clearTimeout(timeout);
+      if (error) {
+        reject(error);
+      } else {
+        shared_port = shared_server.address().port;
+        resolve();
+      }
+    });
+  });
+});
+
+test.after.always(async () => {
+  // Clean up shared server
+  if (shared_server) {
+    try {
+      if (shared_server.cleanup) {
+        await shared_server.cleanup();
+      }
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+    
+    await new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        try {
+          shared_server.close();
+        } catch (error) {
+          // Ignore errors
+        }
+        resolve();
+      }, 2000);
+      
+      try {
+        shared_server.close(() => {
+          clearTimeout(timeout);
+          resolve();
+        });
+      } catch (error) {
+        clearTimeout(timeout);
+        resolve();
+      }
+    });
+    
+    shared_server = null;
+  }
+  
+  // Reset auth state and clean up auth files
+  reset_auth_state();
+  if (fs.existsSync(AUTH_FILE_PATH)) {
+    try {
+      fs.unlinkSync(AUTH_FILE_PATH);
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  }
+  
+  // Force garbage collection if available
+  if (global.gc) {
+    global.gc();
+  }
+});
+
+test.beforeEach(() => {
+  // Reset auth state before each test
+  reset_auth_state();
+  if (fs.existsSync(AUTH_FILE_PATH)) {
+    fs.unlinkSync(AUTH_FILE_PATH);
+  }
+});
+
+const create_client = () => {
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(shared_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) => {
+            const handler = (data) => {
+              try {
+                const messages = parser.parse_messages(data);
+                for (const message of messages) {
+                  client.off('data', handler);
+                  resolve(message);
+                  return;
+                }
+              } catch (error) {
+                // Continue listening
+              }
+            };
+            client.on('data', handler);
+          });
+        },
+        close: () => {
+          client.end();
+        }
+      });
+    });
+    
+    client.on('error', reject);
+  });
+};
+
+test('replication admin operations - get status when disabled', async t => {
+  // Setup authentication first
+  const password = setup_authentication();
+  
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // First authenticate
+    send({ op: 'authentication', data: { password } });
+    const auth_response = await receive();
+    t.is(auth_response.ok, 1);
+    
+    // Get admin status
+    send({ op: 'admin' });
+    const admin_response = await receive();
+    
+    // Admin response should include server info
+    t.is(typeof admin_response.server, 'object');
+    t.is(typeof admin_response.database, 'object');
+    t.is(typeof admin_response.authentication, 'object');
+  } finally {
+    close();
+  }
+});
+
+test('replication integration - basic server functionality works', async t => {
+  // Setup authentication first
+  const password = setup_authentication();
+  
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // First authenticate
+    send({ op: 'authentication', data: { password } });
+    const auth_response = await receive();
+    t.is(auth_response.ok, 1);
+    
+    // Test basic ping operation
+    send({ op: 'ping' });
+    const ping_response = await receive();
+    t.is(ping_response.ok, 1);
+    
+    // Test admin operation works
+    send({ op: 'admin' });
+    const admin_response = await receive();
+    
+    // Admin response should include basic server info
+    t.is(typeof admin_response.server, 'object');
+    t.is(typeof admin_response.database, 'object');
+  } finally {
+    close();
+  }
+});
+
+test('replication integration - database operations work normally', async t => {
+  // Setup authentication first
+  const password = setup_authentication();
+  
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // First authenticate
+    send({ op: 'authentication', data: { password } });
+    const auth_response = await receive();
+    t.is(auth_response.ok, 1);
+    
+    // Test insert operation
+    send({ op: 'insert_one', data: { collection: 'test', document: { name: 'test', value: 1 } } });
+    const insert_response = await receive();
+    t.is(insert_response.ok, 1);
+    
+    // Test find operation
+    send({ op: 'find_one', data: { collection: 'test', filter: { name: 'test' } } });
+    const find_response = await receive();
+    t.is(find_response.ok, 1);
+    t.is(find_response.document.name, 'test');
+  } finally {
+    close();
+  }
+});