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

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

@@ -0,0 +1,155 @@
+import test from 'ava';
+import { decode as decode_messagepack } from 'msgpackr';
+import { send_success, send_error, send_message } from '../../../src/server/lib/send_response.js';
+
+class MockSocket {
+  constructor() {
+    this.written_data = [];
+  }
+  
+  write(data) {
+    this.written_data.push(data);
+  }
+  
+  get_last_written() {
+    return this.written_data[this.written_data.length - 1];
+  }
+  
+  get_decoded_last_written() {
+    const last_data = this.get_last_written();
+    
+    if (last_data.length < 4) {
+      throw new Error('Invalid message format: too short');
+    }
+    
+    const length = last_data.readUInt32BE(0);
+    const payload = last_data.slice(4);
+    
+    if (payload.length !== length) {
+      throw new Error(`Invalid message format: expected ${length} bytes, got ${payload.length}`);
+    }
+    
+    return decode_messagepack(payload);
+  }
+}
+
+test('send_success sends properly formatted success response', (t) => {
+  const mock_socket = new MockSocket();
+  const test_data = { user_id: 123, name: 'test' };
+  
+  send_success(mock_socket, test_data);
+  
+  const response = mock_socket.get_decoded_last_written();
+  
+  t.is(response.ok, true);
+  t.deepEqual(response.data, test_data);
+  t.is(response.error, undefined);
+});
+
+test('send_success with empty data object', (t) => {
+  const mock_socket = new MockSocket();
+  
+  send_success(mock_socket, {});
+  
+  const response = mock_socket.get_decoded_last_written();
+  
+  t.is(response.ok, true);
+  t.deepEqual(response.data, {});
+});
+
+test('send_success with no data parameter uses empty object', (t) => {
+  const mock_socket = new MockSocket();
+  
+  send_success(mock_socket);
+  
+  const response = mock_socket.get_decoded_last_written();
+  
+  t.is(response.ok, true);
+  t.deepEqual(response.data, {});
+});
+
+test('send_error sends properly formatted error response', (t) => {
+  const mock_socket = new MockSocket();
+  const test_error = { message: 'Something went wrong', code: 500 };
+  
+  send_error(mock_socket, test_error);
+  
+  const response = mock_socket.get_decoded_last_written();
+  
+  t.is(response.ok, false);
+  t.deepEqual(response.error, test_error);
+  t.is(response.data, undefined);
+});
+
+test('send_error with empty error object', (t) => {
+  const mock_socket = new MockSocket();
+  
+  send_error(mock_socket, {});
+  
+  const response = mock_socket.get_decoded_last_written();
+  
+  t.is(response.ok, false);
+  t.deepEqual(response.error, {});
+});
+
+test('send_error with no error parameter uses empty object', (t) => {
+  const mock_socket = new MockSocket();
+  
+  send_error(mock_socket);
+  
+  const response = mock_socket.get_decoded_last_written();
+  
+  t.is(response.ok, false);
+  t.deepEqual(response.error, {});
+});
+
+test('send_message sends message in data object', (t) => {
+  const mock_socket = new MockSocket();
+  const test_message = 'Operation completed successfully';
+  
+  send_message(mock_socket, test_message);
+  
+  const response = mock_socket.get_decoded_last_written();
+  
+  t.is(response.ok, true);
+  t.deepEqual(response.data, { message: test_message });
+  t.is(response.error, undefined);
+});
+
+test('send_message with empty string', (t) => {
+  const mock_socket = new MockSocket();
+  
+  send_message(mock_socket, '');
+  
+  const response = mock_socket.get_decoded_last_written();
+  
+  t.is(response.ok, true);
+  t.deepEqual(response.data, { message: '' });
+});
+
+test('send_message with no message parameter uses empty string', (t) => {
+  const mock_socket = new MockSocket();
+  
+  send_message(mock_socket);
+  
+  const response = mock_socket.get_decoded_last_written();
+  
+  t.is(response.ok, true);
+  t.deepEqual(response.data, { message: '' });
+});
+
+test('all functions encode responses as messagepack', (t) => {
+  const mock_socket = new MockSocket();
+  
+  send_success(mock_socket, { test: 'data' });
+  const success_data = mock_socket.get_last_written();
+  t.true(Buffer.isBuffer(success_data));
+  
+  send_error(mock_socket, { test: 'error' });
+  const error_data = mock_socket.get_last_written();
+  t.true(Buffer.isBuffer(error_data));
+  
+  send_message(mock_socket, 'test message');
+  const message_data = mock_socket.get_last_written();
+  t.true(Buffer.isBuffer(message_data));
+});

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

