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

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

@@ -0,0 +1,107 @@
+import test from 'ava';
+import { load_settings, get_settings, reload_settings, clear_settings_cache } from '../../../src/server/lib/load_settings.js';
+
+const valid_settings = {
+  authentication: {
+    password_hash: '$2b$10$example.hash.here'
+  },
+  database: {
+    max_connections: 100
+  }
+};
+
+test.beforeEach(() => {
+  // NOTE: Clean up any cached settings and environment variables before each test.
+  clear_settings_cache();
+  delete process.env.JOYSTICK_DB_SETTINGS;
+});
+
+test.afterEach(() => {
+  // NOTE: Clean up environment variables after each test.
+  delete process.env.JOYSTICK_DB_SETTINGS;
+});
+
+test('load_settings loads valid JSON from environment variable', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify(valid_settings);
+  
+  const settings = load_settings();
+  
+  t.deepEqual(settings, valid_settings);
+  t.is(settings.authentication.password_hash, '$2b$10$example.hash.here');
+});
+
+test('load_settings throws error for missing environment variable', (t) => {
+  const error = t.throws(() => {
+    load_settings();
+  });
+  
+  t.true(error.message.includes('JOYSTICK_DB_SETTINGS environment variable is not set'));
+});
+
+test('load_settings throws error for invalid JSON in environment variable', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = '{ invalid json }';
+  
+  const error = t.throws(() => {
+    load_settings();
+  });
+  
+  t.true(error.message.includes('Invalid JSON in JOYSTICK_DB_SETTINGS environment variable'));
+});
+
+test('get_settings returns cached settings', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify(valid_settings);
+  
+  load_settings();
+  const settings = get_settings();
+  
+  t.deepEqual(settings, valid_settings);
+});
+
+test('get_settings throws error when settings not loaded', (t) => {
+  const error = t.throws(() => {
+    get_settings();
+  });
+  
+  t.true(error.message.includes('Settings not loaded'));
+});
+
+test('reload_settings reloads from environment variable', (t) => {
+  const initial_settings = { test: 'initial' };
+  const updated_settings = { test: 'updated' };
+  
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify(initial_settings);
+  load_settings();
+  
+  t.deepEqual(get_settings(), initial_settings);
+  
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify(updated_settings);
+  const reloaded = reload_settings();
+  
+  t.deepEqual(reloaded, updated_settings);
+  t.deepEqual(get_settings(), updated_settings);
+});
+
+test('load_settings works with complex nested settings', (t) => {
+  const complex_settings = {
+    authentication: {
+      password_hash: '$2b$10$example.hash.here',
+      created_at: '2023-01-01T00:00:00.000Z',
+      failed_attempts: {},
+      rate_limits: {}
+    },
+    database: {
+      max_connections: 100,
+      timeout: 5000
+    },
+    cluster: {
+      enabled: true,
+      nodes: ['node1', 'node2']
+    }
+  };
+  
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify(complex_settings);
+  
+  const settings = load_settings();
+  
+  t.deepEqual(settings, complex_settings);
+});

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

