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

package/tests/server/lib/http_server.test.js

@@ -0,0 +1,389 @@
+import test from 'ava';
+import http from 'http';
+import { URL } from 'url';
+import fs from 'fs';
+import { 
+  start_http_server, 
+  stop_http_server, 
+  get_setup_info, 
+  is_setup_required 
+} from '../../../src/server/lib/http_server.js';
+import { reset_auth_state, setup_authentication } from '../../../src/server/lib/auth_manager.js';
+
+// NOTE: Simple port allocation using a fixed range to avoid conflicts.
+let current_port = 9000;
+const get_next_port = () => {
+  return ++current_port;
+};
+
+const make_http_request = (url, method = 'GET', data = null) => {
+  return new Promise((resolve, reject) => {
+    const parsed_url = new URL(url);
+    const options = {
+      hostname: parsed_url.hostname,
+      port: parsed_url.port,
+      path: parsed_url.pathname + parsed_url.search,
+      method: method,
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      }
+    };
+
+    const req = http.request(options, (res) => {
+      let body = '';
+      res.on('data', (chunk) => {
+        body += chunk;
+      });
+      res.on('end', () => {
+        resolve({
+          status_code: res.statusCode,
+          headers: res.headers,
+          body: body
+        });
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(error);
+    });
+
+    if (data && method === 'POST') {
+      req.write(data);
+    }
+
+    req.end();
+  });
+};
+
+test.beforeEach(() => {
+  reset_auth_state();
+});
+
+test.afterEach(async () => {
+  // NOTE: Clean up HTTP server.
+  await stop_http_server();
+  
+  reset_auth_state();
+});
+
+test('is_setup_required returns true when authentication not configured', (t) => {
+  const setup_required = is_setup_required();
+  t.true(setup_required);
+});
+
+test('is_setup_required returns false when authentication is configured', (t) => {
+  setup_authentication();
+  const setup_required = is_setup_required();
+  t.false(setup_required);
+});
+
+test('start_http_server starts server even when setup not required (for recovery)', async (t) => {
+  setup_authentication();
+  const port = get_next_port();
+  const server = await start_http_server(port);
+  t.truthy(server);
+  
+  const setup_info = get_setup_info();
+  t.false(setup_info.setup_required);
+  t.is(setup_info.setup_token, null);
+  t.false(setup_info.setup_completed);
+  t.true(setup_info.http_server_running);
+});
+
+test('start_http_server starts server when setup is required', async (t) => {
+  const port = get_next_port();
+  const server = await start_http_server(port);
+  t.truthy(server);
+  
+  const setup_info = get_setup_info();
+  t.true(setup_info.setup_required);
+  t.truthy(setup_info.setup_token);
+  t.false(setup_info.setup_completed);
+  t.true(setup_info.http_server_running);
+});
+
+test('HTTP server serves 404 for unknown paths', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  
+  const response = await make_http_request(`http://localhost:${port}/unknown`);
+  t.is(response.status_code, 404);
+  t.true(response.body.includes('404 Not Found'));
+});
+
+test('setup endpoint requires valid token', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  
+  const response = await make_http_request(`http://localhost:${port}/setup?token=invalid`);
+  t.is(response.status_code, 403);
+  t.true(response.body.includes('Invalid or missing setup token'));
+});
+
+test('setup endpoint serves form with valid token', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  const setup_info = get_setup_info();
+  
+  const response = await make_http_request(`http://localhost:${port}/setup?token=${setup_info.setup_token}`);
+  t.is(response.status_code, 200);
+  t.true(response.body.includes('JoystickDB Setup'));
+  t.true(response.body.includes('Setup JoystickDB'));
+  t.true(response.body.includes('form method="POST"'));
+});
+
+test('setup endpoint handles POST request with valid token', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  const setup_info = get_setup_info();
+  
+  const response = await make_http_request(
+    `http://localhost:${port}/setup?token=${setup_info.setup_token}`, 
+    'POST', 
+    ''
+  );
+  
+  t.is(response.status_code, 200);
+  t.true(response.body.includes('Setup Completed Successfully'));
+  t.true(response.body.includes('Generated Password'));
+  t.true(response.body.includes('JOYSTICKDB_PASSWORD='));
+  
+  // NOTE: Verify authentication was configured in environment variable.
+  t.truthy(process.env.JOYSTICK_DB_SETTINGS);
+});
+
+test('setup endpoint rejects POST with invalid token', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  
+  const response = await make_http_request(
+    `http://localhost:${port}/setup?token=invalid`, 
+    'POST', 
+    ''
+  );
+  
+  t.is(response.status_code, 403);
+  t.true(response.body.includes('Invalid or missing setup token'));
+});
+
+test('setup endpoint rejects setup when already configured', async (t) => {
+  setup_authentication();
+  const port = get_next_port();
+  const server = await start_http_server(port);
+  
+  // NOTE: Server should start even when authentication is configured (for recovery operations).
+  t.truthy(server);
+  
+  // NOTE: Verify that is_setup_required returns false.
+  t.false(is_setup_required());
+  
+  // NOTE: But setup endpoint should reject setup attempts.
+  const response = await make_http_request(`http://localhost:${port}/setup?token=any`);
+  t.is(response.status_code, 400);
+  t.true(response.body.includes('Setup has already been completed'));
+});
+
+test('setup endpoint handles missing token parameter', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  
+  const response = await make_http_request(`http://localhost:${port}/setup`);
+  t.is(response.status_code, 403);
+  t.true(response.body.includes('Invalid or missing setup token'));
+});
+
+test('setup endpoint handles unsupported HTTP methods', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  const setup_info = get_setup_info();
+  
+  const response = await make_http_request(
+    `http://localhost:${port}/setup?token=${setup_info.setup_token}`, 
+    'PUT', 
+    ''
+  );
+  
+  t.is(response.status_code, 405);
+  t.true(response.body.includes('Method not allowed'));
+});
+
+test('rate limiting prevents excessive setup attempts', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  
+  // NOTE: Make 11 failed attempts (exceeds limit of 10).
+  for (let i = 0; i < 11; i++) {
+    await make_http_request(`http://localhost:${port}/setup?token=invalid`);
+  }
+  
+  const response = await make_http_request(`http://localhost:${port}/setup?token=invalid`);
+  t.is(response.status_code, 429);
+  t.true(response.body.includes('Too many setup attempts'));
+});
+
+test('stop_http_server stops running server', async (t) => {
+  const port = get_next_port();
+  const server = await start_http_server(port);
+  t.truthy(server);
+  
+  await stop_http_server();
+  
+  const setup_info = get_setup_info();
+  t.false(setup_info.http_server_running);
+  
+  // NOTE: Verify server is no longer accessible.
+  try {
+    await make_http_request(`http://localhost:${port}/setup?token=any`);
+    t.fail('Server should not be accessible after stop');
+  } catch (error) {
+    t.true(error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND');
+  }
+});
+
+test('stop_http_server handles no running server gracefully', async (t) => {
+  await t.notThrowsAsync(async () => {
+    await stop_http_server();
+  });
+});
+
+test('get_setup_info returns correct information', async (t) => {
+  let setup_info = get_setup_info();
+  t.true(setup_info.setup_required);
+  t.is(setup_info.setup_token, null);
+  t.false(setup_info.setup_completed);
+  t.false(setup_info.http_server_running);
+  
+  const port = get_next_port();
+  await start_http_server(port);
+  
+  setup_info = get_setup_info();
+  t.true(setup_info.setup_required);
+  t.truthy(setup_info.setup_token);
+  t.false(setup_info.setup_completed);
+  t.true(setup_info.http_server_running);
+});
+
+test('setup completion updates setup info', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  const setup_info = get_setup_info();
+  
+  await make_http_request(
+    `http://localhost:${port}/setup?token=${setup_info.setup_token}`, 
+    'POST', 
+    ''
+  );
+  
+  const updated_info = get_setup_info();
+  t.false(updated_info.setup_required);
+  t.is(updated_info.setup_token, null);
+  t.true(updated_info.setup_completed);
+});
+
+test('HTTP server handles port conflicts gracefully', async (t) => {
+  const test_port = get_next_port();
+  
+  // NOTE: Start first server.
+  const server1 = await start_http_server(test_port);
+  t.truthy(server1);
+  
+  // NOTE: Wait a moment to ensure the first server is fully established.
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // NOTE: Try to start second server on same port - this should fail.
+  let error_caught = false;
+  try {
+    await start_http_server(test_port);
+    t.fail('Should throw error for port conflict');
+  } catch (error) {
+    error_caught = true;
+    t.true(error.message.includes('EADDRINUSE') || error.code === 'EADDRINUSE');
+  }
+  
+  // NOTE: Ensure we caught the expected error.
+  t.true(error_caught, 'Expected EADDRINUSE error was not caught');
+  
+  // NOTE: Verify first server is still running and accessible.
+  const setup_info = get_setup_info();
+  t.true(setup_info.http_server_running);
+  
+  // NOTE: Clean up the first server.
+  await stop_http_server();
+});
+
+test('setup form includes security information', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  const setup_info = get_setup_info();
+  
+  const response = await make_http_request(`http://localhost:${port}/setup?token=${setup_info.setup_token}`);
+  
+  t.true(response.body.includes('What happens during setup?'));
+  t.true(response.body.includes('secure random password'));
+  t.true(response.body.includes('settings.db.json'));
+  t.true(response.body.includes('After setup:'));
+  t.true(response.body.includes('JOYSTICKDB_PASSWORD='));
+  t.true(response.body.includes('TCP port 1983'));
+});
+
+test('success page includes complete instructions', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  const setup_info = get_setup_info();
+  
+  const response = await make_http_request(
+    `http://localhost:${port}/setup?token=${setup_info.setup_token}`, 
+    'POST', 
+    ''
+  );
+  
+  t.true(response.body.includes('Setup Completed Successfully'));
+  t.true(response.body.includes('Save this password immediately'));
+  t.true(response.body.includes('Generated Password:'));
+  t.true(response.body.includes('Next Steps:'));
+  t.true(response.body.includes('Set environment variable'));
+  t.true(response.body.includes('Restart your application'));
+  t.true(response.body.includes('Connect using the TCP client'));
+  t.true(response.body.includes('Client Connection Example:'));
+  t.true(response.body.includes('import joystickdb'));
+  t.true(response.body.includes('Configuration Details:'));
+});
+
+test('error pages include troubleshooting information', async (t) => {
+  const port = get_next_port();
+  await start_http_server(port);
+  
+  const response = await make_http_request(`http://localhost:${port}/setup?token=invalid`);
+  
+  t.true(response.body.includes('Setup Error'));
+  t.true(response.body.includes('Troubleshooting:'));
+  t.true(response.body.includes('authentication'));
+  t.true(response.body.includes('settings.db.json'));
+  t.true(response.body.includes('write permissions'));
+  t.true(response.body.includes('server logs'));
+  t.true(response.body.includes('Go Back'));
+});
+
+test('HTTP server uses configured port from settings', async (t) => {
+  const custom_port = get_next_port();
+  const server = await start_http_server(custom_port);
+  t.truthy(server);
+  
+  const setup_info = get_setup_info();
+  const response = await make_http_request(`http://localhost:${custom_port}/setup?token=${setup_info.setup_token}`);
+  t.is(response.status_code, 200);
+});
+
+test('setup token is unique across server restarts', async (t) => {
+  const port1 = get_next_port();
+  await start_http_server(port1);
+  const first_token = get_setup_info().setup_token;
+  
+  await stop_http_server();
+  
+  const port2 = get_next_port();
+  await start_http_server(port2);
+  const second_token = get_setup_info().setup_token;
+  
+  t.not(first_token, second_token);
+});

