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

package/tests/server/index.test.js

@@ -0,0 +1,651 @@
+import test from 'ava';
+import sinon from 'sinon';
+import net from 'net';
+import { encode as encode_messagepack } from 'msgpackr';
+import { parse_data, check_op_type, create_server } from '../../src/server/index.js';
+import op_types from '../../src/server/lib/op_types.js';
+import { load_settings, get_settings } from '../../src/server/lib/load_settings.js';
+import { reset_auth_state } from '../../src/server/lib/auth_manager.js';
+
+test.beforeEach(() => {
+  // Reset auth state and clean up environment variables
+  reset_auth_state();
+  delete process.env.JOYSTICK_DB_SETTINGS;
+});
+
+test.afterEach(() => {
+  // Clean up environment variables after each test
+  reset_auth_state();
+  delete process.env.JOYSTICK_DB_SETTINGS;
+});
+
+test('setup operation creates authentication and returns password', async (t) => {
+  const { setup } = await import('../../src/server/index.js');
+  
+  let response_data = null;
+  const mock_socket = {
+    write: (data) => {
+      response_data = data;
+    },
+    end: sinon.stub()
+  };
+  
+  await setup(mock_socket, {});
+  
+  // Verify authentication environment variable was created
+  t.true(process.env.JOYSTICK_DB_SETTINGS !== undefined);
+  
+  // Verify response was sent
+  t.truthy(response_data);
+  
+  // Parse the response to check structure
+  const response_string = response_data.toString();
+  t.true(response_string.includes('Authentication setup completed'));
+});
+
+test('setup operation handles already configured authentication', async (t) => {
+  const { setup } = await import('../../src/server/index.js');
+  const { setup_authentication } = await import('../../src/server/lib/auth_manager.js');
+  
+  // Setup authentication first
+  setup_authentication();
+  
+  let response_data = null;
+  const mock_socket = {
+    write: (data) => {
+      response_data = data;
+    },
+    end: sinon.stub()
+  };
+  
+  await setup(mock_socket, {});
+  
+  // Verify error response was sent
+  t.truthy(response_data);
+  
+  const response_string = response_data.toString();
+  t.true(response_string.includes('Authentication already configured'));
+});
+
+test('authentication operation requires password in data', async (t) => {
+  const { authentication } = await import('../../src/server/index.js');
+  
+  let response_data = null;
+  const mock_socket = {
+    id: 'test-socket',
+    write: (data) => {
+      response_data = data;
+    },
+    end: sinon.stub()
+  };
+  
+  await authentication(mock_socket, {});
+  
+  // Verify error response was sent and socket was closed
+  t.truthy(response_data);
+  t.true(mock_socket.end.calledOnce);
+  
+  const response_string = response_data.toString();
+  t.true(response_string.includes('Authentication operation requires password to be set in data'));
+});
+
+test('authentication operation succeeds with correct password', async (t) => {
+  const { authentication } = await import('../../src/server/index.js');
+  const { setup_authentication } = await import('../../src/server/lib/auth_manager.js');
+  
+  // Setup authentication first
+  const password = setup_authentication();
+  
+  let response_data = null;
+  const mock_socket = {
+    id: 'test-socket',
+    remoteAddress: '127.0.0.1',
+    write: (data) => {
+      response_data = data;
+    },
+    end: sinon.stub()
+  };
+  
+  await authentication(mock_socket, { password });
+  
+  // Verify success response was sent and socket was NOT closed
+  t.truthy(response_data);
+  t.false(mock_socket.end.called);
+  
+  const response_string = response_data.toString();
+  t.true(response_string.includes('Authentication successful'));
+  t.true(response_string.includes('1.0.0'));
+});
+
+test('authentication operation fails with incorrect password', async (t) => {
+  const { authentication } = await import('../../src/server/index.js');
+  const { setup_authentication } = await import('../../src/server/lib/auth_manager.js');
+  
+  // Setup authentication first
+  setup_authentication();
+  
+  let response_data = null;
+  const mock_socket = {
+    id: 'test-socket',
+    remoteAddress: '192.168.1.100',
+    write: (data) => {
+      response_data = data;
+    },
+    end: sinon.stub()
+  };
+  
+  await authentication(mock_socket, { password: 'wrong_password' });
+  
+  // Verify error response was sent and socket was closed
+  t.truthy(response_data);
+  t.true(mock_socket.end.calledOnce);
+  
+  const response_string = response_data.toString();
+  t.true(response_string.includes('Authentication failed'));
+});
+
+test('authentication operation handles rate limiting', async (t) => {
+  const { authentication } = await import('../../src/server/index.js');
+  const { setup_authentication } = await import('../../src/server/lib/auth_manager.js');
+  
+  // Setup authentication first
+  setup_authentication();
+  
+  let response_data = null;
+  const mock_socket = {
+    id: 'test-socket',
+    remoteAddress: '192.168.1.100',
+    write: (data) => {
+      response_data = data;
+    },
+    end: sinon.stub()
+  };
+  
+  // Make 5 failed attempts to trigger rate limiting
+  for (let i = 0; i < 5; i++) {
+    await authentication(mock_socket, { password: 'wrong_password' });
+  }
+  
+  // Reset for the rate limited attempt
+  response_data = null;
+  mock_socket.end.resetHistory();
+  
+  // 6th attempt should be rate limited
+  await authentication(mock_socket, { password: 'wrong_password' });
+  
+  // Verify rate limiting error response was sent and socket was closed
+  t.truthy(response_data);
+  t.true(mock_socket.end.calledOnce);
+  
+  const response_string = response_data.toString();
+  t.true(response_string.includes('Too many failed attempts'));
+});
+
+test('parse_data processes valid messagepack with JSON data', (t = {}) => {
+  const json_data = { name: "test", value: 123 };
+  const json_string = JSON.stringify(json_data);
+  const messagepack_data = encode_messagepack(json_string);
+  const raw_data = Buffer.from(messagepack_data);
+  
+  const result = parse_data(raw_data);
+  
+  t.deepEqual(result, json_data);
+});
+
+test('check_op_type returns true for valid operation types', (t = {}) => {
+  op_types.forEach((op_type) => {
+    const result = check_op_type(op_type);
+    t.true(result, `Expected ${op_type} to be valid`);
+  });
+});
+
+test('check_op_type validates setup operation type', (t = {}) => {
+  const result = check_op_type('setup');
+  t.true(result);
+});
+
+test('check_op_type validates authentication operation type', (t = {}) => {
+  const result = check_op_type('authentication');
+  t.true(result);
+});
+
+test('check_op_type returns false for invalid operation types', (t = {}) => {
+  const invalid_op_types = [
+    "invalid_op",
+    "unknown",
+    "select",
+    "create",
+    "drop",
+    "alter",
+    "FIND_ONE",
+    "Authentication",
+    "ping_test"
+  ];
+  
+  invalid_op_types.forEach((op_type) => {
+    const result = check_op_type(op_type);
+    t.false(result, `Expected ${op_type} to be invalid`);
+  });
+});
+
+test('check_op_type throws error when no op_type is provided', (t = {}) => {
+  const error = t.throws(() => {
+    check_op_type();
+  });
+  
+  t.is(error.message, 'Must pass an op type for operation.');
+});
+
+test('check_op_type throws error when empty string is provided', (t = {}) => {
+  const error = t.throws(() => {
+    check_op_type('');
+  });
+  
+  t.is(error.message, 'Must pass an op type for operation.');
+});
+
+test('check_op_type throws error when null is provided', (t = {}) => {
+  const error = t.throws(() => {
+    check_op_type(null);
+  });
+  
+  t.is(error.message, 'Must pass an op type for operation.');
+});
+
+test('check_op_type throws error when undefined is provided', (t = {}) => {
+  const error = t.throws(() => {
+    check_op_type(undefined);
+  });
+  
+  t.is(error.message, 'Must pass an op type for operation.');
+});
+
+test('check_op_type handles non-string input types', (t = {}) => {
+  const non_string_inputs = [
+    123,
+    true,
+    {},
+    [],
+    Symbol('test')
+  ];
+  
+  non_string_inputs.forEach((input) => {
+    const result = check_op_type(input);
+    t.false(result, `Expected ${typeof input} input to be invalid`);
+  });
+});
+
+test('parse_data processes messagepack with array JSON', (t = {}) => {
+  const json_data = [1, 2, 3, "test"];
+  const json_string = JSON.stringify(json_data);
+  const messagepack_data = encode_messagepack(json_string);
+  const raw_data = Buffer.from(messagepack_data);
+  
+  const result = parse_data(raw_data);
+  
+  t.deepEqual(result, json_data);
+});
+
+test('parse_data processes messagepack with primitive JSON values', (t = {}) => {
+  const test_cases = [
+    { input: true, expected: true },
+    { input: false, expected: false },
+    { input: null, expected: null },
+    { input: 42, expected: 42 },
+    { input: "hello", expected: "hello" }
+  ];
+  
+  test_cases.forEach(({ input, expected }) => {
+    const json_string = JSON.stringify(input);
+    const messagepack_data = encode_messagepack(json_string);
+    const raw_data = Buffer.from(messagepack_data);
+    
+    const result = parse_data(raw_data);
+    
+    t.is(result, expected);
+  });
+});
+
+test('parse_data returns null for messagepack with invalid JSON', (t = {}) => {
+  const invalid_json = '{"name": "test", "value":}';
+  const messagepack_data = encode_messagepack(invalid_json);
+  const raw_data = Buffer.from(messagepack_data);
+  
+  const result = parse_data(raw_data);
+  
+  t.is(result, null);
+});
+
+test('parse_data returns null for messagepack with empty string', (t = {}) => {
+  const empty_string = '';
+  const messagepack_data = encode_messagepack(empty_string);
+  const raw_data = Buffer.from(messagepack_data);
+  
+  const result = parse_data(raw_data);
+  
+  t.is(result, null);
+});
+
+test('parse_data processes complex nested JSON objects', (t = {}) => {
+  const complex_data = {
+    user: {
+      id: 1,
+      name: "John Doe",
+      preferences: {
+        theme: "dark",
+        notifications: true
+      }
+    },
+    items: [
+      { id: 1, name: "Item 1" },
+      { id: 2, name: "Item 2" }
+    ]
+  };
+  
+  const json_string = JSON.stringify(complex_data);
+  const messagepack_data = encode_messagepack(json_string);
+  const raw_data = Buffer.from(messagepack_data);
+  
+  const result = parse_data(raw_data);
+  
+  t.deepEqual(result, complex_data);
+});
+
+test('parse_data processes buffer input as raw_data', (t = {}) => {
+  const json_data = { message: "test" };
+  const json_string = JSON.stringify(json_data);
+  const messagepack_data = encode_messagepack(json_string);
+  const raw_data_buffer = Buffer.from(messagepack_data);
+  
+  const result = parse_data(raw_data_buffer);
+  
+  t.deepEqual(result, json_data);
+});
+
+test('parse_data handles messagepack with JSON containing special characters', (t = {}) => {
+  const json_data = {
+    message: "Hello \"world\" with 'quotes' and \n newlines",
+    unicode: "🚀 Unicode test 中文",
+    escaped: "Line 1\nLine 2\tTabbed"
+  };
+  
+  const json_string = JSON.stringify(json_data);
+  const messagepack_data = encode_messagepack(json_string);
+  const raw_data = Buffer.from(messagepack_data);
+  
+  const result = parse_data(raw_data);
+  
+  t.deepEqual(result, json_data);
+});
+
+test('admin operation requires authentication', (t) => {
+  const mock_socket = {
+    id: 'unauthenticated-socket',
+    write: sinon.stub(),
+    end: sinon.stub()
+  };
+  
+  const send_error_stub = sinon.stub();
+  
+  const authenticated_clients = new Set();
+  
+  const check_authentication = (socket) => {
+    return authenticated_clients.has(socket.id);
+  };
+  
+  const is_authenticated = check_authentication(mock_socket);
+  
+  t.false(is_authenticated);
+  
+  if (!is_authenticated) {
+    send_error_stub(mock_socket, { message: 'Authentication required' });
+  }
+  
+  t.true(send_error_stub.calledOnce);
+  t.true(send_error_stub.calledWith(mock_socket, { message: 'Authentication required' }));
+});
+
+test('admin operation returns server information structure', (t) => {
+  const mock_db = {
+    getStats: () => ({ pages: 100, entries: 50 }),
+    getRange: () => [
+      { key: 'users:1' },
+      { key: 'users:2' },
+      { key: 'posts:1' },
+      { key: 'posts:2' },
+      { key: 'posts:3' }
+    ]
+  };
+  
+  const mock_settings = {
+    port: 1983,
+    cluster: true
+  };
+  
+  const collections = new Map();
+  let total_documents = 0;
+  
+  for (const { key } of mock_db.getRange()) {
+    if (typeof key === 'string' && key.includes(':')) {
+      const collection_name = key.split(':')[0];
+      collections.set(collection_name, (collections.get(collection_name) || 0) + 1);
+      total_documents++;
+    }
+  }
+  
+  const admin_info = {
+    server: {
+      uptime: process.uptime(),
+      memory_usage: process.memoryUsage(),
+      node_version: process.version,
+      platform: process.platform,
+      pid: process.pid
+    },
+    database: {
+      total_documents,
+      collections: Object.fromEntries(collections),
+      stats: mock_db.getStats()
+    },
+    authentication: {
+      authenticated_clients: 0
+    },
+    settings: {
+      port: mock_settings.port || 1983,
+      cluster_enabled: !!mock_settings.cluster
+    }
+  };
+  
+  t.is(typeof admin_info.server.uptime, 'number');
+  t.is(typeof admin_info.server.memory_usage, 'object');
+  t.is(typeof admin_info.server.node_version, 'string');
+  t.is(typeof admin_info.server.platform, 'string');
+  t.is(typeof admin_info.server.pid, 'number');
+  t.is(admin_info.database.total_documents, 5);
+  t.deepEqual(admin_info.database.collections, { users: 2, posts: 3 });
+  t.deepEqual(admin_info.database.stats, { pages: 100, entries: 50 });
+  t.is(admin_info.authentication.authenticated_clients, 0);
+  t.is(admin_info.settings.port, 1983);
+  t.true(admin_info.settings.cluster_enabled);
+});
+
+test('admin operation handles database without getStats method', (t) => {
+  const mock_db = {
+    getRange: () => [
+      { key: 'users:1' },
+      { key: 'posts:1' }
+    ]
+  };
+  
+  const stats = mock_db.getStats ? mock_db.getStats() : {};
+  const collections = new Map();
+  let total_documents = 0;
+  
+  for (const { key } of mock_db.getRange()) {
+    if (typeof key === 'string' && key.includes(':')) {
+      const collection_name = key.split(':')[0];
+      collections.set(collection_name, (collections.get(collection_name) || 0) + 1);
+      total_documents++;
+    }
+  }
+  
+  t.deepEqual(stats, {});
+  t.is(total_documents, 2);
+  t.deepEqual(Object.fromEntries(collections), { users: 1, posts: 1 });
+});
+
+test('admin operation counts authenticated clients correctly', (t) => {
+  const authenticated_clients = new Set(['socket1', 'socket2', 'socket3']);
+  
+  const admin_info = {
+    authentication: {
+      authenticated_clients: authenticated_clients.size
+    }
+  };
+  
+  t.is(admin_info.authentication.authenticated_clients, 3);
+});
+
+test('reload operation requires authentication', (t) => {
+  const mock_socket = {
+    id: 'unauthenticated-socket',
+    write: sinon.stub(),
+    end: sinon.stub()
+  };
+  
+  const send_error_stub = sinon.stub();
+  
+  const authenticated_clients = new Set();
+  
+  const check_authentication = (socket) => {
+    return authenticated_clients.has(socket.id);
+  };
+  
+  const is_authenticated = check_authentication(mock_socket);
+  
+  t.false(is_authenticated);
+  
+  if (!is_authenticated) {
+    send_error_stub(mock_socket, { message: 'Authentication required' });
+  }
+  
+  t.true(send_error_stub.calledOnce);
+  t.true(send_error_stub.calledWith(mock_socket, { message: 'Authentication required' }));
+});
+
+test('reload operation detects configuration changes', (t) => {
+  const old_settings = {
+    port: 1983,
+    authentication: { password_hash: 'old-hash' },
+    cluster: false
+  };
+  
+  const new_settings = {
+    port: 2000,
+    authentication: { password_hash: 'new-hash' },
+    cluster: true
+  };
+  
+  const reload_info = {
+    status: 'success',
+    message: 'Configuration reloaded successfully',
+    changes: {
+      port_changed: old_settings.port !== new_settings.port,
+      authentication_changed: old_settings.authentication?.password_hash !== new_settings.authentication?.password_hash,
+      cluster_changed: old_settings.cluster !== new_settings.cluster
+    },
+    timestamp: new Date().toISOString()
+  };
+  
+  t.is(reload_info.status, 'success');
+  t.is(reload_info.message, 'Configuration reloaded successfully');
+  t.true(reload_info.changes.port_changed);
+  t.true(reload_info.changes.authentication_changed);
+  t.true(reload_info.changes.cluster_changed);
+  t.is(typeof reload_info.timestamp, 'string');
+});
+
+test('reload operation detects no changes when settings are identical', (t) => {
+  const old_settings = {
+    port: 1983,
+    authentication: { password_hash: 'same-hash' },
+    cluster: true
+  };
+  
+  const new_settings = {
+    port: 1983,
+    authentication: { password_hash: 'same-hash' },
+    cluster: true
+  };
+  
+  const reload_info = {
+    status: 'success',
+    message: 'Configuration reloaded successfully',
+    changes: {
+      port_changed: old_settings.port !== new_settings.port,
+      authentication_changed: old_settings.authentication?.password_hash !== new_settings.authentication?.password_hash,
+      cluster_changed: old_settings.cluster !== new_settings.cluster
+    },
+    timestamp: new Date().toISOString()
+  };
+  
+  t.is(reload_info.status, 'success');
+  t.false(reload_info.changes.port_changed);
+  t.false(reload_info.changes.authentication_changed);
+  t.false(reload_info.changes.cluster_changed);
+});
+
+test('reload operation handles missing authentication in old settings', (t) => {
+  const old_settings = {
+    port: 1983,
+    cluster: false
+  };
+  
+  const new_settings = {
+    port: 1983,
+    authentication: { password_hash: 'new-hash' },
+    cluster: false
+  };
+  
+  const reload_info = {
+    status: 'success',
+    message: 'Configuration reloaded successfully',
+    changes: {
+      port_changed: old_settings.port !== new_settings.port,
+      authentication_changed: old_settings.authentication?.password_hash !== new_settings.authentication?.password_hash,
+      cluster_changed: old_settings.cluster !== new_settings.cluster
+    },
+    timestamp: new Date().toISOString()
+  };
+  
+  t.false(reload_info.changes.port_changed);
+  t.true(reload_info.changes.authentication_changed);
+  t.false(reload_info.changes.cluster_changed);
+});
+
+test('reload operation handles missing authentication in new settings', (t) => {
+  const old_settings = {
+    port: 1983,
+    authentication: { password_hash: 'old-hash' },
+    cluster: false
+  };
+  
+  const new_settings = {
+    port: 1983,
+    cluster: false
+  };
+  
+  const reload_info = {
+    status: 'success',
+    message: 'Configuration reloaded successfully',
+    changes: {
+      port_changed: old_settings.port !== new_settings.port,
+      authentication_changed: old_settings.authentication?.password_hash !== new_settings.authentication?.password_hash,
+      cluster_changed: old_settings.cluster !== new_settings.cluster
+    },
+    timestamp: new Date().toISOString()
+  };
+  
+  t.false(reload_info.changes.port_changed);
+  t.true(reload_info.changes.authentication_changed);
+  t.false(reload_info.changes.cluster_changed);
+});