@@ -0,0 +1,243 @@
+import test from 'ava';
+import { load_settings, get_settings, get_port_configuration, clear_settings_cache } from '../../../src/server/lib/load_settings.js';
+
+test.beforeEach(() => {
+  // Clean up environment variables before each test
+  delete process.env.JOYSTICK_DB_SETTINGS;
+  clear_settings_cache();
+});
+
+test.afterEach(() => {
+  // Clean up environment variables after each test
+  delete process.env.JOYSTICK_DB_SETTINGS;
+  clear_settings_cache();
+});
+
+test('get_port_configuration returns default ports when no settings', (t) => {
+  const { tcp_port, http_port } = get_port_configuration();
+  
+  t.is(tcp_port, 1983);
+  t.is(http_port, 1984);
+});
+
+test('get_port_configuration uses configured port from settings', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    port: 3000,
+    authentication: {}
+  });
+  
+  const { tcp_port, http_port } = get_port_configuration();
+  
+  t.is(tcp_port, 3000);
+  t.is(http_port, 3001);
+});
+
+test('load_settings validates port configuration - valid port', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    port: 2000,
+    authentication: {}
+  });
+  
+  t.notThrows(() => {
+    load_settings();
+  });
+  
+  const settings = get_settings();
+  t.is(settings.port, 2000);
+});
+
+test('load_settings validates port configuration - port too low', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    port: 1023,
+    authentication: {}
+  });
+  
+  const error = t.throws(() => {
+    load_settings();
+  });
+  
+  t.true(error.message.includes('Port must be between 1024 and 65534'));
+});
+
+test('load_settings validates port configuration - port too high', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    port: 70000,
+    authentication: {}
+  });
+  
+  const error = t.throws(() => {
+    load_settings();
+  });
+  
+  t.true(error.message.includes('HTTP port (70001) would exceed maximum port number'));
+});
+
+test('load_settings validates port configuration - HTTP port overflow', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    port: 65535,
+    authentication: {}
+  });
+  
+  const error = t.throws(() => {
+    load_settings();
+  });
+  
+  t.true(error.message.includes('HTTP port (65536) would exceed maximum port number'));
+});
+
+test('load_settings validates port configuration - non-integer port', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    port: 1983.5,
+    authentication: {}
+  });
+  
+  const error = t.throws(() => {
+    load_settings();
+  });
+  
+  t.true(error.message.includes('Port must be an integer'));
+});
+
+test('load_settings validates port configuration - string port', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    port: "1983",
+    authentication: {}
+  });
+  
+  const error = t.throws(() => {
+    load_settings();
+  });
+  
+  t.true(error.message.includes('Port must be an integer'));
+});
+
+test('load_settings allows valid port range - minimum valid port', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    port: 1024,
+    authentication: {}
+  });
+  
+  t.notThrows(() => {
+    load_settings();
+  });
+  
+  const settings = get_settings();
+  t.is(settings.port, 1024);
+});
+
+test('load_settings allows valid port range - maximum valid port', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    port: 65534,
+    authentication: {}
+  });
+  
+  t.notThrows(() => {
+    load_settings();
+  });
+  
+  const settings = get_settings();
+  t.is(settings.port, 65534);
+});
+
+test('load_settings allows settings without port configuration', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    authentication: {},
+    s3: { bucket: 'test' }
+  });
+  
+  t.notThrows(() => {
+    load_settings();
+  });
+  
+  const settings = get_settings();
+  t.is(settings.port, undefined);
+});
+
+test('get_port_configuration handles mixed settings scenarios', (t) => {
+  // Test with settings that don't include port
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    authentication: {},
+    s3: { bucket: 'test' }
+  });
+  
+  const { tcp_port, http_port } = get_port_configuration();
+  
+  t.is(tcp_port, 1983);
+  t.is(http_port, 1984);
+});
+
+test('port configuration works with complex settings', (t) => {
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    port: 5000,
+    authentication: {
+      password_hash: 'test-hash'
+    },
+    s3: {
+      bucket: 'test-bucket',
+      region: 'us-east-1'
+    },
+    replication: {
+      enabled: true,
+      nodes: ['node1', 'node2']
+    }
+  });
+  
+  t.notThrows(() => {
+    load_settings();
+  });
+  
+  const settings = get_settings();
+  t.is(settings.port, 5000);
+  
+  const { tcp_port, http_port } = get_port_configuration();
+  t.is(tcp_port, 5000);
+  t.is(http_port, 5001);
+});
+
+test('port validation error messages are descriptive', (t) => {
+  // Test port too low
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({ port: 500 });
+  
+  let error = t.throws(() => load_settings());
+  t.true(error.message.includes('Port must be between 1024 and 65534'));
+  t.true(error.message.includes('HTTP port will be port + 1'));
+  
+  clear_settings_cache();
+  
+  // Test HTTP port overflow
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({ port: 65535 });
+  
+  error = t.throws(() => load_settings());
+  t.true(error.message.includes('HTTP port (65536) would exceed maximum port number (65535)'));
+  t.true(error.message.includes('Use a lower TCP port'));
+});
+
+test('get_port_configuration is resilient to settings loading errors', (t) => {
+  // Set invalid JSON to cause settings loading to fail
+  process.env.JOYSTICK_DB_SETTINGS = '{ invalid json }';
+  
+  // Should not throw and should return defaults
+  const { tcp_port, http_port } = get_port_configuration();
+  
+  t.is(tcp_port, 1983);
+  t.is(http_port, 1984);
+});
+
+test('port configuration updates when settings are reloaded', (t) => {
+  // Start with default configuration
+  let { tcp_port, http_port } = get_port_configuration();
+  t.is(tcp_port, 1983);
+  t.is(http_port, 1984);
+  
+  // Set new port configuration
+  process.env.JOYSTICK_DB_SETTINGS = JSON.stringify({
+    port: 4000,
+    authentication: {}
+  });
+  
+  // Configuration should update after loading settings
+  load_settings();
+  ({ tcp_port, http_port } = get_port_configuration());
+  t.is(tcp_port, 4000);
+  t.is(http_port, 4001);
+});

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

