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

package/tests/server/lib/operations/admin.test.js

@@ -0,0 +1,638 @@
+import test from 'ava';
+import net from 'net';
+import fs from 'fs';
+import { encode as encode_messagepack, decode as decode_messagepack } from 'msgpackr';
+import { create_server } from '../../../../src/server/index.js';
+import { initialize_database, get_database, cleanup_database } from '../../../../src/server/lib/query_engine.js';
+import { reset_auth_state } from '../../../../src/server/lib/auth_manager.js';
+
+// Dynamic port allocation
+let current_port = 4000;
+const get_next_port = () => {
+  return ++current_port;
+};
+
+let server;
+let port;
+
+test.beforeEach(async () => {
+  // Reset auth state
+  reset_auth_state();
+  
+  // Initialize test database and clear it for clean state between tests
+  initialize_database('./test_data');
+  try {
+    const db = get_database();
+    db.clearSync();
+  } catch (error) {
+    // Ignore errors during cleanup
+  }
+  
+  // Create server with dynamic port
+  const test_port = get_next_port();
+  server = await create_server();
+  
+  // Start server on specific port
+  await new Promise((resolve) => {
+    server.listen(test_port, () => {
+      port = test_port;
+      setTimeout(resolve, 100);
+    });
+  });
+});
+
+test.afterEach(async () => {
+  if (server) {
+    await server.cleanup();
+    server.close();
+    server = null;
+  }
+  
+  // Clean up auth state after each test
+  reset_auth_state();
+  
+  // Clean up database
+  await cleanup_database();
+});
+
+const create_client = () => {
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(port, 'localhost');
+    
+    client.on('connect', () => {
+      resolve(client);
+    });
+    
+    client.on('error', reject);
+  });
+};
+
+const send_message = (client, message) => {
+  return new Promise((resolve, reject) => {
+    // Encode the message object directly (not as JSON string first)
+    const encoded_message = encode_messagepack(message);
+    const length_buffer = Buffer.alloc(4);
+    length_buffer.writeUInt32BE(encoded_message.length, 0);
+    
+    let response_data = Buffer.alloc(0);
+    let expected_length = null;
+    let header_received = false;
+    
+    const handle_data = (data) => {
+      response_data = Buffer.concat([response_data, data]);
+      
+      if (!header_received && response_data.length >= 4) {
+        expected_length = response_data.readUInt32BE(0);
+        header_received = true;
+      }
+      
+      if (header_received && response_data.length >= expected_length + 4) {
+        client.removeListener('data', handle_data);
+        const message_data = response_data.slice(4, expected_length + 4);
+        
+        try {
+          const response = decode_messagepack(message_data);
+          resolve(response);
+        } catch (error) {
+          reject(new Error(`Failed to parse response: ${error.message}`));
+        }
+      }
+    };
+    
+    client.on('data', handle_data);
+    client.write(Buffer.concat([length_buffer, encoded_message]));
+    
+    setTimeout(() => {
+      client.removeListener('data', handle_data);
+      reject(new Error('Response timeout'));
+    }, 5000);
+  });
+};
+
+const authenticate_client = async (client) => {
+  // First setup authentication
+  const setup_response = await send_message(client, {
+    op: 'setup',
+    data: {}
+  });
+  
+  if (!setup_response.ok) {
+    throw new Error(`Setup failed: ${JSON.stringify(setup_response.error || setup_response)}`);
+  }
+  
+  const password = setup_response.password;
+  if (!password) {
+    throw new Error(`Setup response did not contain password: ${JSON.stringify(setup_response)}`);
+  }
+  
+  // Then authenticate
+  const auth_response = await send_message(client, {
+    op: 'authentication',
+    data: { password }
+  });
+  
+  if (!auth_response.ok) {
+    throw new Error(`Authentication failed: ${JSON.stringify(auth_response.error || auth_response)}`);
+  }
+  
+  return password;
+};
+
+test('admin operation - default (backward compatibility)', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {}
+  });
+  
+  t.is(response.ok, true);
+  t.truthy(response.server);
+  t.truthy(response.database);
+  t.truthy(response.connections);
+  t.truthy(response.authentication);
+  t.truthy(response.settings);
+  
+  // Check server info
+  t.is(typeof response.server.uptime, 'number');
+  t.is(typeof response.server.uptime_formatted, 'string');
+  t.truthy(response.server.memory_usage);
+  t.is(typeof response.server.node_version, 'string');
+  t.is(typeof response.server.platform, 'string');
+  t.is(typeof response.server.pid, 'number');
+  
+  // Check database info
+  t.is(typeof response.database.total_documents, 'number');
+  t.is(typeof response.database.total_collections, 'number');
+  t.truthy(response.database.stats);
+  t.is(typeof response.database.map_size_usage_percent, 'number');
+  
+  client.end();
+});
+
+test('admin operation - stats action', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  const response = await send_message(client, {
+    op: 'admin',
+    data: { admin_action: 'stats' }
+  });
+  
+  t.is(response.ok, 1);
+  t.truthy(response.server);
+  t.truthy(response.database);
+  t.truthy(response.performance);
+  t.truthy(response.connections);
+  t.truthy(response.write_queue);
+  t.truthy(response.authentication);
+  
+  // Check performance metrics
+  t.is(typeof response.performance.ops_per_second, 'number');
+  t.is(typeof response.performance.avg_response_time_ms, 'number');
+  
+  // Check enhanced database info
+  t.is(typeof response.database.map_size_mb, 'number');
+  t.is(typeof response.database.used_space_mb, 'number');
+  t.is(typeof response.database.usage_percent, 'number');
+  
+  client.end();
+});
+
+test('admin operation - list_collections action', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  // Insert some test data first
+  await send_message(client, {
+    op: 'insert_one',
+    data: {
+      collection: 'test_collection',
+      document: { name: 'test', value: 123 }
+    }
+  });
+  
+  await send_message(client, {
+    op: 'insert_one',
+    data: {
+      collection: 'another_collection',
+      document: { title: 'test', count: 456 }
+    }
+  });
+  
+  const response = await send_message(client, {
+    op: 'admin',
+    data: { admin_action: 'list_collections' }
+  });
+  
+  t.is(response.ok, 1);
+  t.truthy(response.collections);
+  t.is(typeof response.total_collections, 'number');
+  t.is(typeof response.total_documents, 'number');
+  t.true(response.total_collections >= 2);
+  t.true(response.total_documents >= 2);
+  
+  // Check collection structure
+  const test_collection = response.collections.find(col => col.name === 'test_collection');
+  t.truthy(test_collection);
+  t.is(typeof test_collection.document_count, 'number');
+  t.true(Array.isArray(test_collection.indexes));
+  t.is(typeof test_collection.estimated_size_bytes, 'number');
+  
+  client.end();
+});
+
+test('admin operation - list_documents action', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  // Insert test documents
+  const test_docs = [
+    { name: 'doc1', value: 100 },
+    { name: 'doc2', value: 200 },
+    { name: 'doc3', value: 300 }
+  ];
+  
+  for (const doc of test_docs) {
+    await send_message(client, {
+      op: 'insert_one',
+      data: {
+        collection: 'list_test',
+        document: doc
+      }
+    });
+  }
+  
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {
+      admin_action: 'list_documents',
+      collection: 'list_test',
+      limit: 2
+    }
+  });
+  
+  t.is(response.ok, 1);
+  t.is(response.collection, 'list_test');
+  t.true(Array.isArray(response.documents));
+  t.is(response.documents.length, 2);
+  t.is(response.count, 2);
+  t.is(response.skip, 0);
+  t.is(response.limit, 2);
+  t.is(response.has_more, true);
+  
+  // Check document structure
+  const first_doc = response.documents[0];
+  t.truthy(first_doc._id);
+  t.truthy(first_doc.name);
+  t.is(typeof first_doc.value, 'number');
+  
+  client.end();
+});
+
+test('admin operation - list_documents with pagination', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  // Insert test documents for pagination
+  const test_docs = [
+    { name: 'page_doc1', value: 100 },
+    { name: 'page_doc2', value: 200 },
+    { name: 'page_doc3', value: 300 }
+  ];
+  
+  for (const doc of test_docs) {
+    await send_message(client, {
+      op: 'insert_one',
+      data: {
+        collection: 'pagination_test',
+        document: doc
+      }
+    });
+  }
+  
+  // Test pagination
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {
+      admin_action: 'list_documents',
+      collection: 'pagination_test',
+      limit: 1,
+      skip: 1
+    }
+  });
+  
+  t.is(response.ok, 1);
+  t.is(response.documents.length, 1);
+  t.is(response.skip, 1);
+  t.is(response.limit, 1);
+  
+  client.end();
+});
+
+test('admin operation - get_document action', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  // Insert a test document
+  const insert_response = await send_message(client, {
+    op: 'insert_one',
+    data: {
+      collection: 'get_test',
+      document: { name: 'specific_doc', value: 999 }
+    }
+  });
+  
+  const document_id = insert_response.inserted_id;
+  
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {
+      admin_action: 'get_document',
+      collection: 'get_test',
+      document_id
+    }
+  });
+  
+  t.is(response.ok, 1);
+  t.is(response.found, true);
+  t.is(response.collection, 'get_test');
+  t.is(response.document_id, document_id);
+  t.truthy(response.document);
+  t.is(response.document._id, document_id);
+  t.is(response.document.name, 'specific_doc');
+  t.is(response.document.value, 999);
+  
+  client.end();
+});
+
+test('admin operation - get_document not found', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {
+      admin_action: 'get_document',
+      collection: 'get_test',
+      document_id: 'nonexistent'
+    }
+  });
+  
+  t.is(response.ok, 1);
+  t.is(response.found, false);
+  t.is(response.collection, 'get_test');
+  t.is(response.document_id, 'nonexistent');
+  
+  client.end();
+});
+
+test('admin operation - query_documents action', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  // Insert test documents with different values
+  const test_docs = [
+    { category: 'A', score: 85 },
+    { category: 'B', score: 92 },
+    { category: 'A', score: 78 },
+    { category: 'C', score: 95 }
+  ];
+  
+  for (const doc of test_docs) {
+    await send_message(client, {
+      op: 'insert_one',
+      data: {
+        collection: 'query_test',
+        document: doc
+      }
+    });
+  }
+  
+  // Query for category 'A'
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {
+      admin_action: 'query_documents',
+      collection: 'query_test',
+      filter: { category: 'A' }
+    }
+  });
+  
+  t.is(response.ok, 1);
+  t.is(response.collection, 'query_test');
+  t.deepEqual(response.filter, { category: 'A' });
+  t.true(Array.isArray(response.documents));
+  t.is(response.documents.length, 2);
+  t.is(typeof response.total_examined, 'number');
+  t.true(response.total_examined >= 2);
+  
+  // Check that all returned documents match the filter
+  response.documents.forEach(doc => {
+    t.is(doc.category, 'A');
+    t.truthy(doc._id);
+    t.is(typeof doc.score, 'number');
+  });
+  
+  client.end();
+});
+
+test('admin operation - query_documents with operators', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  // Query with $gt operator
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {
+      admin_action: 'query_documents',
+      collection: 'query_test',
+      filter: { score: { $gt: 90 } }
+    }
+  });
+  
+  t.is(response.ok, 1);
+  t.true(Array.isArray(response.documents));
+  
+  // All returned documents should have score > 90
+  response.documents.forEach(doc => {
+    t.true(doc.score > 90);
+  });
+  
+  client.end();
+});
+
+test('admin operation - insert_document action', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {
+      admin_action: 'insert_document',
+      collection: 'admin_insert_test',
+      document: { name: 'admin_inserted', value: 777 }
+    }
+  });
+  
+  t.is(response.ok, 1);
+  t.truthy(response.inserted_id);
+  t.is(response.acknowledged, true);
+  
+  // Verify the document was inserted
+  const verify_response = await send_message(client, {
+    op: 'find_one',
+    data: {
+      collection: 'admin_insert_test',
+      filter: { name: 'admin_inserted' }
+    }
+  });
+  
+  t.is(verify_response.ok, 1);
+  t.truthy(verify_response.document);
+  t.is(verify_response.document.name, 'admin_inserted');
+  t.is(verify_response.document.value, 777);
+  
+  client.end();
+});
+
+test('admin operation - update_document action', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  // Insert a document to update
+  const insert_response = await send_message(client, {
+    op: 'insert_one',
+    data: {
+      collection: 'admin_update_test',
+      document: { name: 'to_update', value: 100 }
+    }
+  });
+  
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {
+      admin_action: 'update_document',
+      collection: 'admin_update_test',
+      filter: { name: 'to_update' },
+      update: { $set: { value: 200, updated: true } }
+    }
+  });
+  
+  t.is(response.ok, 1);
+  t.is(response.matched_count, 1);
+  t.is(response.modified_count, 1);
+  t.is(response.acknowledged, true);
+  
+  // Verify the update
+  const verify_response = await send_message(client, {
+    op: 'find_one',
+    data: {
+      collection: 'admin_update_test',
+      filter: { name: 'to_update' }
+    }
+  });
+  
+  t.is(verify_response.ok, 1);
+  t.is(verify_response.document.value, 200);
+  t.is(verify_response.document.updated, true);
+  
+  client.end();
+});
+
+test('admin operation - delete_document action', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  // Insert a document to delete
+  await send_message(client, {
+    op: 'insert_one',
+    data: {
+      collection: 'admin_delete_test',
+      document: { name: 'to_delete', value: 100 }
+    }
+  });
+  
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {
+      admin_action: 'delete_document',
+      collection: 'admin_delete_test',
+      filter: { name: 'to_delete' }
+    }
+  });
+  
+  t.is(response.ok, 1);
+  t.is(response.deleted_count, 1);
+  t.is(response.acknowledged, true);
+  
+  // Verify the document was deleted
+  const verify_response = await send_message(client, {
+    op: 'find_one',
+    data: {
+      collection: 'admin_delete_test',
+      filter: { name: 'to_delete' }
+    }
+  });
+  
+  t.is(verify_response.ok, 1);
+  t.is(verify_response.document, null);
+  
+  client.end();
+});
+
+test('admin operation - authentication required', async (t) => {
+  const client = await create_client();
+  
+  // Try admin operation without authentication
+  const response = await send_message(client, {
+    op: 'admin',
+    data: { admin_action: 'stats' }
+  });
+  
+  t.is(response.ok, false);
+  t.truthy(response.error);
+  t.true(response.error.includes('Authentication required'));
+  
+  client.end();
+});
+
+test('admin operation - invalid collection name', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {
+      admin_action: 'list_documents'
+      // Missing collection parameter
+    }
+  });
+  
+  t.is(response.ok, 0);
+  t.truthy(response.error);
+  t.true(response.error.includes('Collection name is required'));
+  
+  client.end();
+});
+
+test('admin operation - error handling', async (t) => {
+  const client = await create_client();
+  await authenticate_client(client);
+  
+  const response = await send_message(client, {
+    op: 'admin',
+    data: {
+      admin_action: 'get_document',
+      collection: 'test'
+      // Missing document_id parameter
+    }
+  });
+  
+  t.is(response.ok, 0);
+  t.truthy(response.error);
+  t.true(response.error.includes('Collection name and document ID are required'));
+  
+  client.end();
+});