@joystick.js/db-canary 0.0.0-canary.2275 → 0.0.0-canary.2276

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

@@ -1,202 +0,0 @@
-import test from 'ava';
-import { get_replication_manager, initialize_replication_manager, shutdown_replication_manager } from '../../../src/server/lib/replication_manager.js';
-
-test.beforeEach(async () => {
-  // Clean up any existing replication manager
-  await shutdown_replication_manager();
-});
-
-test.afterEach(async () => {
-  // Clean up after each test
-  await shutdown_replication_manager();
-});
-
-test('replication manager singleton', t => {
-  const manager1 = get_replication_manager();
-  const manager2 = get_replication_manager();
-  
-  t.is(manager1, manager2, 'Should return same instance');
-});
-
-test('replication manager initialization without settings', t => {
-  const manager = get_replication_manager();
-  
-  // Should not throw when no settings are available
-  t.notThrows(() => {
-    manager.initialize();
-  });
-  
-  t.false(manager.enabled, 'Should be disabled without settings');
-});
-
-test('replication manager default configuration', t => {
-  const manager = get_replication_manager();
-  
-  t.false(manager.enabled, 'Should be disabled by default');
-  t.is(manager.mode, 'async', 'Should default to async mode');
-  t.is(manager.timeout_ms, 5000, 'Should have default timeout');
-  t.is(manager.retry_attempts, 3, 'Should have default retry attempts');
-  t.is(manager.batch_size, 100, 'Should have default batch size');
-});
-
-test('replication manager queue operation when disabled', t => {
-  const manager = get_replication_manager();
-  
-  // Should not throw when queuing operations while disabled
-  t.notThrows(() => {
-    manager.queue_replication('insert_one', 'test_collection', { document: { name: 'test' } });
-  });
-  
-  t.is(manager.replication_queue.length, 0, 'Should not queue when disabled');
-});
-
-test('replication manager get status when disabled', t => {
-  const manager = get_replication_manager();
-  
-  const status = manager.get_replication_status();
-  
-  t.false(status.enabled, 'Should report as disabled');
-  t.is(status.connected_secondaries, 0, 'Should have no connected secondaries');
-  t.is(status.queue_length, 0, 'Should have empty queue');
-  t.false(status.processing, 'Should not be processing');
-  t.is(status.secondaries.length, 0, 'Should have no secondaries');
-});
-
-test('replication manager get secondary health when disabled', t => {
-  const manager = get_replication_manager();
-  
-  const health = manager.get_secondary_health();
-  
-  t.is(health.total_secondaries, 0, 'Should have no secondaries');
-  t.is(health.healthy_secondaries, 0, 'Should have no healthy secondaries');
-  t.is(health.secondaries.length, 0, 'Should have empty secondaries array');
-});
-
-test('replication manager add secondary when disabled', async t => {
-  const manager = get_replication_manager();
-  
-  const secondary = {
-    id: 'test-secondary',
-    ip: '127.0.0.1',
-    port: 1984,
-    private_key: Buffer.from('test-key').toString('base64'),
-    enabled: true
-  };
-  
-  // Should not throw but won't actually connect
-  const result = await manager.add_secondary(secondary);
-  
-  t.true(result.success, 'Should return success');
-  t.is(result.secondary_id, 'test-secondary', 'Should return secondary ID');
-});
-
-test('replication manager remove non-existent secondary', t => {
-  const manager = get_replication_manager();
-  
-  const error = t.throws(() => {
-    manager.remove_secondary('non-existent');
-  });
-  
-  t.true(error.message.includes('not found'), 'Should throw not found error');
-});
-
-test('replication manager sync when disabled', async t => {
-  const manager = get_replication_manager();
-  
-  const error = await t.throwsAsync(async () => {
-    await manager.sync_secondaries();
-  });
-  
-  t.true(error.message.includes('not enabled'), 'Should throw not enabled error');
-});
-
-test('replication manager shutdown', async t => {
-  const manager = get_replication_manager();
-  
-  // Should not throw when shutting down
-  await t.notThrowsAsync(async () => {
-    await manager.shutdown();
-  });
-  
-  t.false(manager.enabled, 'Should be disabled after shutdown');
-  t.false(manager.processing_replication, 'Should not be processing after shutdown');
-  t.is(manager.secondary_connections.size, 0, 'Should have no connections after shutdown');
-  t.is(manager.replication_queue.length, 0, 'Should have empty queue after shutdown');
-});
-
-test('replication manager statistics tracking', t => {
-  const manager = get_replication_manager();
-  
-  const initialStats = manager.stats;
-  
-  t.is(initialStats.total_operations_replicated, 0, 'Should start with zero operations');
-  t.is(initialStats.successful_replications, 0, 'Should start with zero successful replications');
-  t.is(initialStats.failed_replications, 0, 'Should start with zero failed replications');
-  t.is(initialStats.connected_secondaries, 0, 'Should start with zero connected secondaries');
-  t.is(initialStats.avg_replication_latency_ms, 0, 'Should start with zero average latency');
-});
-
-test('replication manager sequence number generation', t => {
-  const manager = get_replication_manager();
-  
-  const initialSequence = manager.sequence_number;
-  
-  // Enable manager temporarily to test sequence generation
-  manager.enabled = true;
-  manager.secondary_connections.set('test', { authenticated: true });
-  
-  manager.queue_replication('insert_one', 'test', { document: { name: 'test1' } });
-  manager.queue_replication('insert_one', 'test', { document: { name: 'test2' } });
-  
-  t.is(manager.sequence_number, initialSequence + 2, 'Should increment sequence number for each operation');
-  t.true(manager.sequence_number > initialSequence, 'Should generate increasing sequence numbers');
-  
-  // Clean up
-  manager.enabled = false;
-  manager.secondary_connections.clear();
-  manager.replication_queue = [];
-});
-
-test('replication manager sequence number increment', t => {
-  const manager = get_replication_manager();
-  
-  const initialSequence = manager.sequence_number;
-  
-  // Enable manager temporarily to test queue operation
-  manager.enabled = true;
-  manager.secondary_connections.set('test', { authenticated: true });
-  
-  manager.queue_replication('insert_one', 'test', { document: { name: 'test' } });
-  
-  t.is(manager.sequence_number, initialSequence + 1, 'Should increment sequence number');
-  
-  // Clean up
-  manager.enabled = false;
-  manager.secondary_connections.clear();
-  manager.replication_queue = [];
-});
-
-test('replication manager batch processing preparation', t => {
-  const manager = get_replication_manager();
-  
-  // Enable manager and add mock secondary
-  manager.enabled = true;
-  manager.secondary_connections.set('test', { 
-    authenticated: true,
-    socket: { write: () => {} },
-    pending_operations: new Map()
-  });
-  
-  // Add multiple operations to queue
-  for (let i = 0; i < 5; i++) {
-    manager.queue_replication('insert_one', 'test', { document: { id: i } });
-  }
-  
-  t.is(manager.replication_queue.length, 5, 'Should queue all operations');
-  t.is(manager.stats.total_operations_replicated, 5, 'Should track total operations');
-  
-  // Clean up
-  manager.enabled = false;
-  manager.secondary_connections.clear();
-  manager.replication_queue = [];
-});

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

@@ -1,258 +0,0 @@
-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');
-});