@@ -0,0 +1,282 @@
+import test from 'ava';
+import sinon from 'sinon';
+import create_logger from '../../../src/server/lib/logger.js';
+
+test.beforeEach(t => {
+  t.context.mock_logger = {
+    info: sinon.stub(),
+    warn: sinon.stub(),
+    error: sinon.stub(),
+    debug: sinon.stub()
+  };
+});
+
+test.afterEach(t => {
+  sinon.restore();
+});
+
+test('create_logger returns logger and create_context_logger function', t => {
+  const result = create_logger('test');
+  
+  t.truthy(result.logger);
+  t.is(typeof result.create_context_logger, 'function');
+});
+
+test('create_logger with different component names', t => {
+  const result_one = create_logger('master');
+  const result_two = create_logger('worker');
+  const result_three = create_logger();
+  
+  t.truthy(result_one.logger);
+  t.truthy(result_two.logger);
+  t.truthy(result_three.logger);
+  t.is(typeof result_one.create_context_logger, 'function');
+  t.is(typeof result_two.create_context_logger, 'function');
+  t.is(typeof result_three.create_context_logger, 'function');
+});
+
+test('create_context_logger returns object with logging methods', t => {
+  const { create_context_logger } = create_logger('test');
+  const context_logger = create_context_logger();
+  
+  t.is(typeof context_logger.info, 'function');
+  t.is(typeof context_logger.warn, 'function');
+  t.is(typeof context_logger.error, 'function');
+  t.is(typeof context_logger.debug, 'function');
+  t.is(typeof context_logger.log_operation, 'function');
+  t.is(typeof context_logger.log_request, 'function');
+});
+
+test('context logger info method with base context', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const info_stub = sinon.stub(logger, 'info');
+  
+  const base_context = { component: 'test', pid: 123 };
+  const context_logger = create_context_logger(base_context);
+  
+  const message = 'Test message';
+  const additional_context = { operation: 'test_op' };
+  
+  context_logger.info(message, additional_context);
+  
+  t.true(info_stub.calledOnce);
+  const call = info_stub.firstCall;
+  t.is(call.args[0], message);
+  t.deepEqual(call.args[1].context, { ...base_context, ...additional_context });
+});
+
+test('context logger warn method with context', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const warn_stub = sinon.stub(logger, 'warn');
+  
+  const base_context = { component: 'test' };
+  const context_logger = create_context_logger(base_context);
+  
+  const message = 'Warning message';
+  const additional_context = { warning_type: 'test' };
+  
+  context_logger.warn(message, additional_context);
+  
+  t.true(warn_stub.calledOnce);
+  const call = warn_stub.firstCall;
+  t.is(call.args[0], message);
+  t.deepEqual(call.args[1].context, { ...base_context, ...additional_context });
+});
+
+test('context logger error method handles Error objects', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const error_stub = sinon.stub(logger, 'error');
+  
+  const base_context = { component: 'test' };
+  const context_logger = create_context_logger(base_context);
+  
+  const message = 'Error occurred';
+  const error = new Error('Test error');
+  
+  context_logger.error(message, error);
+  
+  t.true(error_stub.calledOnce);
+  const call = error_stub.firstCall;
+  t.is(call.args[0], message);
+  t.deepEqual(call.args[1].context, base_context);
+  t.is(call.args[1].error_message, 'Test error');
+  t.truthy(call.args[1].stack);
+});
+
+test('context logger error method handles context objects', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const error_stub = sinon.stub(logger, 'error');
+  
+  const base_context = { component: 'test' };
+  const context_logger = create_context_logger(base_context);
+  
+  const message = 'Error occurred';
+  const error_context = { error_code: 500, details: 'Server error' };
+  
+  context_logger.error(message, error_context);
+  
+  t.true(error_stub.calledOnce);
+  const call = error_stub.firstCall;
+  t.is(call.args[0], message);
+  t.deepEqual(call.args[1].context, { ...base_context, ...error_context });
+});
+
+test('context logger debug method with context', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const debug_stub = sinon.stub(logger, 'debug');
+  
+  const base_context = { component: 'test' };
+  const context_logger = create_context_logger(base_context);
+  
+  const message = 'Debug message';
+  const debug_context = { debug_info: 'test_data' };
+  
+  context_logger.debug(message, debug_context);
+  
+  t.true(debug_stub.calledOnce);
+  const call = debug_stub.firstCall;
+  t.is(call.args[0], message);
+  t.deepEqual(call.args[1].context, { ...base_context, ...debug_context });
+});
+
+test('log_operation method includes operation and duration', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const info_stub = sinon.stub(logger, 'info');
+  
+  const base_context = { component: 'test' };
+  const context_logger = create_context_logger(base_context);
+  
+  const operation = 'database_write';
+  const duration = 150;
+  const additional_context = { records_affected: 5 };
+  
+  context_logger.log_operation(operation, duration, additional_context);
+  
+  t.true(info_stub.calledOnce);
+  const call = info_stub.firstCall;
+  t.is(call.args[0], `Operation completed: ${operation}`);
+  t.deepEqual(call.args[1].context, { ...base_context, ...additional_context, operation });
+  t.is(call.args[1].duration_ms, duration);
+});
+
+test('log_request method includes request_id and operation', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const info_stub = sinon.stub(logger, 'info');
+  
+  const base_context = { component: 'test' };
+  const context_logger = create_context_logger(base_context);
+  
+  const request_id = 'req_123';
+  const operation = 'find_one';
+  const additional_context = { collection: 'users' };
+  
+  context_logger.log_request(request_id, operation, additional_context);
+  
+  t.true(info_stub.calledOnce);
+  const call = info_stub.firstCall;
+  t.is(call.args[0], `Request: ${operation}`);
+  t.is(call.args[1].request_id, request_id);
+  t.deepEqual(call.args[1].context, { ...base_context, ...additional_context, operation });
+});
+
+test('context logger methods work with empty base context', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const info_stub = sinon.stub(logger, 'info');
+  
+  const context_logger = create_context_logger();
+  
+  context_logger.info('Test message', { test: 'data' });
+  
+  t.true(info_stub.calledOnce);
+  const call = info_stub.firstCall;
+  t.deepEqual(call.args[1].context, { test: 'data' });
+});
+
+test('context logger methods work with empty additional context', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const info_stub = sinon.stub(logger, 'info');
+  
+  const base_context = { component: 'test' };
+  const context_logger = create_context_logger(base_context);
+  
+  context_logger.info('Test message');
+  
+  t.true(info_stub.calledOnce);
+  const call = info_stub.firstCall;
+  t.deepEqual(call.args[1].context, base_context);
+});
+
+test('context logger handles undefined context gracefully', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const info_stub = sinon.stub(logger, 'info');
+  
+  const context_logger = create_context_logger();
+  
+  context_logger.info('Test message');
+  
+  t.true(info_stub.calledOnce);
+  const call = info_stub.firstCall;
+  t.deepEqual(call.args[1].context, {});
+});
+
+test('log_operation works with minimal parameters', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const info_stub = sinon.stub(logger, 'info');
+  
+  const context_logger = create_context_logger();
+  
+  context_logger.log_operation('test_op', 100);
+  
+  t.true(info_stub.calledOnce);
+  const call = info_stub.firstCall;
+  t.is(call.args[0], 'Operation completed: test_op');
+  t.is(call.args[1].duration_ms, 100);
+  t.deepEqual(call.args[1].context, { operation: 'test_op' });
+});
+
+test('log_request works with minimal parameters', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const info_stub = sinon.stub(logger, 'info');
+  
+  const context_logger = create_context_logger();
+  
+  context_logger.log_request('req_456', 'update_one');
+  
+  t.true(info_stub.calledOnce);
+  const call = info_stub.firstCall;
+  t.is(call.args[0], 'Request: update_one');
+  t.is(call.args[1].request_id, 'req_456');
+  t.deepEqual(call.args[1].context, { operation: 'update_one' });
+});
+
+test('context merging preserves base context when additional context is empty', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const info_stub = sinon.stub(logger, 'info');
+  
+  const base_context = { component: 'test', pid: 999 };
+  const context_logger = create_context_logger(base_context);
+  
+  context_logger.info('Test message', {});
+  
+  t.true(info_stub.calledOnce);
+  const call = info_stub.firstCall;
+  t.deepEqual(call.args[1].context, base_context);
+});
+
+test('additional context overrides base context for same keys', t => {
+  const { logger, create_context_logger } = create_logger('test');
+  const info_stub = sinon.stub(logger, 'info');
+  
+  const base_context = { component: 'test', operation: 'base_op' };
+  const context_logger = create_context_logger(base_context);
+  
+  context_logger.info('Test message', { operation: 'override_op', extra: 'data' });
+  
+  t.true(info_stub.calledOnce);
+  const call = info_stub.firstCall;
+  t.deepEqual(call.args[1].context, { 
+    component: 'test', 
+    operation: 'override_op', 
+    extra: 'data' 
+  });
+});