package/tests/server/lib/index_manager.test.js

@@ -0,0 +1,301 @@
+import test from 'ava';
+import { initialize_database, get_database, cleanup_database } from '../../../src/server/lib/query_engine.js';
+import {
+  initialize_index_database,
+  get_index_database,
+  create_index,
+  drop_index,
+  get_indexes,
+  update_indexes_on_insert,
+  update_indexes_on_update,
+  update_indexes_on_delete,
+  find_documents_by_index,
+  can_use_index
+} from '../../../src/server/lib/index_manager.js';
+import insert_one from '../../../src/server/lib/operations/insert_one.js';
+
+test.beforeEach(() => {
+  initialize_database('./test_data');
+  initialize_index_database();
+  
+  const main_db = get_database();
+  const index_db = get_index_database();
+  
+  // Clear both databases
+  main_db.clearSync();
+  index_db.clearSync();
+});
+
+test.afterEach(async () => {
+  try {
+    await cleanup_database();
+  } catch (error) {
+    // Ignore cleanup errors in tests
+  }
+});
+
+test('create_index - should create an index successfully', async (t) => {
+  const result = await create_index('default', 'users', 'email');
+  
+  t.is(result.acknowledged, true);
+  
+  const indexes = get_indexes('default', 'users');
+  t.is(indexes.length, 1);
+  t.is(indexes[0].field, 'email');
+  t.is(indexes[0].collection, 'users');
+});
+
+test('create_index - should create a unique index', async (t) => {
+  const result = await create_index('default', 'users', 'email', { unique: true });
+  
+  t.is(result.acknowledged, true);
+  
+  const indexes = get_indexes('default', 'users');
+  t.is(indexes.length, 1);
+  t.is(indexes[0].unique, true);
+});
+
+test('create_index - should create a sparse index', async (t) => {
+  const result = await create_index('default', 'users', 'email', { sparse: true });
+  
+  t.is(result.acknowledged, true);
+  
+  const indexes = get_indexes('default', 'users');
+  t.is(indexes.length, 1);
+  t.is(indexes[0].sparse, true);
+});
+
+test('create_index - should throw if index already exists', async (t) => {
+  await create_index('default', 'users', 'email');
+  
+  await t.throwsAsync(
+    () => create_index('default', 'users', 'email'),
+    { message: 'Index on default.users.email already exists' }
+  );
+});
+
+test('create_index - should throw if collection name is missing', async (t) => {
+  await t.throwsAsync(
+    () => create_index('default', '', 'email'),
+    { message: 'Collection name is required' }
+  );
+});
+
+test('create_index - should throw if field name is missing', async (t) => {
+  await t.throwsAsync(
+    () => create_index('default', 'users', ''),
+    { message: 'Field name is required' }
+  );
+});
+
+test('drop_index - should drop an index successfully', async (t) => {
+  await create_index('default', 'users', 'email');
+  
+  const result = await drop_index('default', 'users', 'email');
+  t.is(result.acknowledged, true);
+  
+  const indexes = get_indexes('default', 'users');
+  t.is(indexes.length, 0);
+});
+
+test('drop_index - should throw if index does not exist', async (t) => {
+  await t.throwsAsync(
+    () => drop_index('default', 'users', 'email'),
+    { message: 'Index on default.users.email does not exist' }
+  );
+});
+
+test('get_indexes - should return empty array for collection with no indexes', (t) => {
+  const indexes = get_indexes('default', 'users');
+  t.is(indexes.length, 0);
+});
+
+test('get_indexes - should return all indexes for a collection', async (t) => {
+  await create_index('default', 'users', 'email');
+  await create_index('default', 'users', 'name');
+  
+  const indexes = get_indexes('default', 'users');
+  t.is(indexes.length, 2);
+  
+  const fields = indexes.map(index => index.field).sort();
+  t.deepEqual(fields, ['email', 'name']);
+});
+
+test('update_indexes_on_insert - should update indexes when document is inserted', async (t) => {
+  await create_index('default', 'users', 'email');
+  
+  const document = { _id: 'test_id', email: 'test@example.com', name: 'Test User' };
+  await update_indexes_on_insert('default', 'users', document);
+  
+  const document_ids = find_documents_by_index('default', 'users', 'email', 'eq', 'test@example.com');
+  t.truthy(document_ids);
+  t.is(document_ids.length, 1);
+  t.is(document_ids[0], 'test_id');
+});
+
+test('update_indexes_on_insert - should handle null values with sparse index', async (t) => {
+  await create_index('default', 'users', 'email', { sparse: true });
+  
+  const document = { _id: 'test_id', name: 'Test User' };
+  await update_indexes_on_insert('default', 'users', document);
+  
+  const document_ids = find_documents_by_index('default', 'users', 'email', 'eq', null);
+  t.is(document_ids, null);
+});
+
+test('update_indexes_on_insert - should handle null values with non-sparse index', async (t) => {
+  await create_index('default', 'users', 'email');
+  
+  const document = { _id: 'test_id', name: 'Test User' };
+  await update_indexes_on_insert('default', 'users', document);
+  
+  const document_ids = find_documents_by_index('default', 'users', 'email', 'eq', null);
+  t.truthy(document_ids);
+  t.is(document_ids.length, 1);
+  t.is(document_ids[0], 'test_id');
+});
+
+test('update_indexes_on_insert - should enforce unique constraint', async (t) => {
+  await create_index('default', 'users', 'email', { unique: true });
+  
+  const document1 = { _id: 'test_id_1', email: 'test@example.com' };
+  await update_indexes_on_insert('default', 'users', document1);
+  
+  const document2 = { _id: 'test_id_2', email: 'test@example.com' };
+  await t.throwsAsync(
+    () => update_indexes_on_insert('default', 'users', document2),
+    { message: 'Duplicate value for unique index on default.users.email: test@example.com' }
+  );
+});
+
+test('update_indexes_on_update - should update indexes when document is updated', async (t) => {
+  await create_index('default', 'users', 'email');
+  
+  const old_document = { _id: 'test_id', email: 'old@example.com' };
+  const new_document = { _id: 'test_id', email: 'new@example.com' };
+  
+  await update_indexes_on_insert('default', 'users', old_document);
+  await update_indexes_on_update('default', 'users', old_document, new_document);
+  
+  const old_ids = find_documents_by_index('default', 'users', 'email', 'eq', 'old@example.com');
+  t.is(old_ids, null);
+  
+  const new_ids = find_documents_by_index('default', 'users', 'email', 'eq', 'new@example.com');
+  t.truthy(new_ids);
+  t.is(new_ids.length, 1);
+  t.is(new_ids[0], 'test_id');
+});
+
+test('update_indexes_on_delete - should update indexes when document is deleted', async (t) => {
+  await create_index('default', 'users', 'email');
+  
+  const document = { _id: 'test_id', email: 'test@example.com' };
+  await update_indexes_on_insert('default', 'users', document);
+  await update_indexes_on_delete('default', 'users', document);
+  
+  const document_ids = find_documents_by_index('default', 'users', 'email', 'eq', 'test@example.com');
+  t.is(document_ids, null);
+});
+
+test('find_documents_by_index - should find documents by exact match', async (t) => {
+  await create_index('default', 'users', 'email');
+  
+  const document = { _id: 'test_id', email: 'test@example.com' };
+  await update_indexes_on_insert('default', 'users', document);
+  
+  const document_ids = find_documents_by_index('default', 'users', 'email', '$eq', 'test@example.com');
+  t.truthy(document_ids);
+  t.is(document_ids.length, 1);
+  t.is(document_ids[0], 'test_id');
+});
+
+test('find_documents_by_index - should find documents by $in operator', async (t) => {
+  await create_index('default', 'users', 'status');
+  
+  const doc1 = { _id: 'id1', status: 'active' };
+  const doc2 = { _id: 'id2', status: 'inactive' };
+  const doc3 = { _id: 'id3', status: 'pending' };
+  
+  await update_indexes_on_insert('default', 'users', doc1);
+  await update_indexes_on_insert('default', 'users', doc2);
+  await update_indexes_on_insert('default', 'users', doc3);
+  
+  const document_ids = find_documents_by_index('default', 'users', 'status', '$in', ['active', 'pending']);
+  t.truthy(document_ids);
+  t.is(document_ids.length, 2);
+  t.true(document_ids.includes('id1'));
+  t.true(document_ids.includes('id3'));
+});
+
+test('find_documents_by_index - should find documents by $exists operator', async (t) => {
+  await create_index('default', 'users', 'email');
+  
+  const doc1 = { _id: 'id1', email: 'test@example.com' };
+  const doc2 = { _id: 'id2', name: 'Test User' };
+  
+  await update_indexes_on_insert('default', 'users', doc1);
+  await update_indexes_on_insert('default', 'users', doc2);
+  
+  const with_email = find_documents_by_index('default', 'users', 'email', '$exists', true);
+  t.truthy(with_email);
+  t.is(with_email.length, 1);
+  t.is(with_email[0], 'id1');
+  
+  const without_email = find_documents_by_index('default', 'users', 'email', '$exists', false);
+  t.truthy(without_email);
+  t.is(without_email.length, 1);
+  t.is(without_email[0], 'id2');
+});
+
+test('can_use_index - should detect when index can be used', async (t) => {
+  await create_index('default', 'users', 'email');
+  
+  const filter1 = { email: 'test@example.com' };
+  const result1 = can_use_index('default', 'users', filter1);
+  t.truthy(result1);
+  t.is(result1.field, 'email');
+  t.deepEqual(result1.operators, ['eq']);
+  
+  const filter2 = { email: { $eq: 'test@example.com' } };
+  const result2 = can_use_index('default', 'users', filter2);
+  t.truthy(result2);
+  t.is(result2.field, 'email');
+  t.deepEqual(result2.operators, ['$eq']);
+  
+  const filter3 = { email: { $in: ['test1@example.com', 'test2@example.com'] } };
+  const result3 = can_use_index('default', 'users', filter3);
+  t.truthy(result3);
+  t.is(result3.field, 'email');
+  t.deepEqual(result3.operators, ['$in']);
+});
+
+test('can_use_index - should return null when no index can be used', async (t) => {
+  await create_index('default', 'users', 'email');
+  
+  const filter1 = { name: 'Test User' };
+  const result1 = can_use_index('default', 'users', filter1);
+  t.is(result1, null);
+  
+  const filter2 = { email: { $regex: 'test.*' } };
+  const result2 = can_use_index('default', 'users', filter2);
+  t.is(result2, null);
+});
+
+test('nested field indexing - should handle nested object fields', async (t) => {
+  await create_index('default', 'users', 'profile.email');
+  
+  const document = { 
+    _id: 'test_id', 
+    profile: { 
+      email: 'test@example.com',
+      name: 'Test User'
+    }
+  };
+  
+  await update_indexes_on_insert('default', 'users', document);
+  
+  const document_ids = find_documents_by_index('default', 'users', 'profile.email', 'eq', 'test@example.com');
+  t.truthy(document_ids);
+  t.is(document_ids.length, 1);
+  t.is(document_ids[0], 'test_id');
+});