@@ -0,0 +1,169 @@
+import test from 'ava';
+import { encode_message, create_message_parser } from '../../../src/server/lib/tcp_protocol.js';
+
+test('encode_message - should encode message with length prefix', (t) => {
+  const data = { test: 'data', number: 42 };
+  const result = encode_message(data);
+  
+  t.true(Buffer.isBuffer(result));
+  t.true(result.length > 4);
+  
+  const length = result.readUInt32BE(0);
+  const payload = result.slice(4);
+  
+  t.is(payload.length, length);
+});
+
+test('encode_message - should handle empty object', (t) => {
+  const data = {};
+  const result = encode_message(data);
+  
+  t.true(Buffer.isBuffer(result));
+  
+  const length = result.readUInt32BE(0);
+  t.true(length > 0);
+});
+
+test('encode_message - should handle complex nested data', (t) => {
+  const data = {
+    nested: {
+      array: [1, 2, 3],
+      string: 'test',
+      boolean: true
+    }
+  };
+  
+  const result = encode_message(data);
+  
+  t.true(Buffer.isBuffer(result));
+  t.true(result.length > 4);
+});
+
+test('create_message_parser - should parse single complete message', (t) => {
+  const parser = create_message_parser();
+  const test_data = { op: 'test', data: { value: 123 } };
+  const encoded = encode_message(test_data);
+  
+  const messages = parser.parse_messages(encoded);
+  
+  t.is(messages.length, 1);
+  t.deepEqual(messages[0], test_data);
+});
+
+test('create_message_parser - should parse multiple messages', (t) => {
+  const parser = create_message_parser();
+  const test_data_1 = { op: 'test1', data: { value: 123 } };
+  const test_data_2 = { op: 'test2', data: { value: 456 } };
+  
+  const encoded_1 = encode_message(test_data_1);
+  const encoded_2 = encode_message(test_data_2);
+  const combined = Buffer.concat([encoded_1, encoded_2]);
+  
+  const messages = parser.parse_messages(combined);
+  
+  t.is(messages.length, 2);
+  t.deepEqual(messages[0], test_data_1);
+  t.deepEqual(messages[1], test_data_2);
+});
+
+test('create_message_parser - should handle partial messages', (t) => {
+  const parser = create_message_parser();
+  const test_data = { op: 'test', data: { value: 123 } };
+  const encoded = encode_message(test_data);
+  
+  const partial_1 = encoded.slice(0, 2);
+  const partial_2 = encoded.slice(2);
+  
+  let messages = parser.parse_messages(partial_1);
+  t.is(messages.length, 0);
+  
+  messages = parser.parse_messages(partial_2);
+  t.is(messages.length, 1);
+  t.deepEqual(messages[0], test_data);
+});
+
+test('create_message_parser - should handle partial length prefix', (t) => {
+  const parser = create_message_parser();
+  const test_data = { op: 'test', data: { value: 123 } };
+  const encoded = encode_message(test_data);
+  
+  const partial_length = encoded.slice(0, 3);
+  const remaining = encoded.slice(3);
+  
+  let messages = parser.parse_messages(partial_length);
+  t.is(messages.length, 0);
+  
+  messages = parser.parse_messages(remaining);
+  t.is(messages.length, 1);
+  t.deepEqual(messages[0], test_data);
+});
+
+test('create_message_parser - should handle partial payload', (t) => {
+  const parser = create_message_parser();
+  const test_data = { op: 'test', data: { value: 123 } };
+  const encoded = encode_message(test_data);
+  
+  const length_and_partial = encoded.slice(0, encoded.length - 2);
+  const remaining_payload = encoded.slice(encoded.length - 2);
+  
+  let messages = parser.parse_messages(length_and_partial);
+  t.is(messages.length, 0);
+  
+  messages = parser.parse_messages(remaining_payload);
+  t.is(messages.length, 1);
+  t.deepEqual(messages[0], test_data);
+});
+
+test('create_message_parser - should throw on invalid messagepack', (t) => {
+  const parser = create_message_parser();
+  
+  const invalid_length = Buffer.allocUnsafe(4);
+  invalid_length.writeUInt32BE(5, 0);
+  const invalid_payload = Buffer.from([0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
+  const invalid_message = Buffer.concat([invalid_length, invalid_payload]);
+  
+  t.throws(
+    () => {
+      parser.parse_messages(invalid_message);
+    },
+    { message: /Invalid message format/ }
+  );
+});
+
+test('create_message_parser - reset should clear internal state', (t) => {
+  const parser = create_message_parser();
+  const test_data = { op: 'test', data: { value: 123 } };
+  const encoded = encode_message(test_data);
+  
+  const partial = encoded.slice(0, 2);
+  parser.parse_messages(partial);
+  
+  parser.reset();
+  
+  const messages = parser.parse_messages(encoded);
+  t.is(messages.length, 1);
+  t.deepEqual(messages[0], test_data);
+});
+
+test('create_message_parser - should handle empty buffer', (t) => {
+  const parser = create_message_parser();
+  const empty_buffer = Buffer.alloc(0);
+  
+  const messages = parser.parse_messages(empty_buffer);
+  
+  t.is(messages.length, 0);
+});
+
+test('create_message_parser - should handle zero-length message', (t) => {
+  const parser = create_message_parser();
+  
+  const zero_length = Buffer.allocUnsafe(4);
+  zero_length.writeUInt32BE(0, 0);
+  
+  t.throws(
+    () => {
+      parser.parse_messages(zero_length);
+    },
+    { message: /Invalid message format/ }
+  );
+});

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

@@ -0,0 +1,258 @@
+import test from 'ava';
+import { get_write_forwarder, initialize_write_forwarder, shutdown_write_forwarder } from '../../../src/server/lib/write_forwarder.js';
+
+test.beforeEach(async () => {
+  // Clean up any existing write forwarder
+  await shutdown_write_forwarder();
+});
+
+test.afterEach(async () => {
+  // Clean up after each test
+  await shutdown_write_forwarder();
+});
+
+test('write forwarder singleton', t => {
+  const forwarder1 = get_write_forwarder();
+  const forwarder2 = get_write_forwarder();
+  
+  t.is(forwarder1, forwarder2, 'Should return same instance');
+});
+
+test('write forwarder initialization without settings', t => {
+  const forwarder = get_write_forwarder();
+  
+  // Should not throw when no settings are available
+  t.notThrows(() => {
+    forwarder.initialize();
+  });
+  
+  t.false(forwarder.is_secondary_mode, 'Should not be in secondary mode without settings');
+});
+
+test('write forwarder default configuration', t => {
+  const forwarder = get_write_forwarder();
+  
+  t.false(forwarder.is_secondary_mode, 'Should not be in secondary mode by default');
+  t.is(forwarder.primary_config, null, 'Should have no primary config by default');
+  t.is(forwarder.pending_forwards.size, 0, 'Should have no pending forwards');
+  t.is(forwarder.forward_timeout_ms, 10000, 'Should have default timeout');
+  t.is(forwarder.reconnect_delay_ms, 5000, 'Should have default reconnect delay');
+});
+
+test('write forwarder should forward operation check', t => {
+  const forwarder = get_write_forwarder();
+  
+  // Not in secondary mode
+  t.false(forwarder.should_forward_operation('insert_one'), 'Should not forward when not in secondary mode');
+  
+  // Enable secondary mode
+  forwarder.is_secondary_mode = true;
+  
+  // Test write operations
+  t.true(forwarder.should_forward_operation('insert_one'), 'Should forward insert_one');
+  t.true(forwarder.should_forward_operation('update_one'), 'Should forward update_one');
+  t.true(forwarder.should_forward_operation('delete_one'), 'Should forward delete_one');
+  t.true(forwarder.should_forward_operation('bulk_write'), 'Should forward bulk_write');
+  t.true(forwarder.should_forward_operation('create_index'), 'Should forward create_index');
+  t.true(forwarder.should_forward_operation('drop_index'), 'Should forward drop_index');
+  
+  // Test read operations
+  t.false(forwarder.should_forward_operation('find_one'), 'Should not forward find_one');
+  t.false(forwarder.should_forward_operation('find'), 'Should not forward find');
+  t.false(forwarder.should_forward_operation('get_indexes'), 'Should not forward get_indexes');
+  
+  // Clean up
+  forwarder.is_secondary_mode = false;
+});
+
+test('write forwarder forward operation when not in secondary mode', async t => {
+  const forwarder = get_write_forwarder();
+  const mockSocket = { id: 'test-socket' };
+  
+  const forwarded = await forwarder.forward_operation(mockSocket, 'insert_one', { collection: 'test' });
+  
+  t.false(forwarded, 'Should not forward when not in secondary mode');
+});
+
+test('write forwarder forward operation when not connected', async t => {
+  const forwarder = get_write_forwarder();
+  const mockSocket = { 
+    id: 'test-socket',
+    write: () => {}
+  };
+  
+  // Enable secondary mode but no connection
+  forwarder.is_secondary_mode = true;
+  forwarder.primary_connection = null;
+  
+  const forwarded = await forwarder.forward_operation(mockSocket, 'insert_one', { collection: 'test' });
+  
+  t.true(forwarded, 'Should handle forward attempt');
+  
+  // Clean up
+  forwarder.is_secondary_mode = false;
+});
+
+test('write forwarder generate forward ID', t => {
+  const forwarder = get_write_forwarder();
+  
+  const id1 = forwarder.generate_forward_id();
+  const id2 = forwarder.generate_forward_id();
+  
+  t.is(typeof id1, 'string', 'Should return string ID');
+  t.is(typeof id2, 'string', 'Should return string ID');
+  t.not(id1, id2, 'Should generate unique IDs');
+  t.true(id1.startsWith('fwd_'), 'Should start with fwd_ prefix');
+});
+
+test('write forwarder get status when disabled', t => {
+  const forwarder = get_write_forwarder();
+  
+  const status = forwarder.get_forwarder_status();
+  
+  t.false(status.enabled, 'Should report as disabled');
+  t.false(status.connected_to_primary, 'Should not be connected to primary');
+  t.is(status.primary_config, null, 'Should have no primary config');
+  t.is(status.pending_forwards, 0, 'Should have no pending forwards');
+  t.is(status.stats.total_forwards, 0, 'Should have zero total forwards');
+});
+
+test('write forwarder statistics tracking', t => {
+  const forwarder = get_write_forwarder();
+  
+  const initialStats = forwarder.stats;
+  
+  t.is(initialStats.total_forwards, 0, 'Should start with zero forwards');
+  t.is(initialStats.successful_forwards, 0, 'Should start with zero successful forwards');
+  t.is(initialStats.failed_forwards, 0, 'Should start with zero failed forwards');
+  t.is(initialStats.avg_forward_latency_ms, 0, 'Should start with zero average latency');
+  t.is(initialStats.connection_attempts, 0, 'Should start with zero connection attempts');
+  t.is(initialStats.last_connection_attempt, null, 'Should have no last connection attempt');
+});
+
+test('write forwarder handle forward timeout', t => {
+  const forwarder = get_write_forwarder();
+  const forwardId = 'test-forward-id';
+  
+  // Add a pending forward
+  forwarder.pending_forwards.set(forwardId, {
+    client_socket: { write: () => {} },
+    operation: 'insert_one',
+    data: { collection: 'test' },
+    sent_at: Date.now(),
+    timeout: null
+  });
+  
+  const initialFailed = forwarder.stats.failed_forwards;
+  
+  forwarder.handle_forward_timeout(forwardId);
+  
+  t.false(forwarder.pending_forwards.has(forwardId), 'Should remove pending forward');
+  t.is(forwarder.stats.failed_forwards, initialFailed + 1, 'Should increment failed forwards');
+});
+
+test('write forwarder fail pending forwards', t => {
+  const forwarder = get_write_forwarder();
+  
+  // Add multiple pending forwards
+  for (let i = 0; i < 3; i++) {
+    forwarder.pending_forwards.set(`forward-${i}`, {
+      client_socket: { write: () => {} },
+      operation: 'insert_one',
+      data: { collection: 'test' },
+      sent_at: Date.now(),
+      timeout: null
+    });
+  }
+  
+  const initialFailed = forwarder.stats.failed_forwards;
+  const pendingCount = forwarder.pending_forwards.size;
+  
+  forwarder.fail_pending_forwards('Test reason');
+  
+  t.is(forwarder.pending_forwards.size, 0, 'Should clear all pending forwards');
+  t.is(forwarder.stats.failed_forwards, initialFailed + pendingCount, 'Should increment failed forwards by pending count');
+});
+
+test('write forwarder shutdown', async t => {
+  const forwarder = get_write_forwarder();
+  
+  // Add some pending forwards
+  forwarder.pending_forwards.set('test-forward', {
+    client_socket: { write: () => {} },
+    operation: 'insert_one',
+    data: { collection: 'test' },
+    sent_at: Date.now(),
+    timeout: null
+  });
+  
+  forwarder.is_secondary_mode = true;
+  
+  // Should not throw when shutting down
+  await t.notThrowsAsync(async () => {
+    await forwarder.shutdown();
+  });
+  
+  t.false(forwarder.is_secondary_mode, 'Should disable secondary mode after shutdown');
+  t.is(forwarder.pending_forwards.size, 0, 'Should clear pending forwards after shutdown');
+  t.is(forwarder.primary_connection, null, 'Should clear primary connection after shutdown');
+});
+
+test('write forwarder handle primary response with unknown forward', t => {
+  const forwarder = get_write_forwarder();
+  
+  // Set up primary connection
+  forwarder.primary_connection = {
+    authenticated: true,
+    last_ping: Date.now()
+  };
+  
+  const response = {
+    forward_id: 'unknown-forward-id',
+    ok: 1,
+    result: 'success'
+  };
+  
+  // Should not throw when handling unknown forward response
+  t.notThrows(() => {
+    forwarder.handle_forward_response(response);
+  });
+});
+
+test('write forwarder handle authentication success', t => {
+  const forwarder = get_write_forwarder();
+  
+  // Set up primary connection
+  forwarder.primary_connection = {
+    authenticated: false,
+    last_ping: Date.now()
+  };
+  
+  const authResponse = {
+    ok: 1,
+    message: 'Authentication successful'
+  };
+  
+  forwarder.handle_primary_response(authResponse);
+  
+  t.true(forwarder.primary_connection.authenticated, 'Should set authenticated to true');
+});
+
+test('write forwarder handle ping response', t => {
+  const forwarder = get_write_forwarder();
+  
+  // Set up primary connection
+  const initialPing = Date.now() - 1000;
+  forwarder.primary_connection = {
+    authenticated: true,
+    last_ping: initialPing
+  };
+  
+  const pingResponse = {
+    ok: 1
+  };
+  
+  forwarder.handle_primary_response(pingResponse);
+  
+  t.true(forwarder.primary_connection.last_ping > initialPing, 'Should update last ping time');
+});