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

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

@@ -0,0 +1,294 @@
+import test from 'ava';
+import sinon from 'sinon';
+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, cleanup_database } from '../../../src/server/lib/query_engine.js';
+import { setup_authentication, reset_auth_state } from '../../../src/server/lib/auth_manager.js';
+
+// Dynamic port allocation
+let current_port = 3000;
+const get_next_port = () => {
+  return ++current_port;
+};
+
+let server;
+let port;
+
+test.beforeEach(async () => {
+  // Reset auth state and clean up environment variables
+  reset_auth_state();
+  delete process.env.JOYSTICK_DB_SETTINGS;
+  
+  // Initialize database for testing
+  initialize_database();
+  
+  // 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 database
+  try {
+    await cleanup_database(true); // Remove test database directory
+  } catch (error) {
+    // Ignore cleanup errors
+  }
+  
+  // Clean up environment variables
+  reset_auth_state();
+  delete process.env.JOYSTICK_DB_SETTINGS;
+});
+
+const create_client = () => {
+  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) => {
+            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('integration - setup command creates authentication and returns password', async (t) => {
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    send({ op: 'setup' });
+    const response = await receive();
+    
+    t.true(response.ok === 1 || response.ok === true);
+    t.is(typeof response.password, 'string');
+    t.is(response.password.length, 32);
+    t.true(response.message.includes('Authentication setup completed'));
+    
+    // Verify environment variable was created
+    t.true(process.env.JOYSTICK_DB_SETTINGS !== undefined);
+    
+    const settings_data = JSON.parse(process.env.JOYSTICK_DB_SETTINGS);
+    t.true(typeof settings_data.authentication.password_hash === 'string');
+    t.true(typeof settings_data.authentication.created_at === 'string');
+  } finally {
+    close();
+  }
+});
+
+test('integration - authentication succeeds with correct password', async (t) => {
+  // Setup authentication first
+  const password = setup_authentication();
+  
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    send({ op: 'authentication', data: { password } });
+    const response = await receive();
+    
+    t.is(response.ok, 1);
+    t.is(response.version, '1.0.0');
+    t.is(response.message, 'Authentication successful');
+  } finally {
+    close();
+  }
+});
+
+test('integration - authentication fails with incorrect password', async (t) => {
+  // Setup authentication first
+  setup_authentication();
+  
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    send({ op: 'authentication', data: { password: 'wrong_password' } });
+    const response = await receive();
+    
+    t.true(response.ok === 0 || response.ok === false);
+    t.is(response.error, 'Authentication failed');
+  } finally {
+    close();
+  }
+});
+
+test('integration - database operations require authentication', async (t) => {
+  // Setup authentication first
+  setup_authentication();
+  
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // Try to perform find operation without authentication
+    send({ op: 'find', data: { collection: 'users', filter: {} } });
+    const response = await receive();
+    
+    t.true(response.ok === 0 || response.ok === false);
+    t.is(response.error, 'Authentication required');
+  } finally {
+    close();
+  }
+});
+
+test('integration - database operations work after authentication', 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);
+    t.is(auth_response.version, '1.0.0');
+    
+    // Now try a database operation
+    send({ op: 'ping' });
+    const ping_response = await receive();
+    t.is(ping_response.ok, 1);
+  } finally {
+    close();
+  }
+});
+
+test('integration - admin operation includes authentication stats', 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);
+    t.is(auth_response.version, '1.0.0');
+    
+    // Now try admin operation
+    send({ op: 'admin' });
+    const admin_response = await receive();
+    
+    // This should be the admin response
+    t.true(typeof admin_response.authentication === 'object');
+    t.is(admin_response.authentication.authenticated_clients, 1);
+    t.true(admin_response.authentication.configured);
+    t.is(typeof admin_response.authentication.created_at, 'string');
+    t.true(typeof admin_response.server === 'object');
+    t.true(typeof admin_response.database === 'object');
+  } finally {
+    close();
+  }
+});
+
+test('integration - rate limiting blocks multiple failed attempts', async (t) => {
+  // Setup authentication first
+  setup_authentication();
+  
+  // Make 5 failed attempts
+  for (let i = 0; i < 5; i++) {
+    const { client, send, receive, close } = await create_client();
+    
+    try {
+      send({ op: 'authentication', data: { password: 'wrong_password' } });
+      const response = await receive();
+      
+      t.true(response.ok === 0 || response.ok === false);
+      t.is(response.error, 'Authentication failed');
+    } finally {
+      close();
+    }
+    
+    // Small delay between attempts
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  
+  // 6th attempt should be rate limited
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    send({ op: 'authentication', data: { password: 'wrong_password' } });
+    const response = await receive();
+    
+    t.true(response.ok === 0 || response.ok === false);
+    t.true(response.error.includes('Too many failed attempts'));
+  } finally {
+    close();
+  }
+});
+
+test('integration - setup fails when authentication already configured', async (t) => {
+  // Setup authentication first
+  setup_authentication();
+  
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    // Try to setup again
+    send({ op: 'setup' });
+    const response = await receive();
+    
+    t.true(response.ok === 0 || response.ok === false);
+    t.true(response.error.includes('Authentication already configured'));
+  } finally {
+    close();
+  }
+});
+
+test('integration - protocol versioning returns correct version', async (t) => {
+  // Setup authentication first
+  const password = setup_authentication();
+  
+  const { client, send, receive, close } = await create_client();
+  
+  try {
+    send({ op: 'authentication', data: { password } });
+    const response = await receive();
+    
+    t.is(response.ok, 1);
+    t.is(response.version, '1.0.0');
+    t.is(response.message, 'Authentication successful');
+  } finally {
+    close();
+  }
+});

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

@@ -0,0 +1,268 @@
+import test from 'ava';
+import { initialize_database, cleanup_database } from '../../../src/server/lib/query_engine.js';
+import { initialize_index_database, get_indexes, cleanup_index_database } from '../../../src/server/lib/index_manager.js';
+import { initialize_auto_index_database, cleanup_auto_index_database } from '../../../src/server/lib/auto_index_manager.js';
+import find from '../../../src/server/lib/operations/find.js';
+import find_one from '../../../src/server/lib/operations/find_one.js';
+import insert_one from '../../../src/server/lib/operations/insert_one.js';
+import admin from '../../../src/server/lib/operations/admin.js';
+
+test.beforeEach(async (t) => {
+  initialize_database('./test_data');
+  initialize_index_database();
+  initialize_auto_index_database();
+  
+  const test_documents = [
+    { name: 'Alice', age: 25, department: 'Engineering', salary: 75000 },
+    { name: 'Bob', age: 30, department: 'Marketing', salary: 65000 },
+    { name: 'Charlie', age: 35, department: 'Engineering', salary: 85000 },
+    { name: 'Diana', age: 28, department: 'Sales', salary: 70000 },
+    { name: 'Eve', age: 32, department: 'Engineering', salary: 80000 }
+  ];
+  
+  for (const doc of test_documents) {
+    await insert_one('default', 'employees', doc);
+  }
+});
+
+test.afterEach(async (t) => {
+  cleanup_auto_index_database();
+  cleanup_index_database();
+  await cleanup_database();
+});
+
+test('should record query statistics during find operations', async (t) => {
+  await find('default', 'employees', { name: 'Alice' });
+  await find('default', 'employees', { age: 25 });
+  await find('default', 'employees', { department: 'Engineering' });
+  
+  const stats = await admin('get_query_stats', { collection: 'employees' });
+  
+  t.truthy(stats.name);
+  t.truthy(stats.age);
+  t.truthy(stats.department);
+  t.is(stats.name.query_count, 1);
+  t.is(stats.age.query_count, 1);
+  t.is(stats.department.query_count, 1);
+});
+
+test('should record query statistics during find_one operations', async (t) => {
+  await find_one('default', 'employees', { name: 'Bob' });
+  await find_one('default', 'employees', { age: 30 });
+  
+  const stats = await admin('get_query_stats', { collection: 'employees' });
+  
+  t.truthy(stats.name);
+  t.truthy(stats.age);
+  t.is(stats.name.query_count, 1);
+  t.is(stats.age.query_count, 1);
+});
+
+test('should track execution times for queries', async (t) => {
+  await find('default', 'employees', { name: 'Alice' });
+  await find('default', 'employees', { name: 'Bob' });
+  await find('default', 'employees', { name: 'Charlie' });
+  
+  const stats = await admin('get_query_stats', { collection: 'employees' });
+  
+  t.is(stats.name.query_count, 3);
+  t.true(stats.name.total_time_ms >= 0);
+  t.true(stats.name.avg_time_ms >= 0);
+  t.is(stats.name.avg_time_ms, stats.name.total_time_ms / 3);
+});
+
+test('should get auto index statistics', async (t) => {
+  const stats = await admin('get_auto_index_stats');
+  
+  t.is(typeof stats, 'object');
+  t.is(stats.total_auto_indexes, 0);
+  t.is(typeof stats.collections, 'object');
+});
+
+test('should force index evaluation', async (t) => {
+  for (let i = 0; i < 50; i++) {
+    await find('default', 'employees', { name: `User${i}` });
+  }
+  
+  const result = await admin('evaluate_auto_indexes', { collection: 'employees' });
+  t.is(result.acknowledged, true);
+});
+
+test('should force index evaluation for all collections', async (t) => {
+  await find('default', 'employees', { name: 'Alice' });
+  await find('default', 'products', { category: 'Electronics' });
+  
+  const result = await admin('evaluate_auto_indexes');
+  t.is(result.acknowledged, true);
+});
+
+test('should remove automatic indexes', async (t) => {
+  const result = await admin('remove_auto_indexes', { 
+    collection: 'employees', 
+    field_names: ['name'] 
+  });
+  
+  t.is(result.acknowledged, true);
+  t.is(typeof result.removed_count, 'number');
+});
+
+test('should remove all automatic indexes from collection', async (t) => {
+  const result = await admin('remove_auto_indexes', { collection: 'employees' });
+  
+  t.is(result.acknowledged, true);
+  t.is(typeof result.removed_count, 'number');
+});
+
+test('should handle complex query filters', async (t) => {
+  await find('default', 'employees', { 
+    age: { $gte: 25, $lte: 35 },
+    department: { $in: ['Engineering', 'Marketing'] },
+    salary: { $gt: 70000 }
+  });
+  
+  const stats = await admin('get_query_stats', { collection: 'employees' });
+  
+  t.truthy(stats.age);
+  t.truthy(stats.department);
+  t.truthy(stats.salary);
+  t.is(stats.age.query_count, 1);
+  t.is(stats.department.query_count, 1);
+  t.is(stats.salary.query_count, 1);
+});
+
+test('should track index usage when indexes exist', async (t) => {
+  await admin('create_index', { collection: 'employees', field: 'name' });
+  
+  await find('default', 'employees', { name: 'Alice' });
+  await find('default', 'employees', { name: 'Bob' });
+  
+  const stats = await admin('get_query_stats', { collection: 'employees' });
+  
+  t.is(stats.name.query_count, 2);
+  t.is(stats.name.used_index_count, 2);
+});
+
+test('should differentiate between indexed and non-indexed queries', async (t) => {
+  await admin('create_index', { collection: 'employees', field: 'name' });
+  
+  await find('default', 'employees', { name: 'Alice' });
+  await find('default', 'employees', { age: 25 });
+  
+  const stats = await admin('get_query_stats', { collection: 'employees' });
+  
+  t.is(stats.name.used_index_count, 1);
+  t.is(stats.age.used_index_count, 0);
+});
+
+test('should handle queries with projection and sorting', async (t) => {
+  await find('default', 'employees', { department: 'Engineering' }, {
+    projection: { name: 1, salary: 1 },
+    sort: { salary: -1 },
+    limit: 2
+  });
+  
+  const stats = await admin('get_query_stats', { collection: 'employees' });
+  
+  t.truthy(stats.department);
+  t.is(stats.department.query_count, 1);
+});
+
+test('should handle find_one with projection', async (t) => {
+  await find_one('default', 'employees', { name: 'Alice' }, {
+    projection: { age: 1, department: 1 }
+  });
+  
+  const stats = await admin('get_query_stats', { collection: 'employees' });
+  
+  t.truthy(stats.name);
+  t.is(stats.name.query_count, 1);
+});
+
+test('should accumulate statistics across multiple operations', async (t) => {
+  await find('default', 'employees', { name: 'Alice' });
+  await find_one('default', 'employees', { name: 'Bob' });
+  await find('default', 'employees', { name: 'Charlie' });
+  
+  const stats = await admin('get_query_stats', { collection: 'employees' });
+  
+  t.is(stats.name.query_count, 3);
+  t.true(stats.name.total_time_ms > 0);
+});
+
+test('should handle empty result sets', async (t) => {
+  await find('default', 'employees', { name: 'NonExistent' });
+  await find_one('default', 'employees', { age: 999 });
+  
+  const stats = await admin('get_query_stats', { collection: 'employees' });
+  
+  t.truthy(stats.name);
+  t.truthy(stats.age);
+  t.is(stats.name.query_count, 1);
+  t.is(stats.age.query_count, 1);
+});
+
+test('should handle queries on non-existent collections', async (t) => {
+  await find('default', 'non_existent_collection', { field: 'value' });
+  
+  const stats = await admin('get_query_stats', { collection: 'non_existent_collection' });
+  
+  t.truthy(stats.field);
+  t.is(stats.field.query_count, 1);
+});
+
+test('should track slow queries correctly', async (t) => {
+  for (let i = 0; i < 10; i++) {
+    await find('default', 'employees', { department: 'Engineering' });
+  }
+  
+  const stats = await admin('get_query_stats', { collection: 'employees' });
+  
+  t.is(stats.department.query_count, 10);
+  t.true(stats.department.slow_query_count >= 0);
+});
+
+test('should get statistics for specific collection only', async (t) => {
+  await find('default', 'employees', { name: 'Alice' });
+  await find('default', 'products', { category: 'Electronics' });
+  
+  const employee_stats = await admin('get_query_stats', { collection: 'employees' });
+  const product_stats = await admin('get_query_stats', { collection: 'products' });
+  
+  t.truthy(employee_stats.name);
+  t.falsy(employee_stats.category);
+  t.truthy(product_stats.category);
+  t.falsy(product_stats.name);
+});
+
+test('should get statistics for all collections', async (t) => {
+  await find('default', 'employees', { name: 'Alice' });
+  await find('default', 'products', { category: 'Electronics' });
+  
+  const all_stats = await admin('get_query_stats');
+  
+  t.truthy(all_stats.employees);
+  t.truthy(all_stats.products);
+  t.truthy(all_stats.employees.name);
+  t.truthy(all_stats.products.category);
+});
+
+test('should handle admin operations without errors', async (t) => {
+  await t.notThrowsAsync(async () => {
+    await admin('get_auto_index_stats');
+    await admin('get_query_stats');
+    await admin('evaluate_auto_indexes');
+    await admin('remove_auto_indexes', { collection: 'test' });
+  });
+});
+
+test('should maintain statistics persistence across operations', async (t) => {
+  await find('default', 'employees', { name: 'Alice' });
+  
+  let stats = await admin('get_query_stats', { collection: 'employees' });
+  t.is(stats.name.query_count, 1);
+  
+  await find('default', 'employees', { name: 'Bob' });
+  
+  stats = await admin('get_query_stats', { collection: 'employees' });
+  t.is(stats.name.query_count, 2);
+});