@joystick.js/db-canary 0.0.0-canary.2270 → 0.0.0-canary.2272

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

@@ -1,402 +0,0 @@
-/**
- * @fileoverview Tests for batched write queue system.
- * Comprehensive test suite covering functionality, performance, and edge cases.
- */
-
-import test from 'ava';
-import BatchedWriteQueue, { get_batched_write_queue, shutdown_batched_write_queue } from '../../../src/server/lib/batched_write_queue.js';
-import ProcessingLane from '../../../src/server/lib/processing_lane.js';
-
-test('ProcessingLane should create with correct configuration', (t) => {
-  const lane = new ProcessingLane({
-    batch_size: 3,
-    batch_timeout: 50,
-    lane_id: 0
-  });
-
-  t.is(lane.batch_size, 3);
-  t.is(lane.batch_timeout, 50);
-  t.is(lane.lane_id, 0);
-  t.is(lane.current_batch.length, 0);
-  t.is(lane.processing, false);
-});
-
-test('ProcessingLane should add operations to batch and process when batch size is reached', async (t) => {
-  const lane = new ProcessingLane({
-    batch_size: 3,
-    batch_timeout: 50,
-    lane_id: 0
-  });
-
-  try {
-    const operations = [];
-
-    // Create 3 operations (batch size)
-    for (let i = 0; i < 3; i++) {
-      const operation_fn = async () => `result_${i}`;
-      const context = { test: `operation_${i}` };
-      
-      operations.push(lane.add_operation({ operation_fn, context }));
-    }
-
-    // Wait for all operations to complete
-    const completed_results = await Promise.all(operations);
-    
-    t.deepEqual(completed_results, ['result_0', 'result_1', 'result_2']);
-    
-    // Check statistics
-    const stats = lane.get_stats();
-    t.is(stats.total_operations, 3);
-    t.is(stats.completed_operations, 3);
-    t.is(stats.batches_processed, 1);
-  } finally {
-    await lane.shutdown();
-  }
-});
-
-test('ProcessingLane should process partial batch on timeout', async (t) => {
-  const lane = new ProcessingLane({
-    batch_size: 3,
-    batch_timeout: 50,
-    lane_id: 0
-  });
-
-  try {
-    const operation_fn = async () => 'timeout_result';
-    const context = { test: 'timeout_operation' };
-    
-    // Add single operation (less than batch size)
-    const result_promise = lane.add_operation({ operation_fn, context });
-    
-    // Wait for timeout to trigger processing
-    const result = await result_promise;
-    
-    t.is(result, 'timeout_result');
-    
-    const stats = lane.get_stats();
-    t.is(stats.total_operations, 1);
-    t.is(stats.completed_operations, 1);
-    t.is(stats.batches_processed, 1);
-  } finally {
-    await lane.shutdown();
-  }
-});
-
-test('ProcessingLane should handle operation failures correctly', async (t) => {
-  const lane = new ProcessingLane({
-    batch_size: 3,
-    batch_timeout: 50,
-    lane_id: 0
-  });
-
-  try {
-    const error_message = 'Test operation error';
-    const operation_fn = async () => {
-      throw new Error(error_message);
-    };
-    
-    const error = await t.throwsAsync(
-      lane.add_operation({ operation_fn, context: {} })
-    );
-    
-    t.is(error.message, error_message);
-    
-    const stats = lane.get_stats();
-    t.is(stats.total_operations, 1);
-    t.is(stats.failed_operations, 1);
-    t.is(stats.completed_operations, 0);
-  } finally {
-    await lane.shutdown();
-  }
-});
-
-test('ProcessingLane should flush batch manually', async (t) => {
-  const lane = new ProcessingLane({
-    batch_size: 3,
-    batch_timeout: 50,
-    lane_id: 0
-  });
-
-  try {
-    const operation_fn = async () => 'flush_result';
-    
-    // Add operation but don't wait for timeout
-    const result_promise = lane.add_operation({ operation_fn, context: {} });
-    
-    // Manually flush the batch
-    await lane.flush_batch();
-    
-    const result = await result_promise;
-    t.is(result, 'flush_result');
-  } finally {
-    await lane.shutdown();
-  }
-});
-
-test('ProcessingLane should reject operations during shutdown', async (t) => {
-  const lane = new ProcessingLane({
-    batch_size: 3,
-    batch_timeout: 50,
-    lane_id: 0
-  });
-
-  // Start shutdown
-  const shutdown_promise = lane.shutdown();
-  
-  // Try to add operation during shutdown
-  const error = await t.throwsAsync(
-    lane.add_operation({ 
-      operation_fn: async () => 'should_not_execute',
-      context: {}
-    })
-  );
-  
-  t.is(error.message, 'Processing lane shutting down');
-  
-  await shutdown_promise;
-});
-
-test('BatchedWriteQueue should create with correct configuration', (t) => {
-  const queue = new BatchedWriteQueue({
-    batch_size: 3,
-    batch_timeout: 50,
-    lane_count: 2,
-    queue_limit: 100
-  });
-
-  t.is(queue.batch_size, 3);
-  t.is(queue.batch_timeout, 50);
-  t.is(queue.lane_count, 2);
-  t.is(queue.lanes.length, 2);
-  t.is(queue.queue_limit, 100);
-});
-
-test('BatchedWriteQueue should distribute operations across lanes consistently', async (t) => {
-  const queue = new BatchedWriteQueue({
-    batch_size: 3,
-    batch_timeout: 50,
-    lane_count: 2,
-    queue_limit: 100
-  });
-
-  try {
-    const operations = [];
-    
-    // Create operations with different contexts
-    for (let i = 0; i < 10; i++) {
-      const operation_fn = async () => `result_${i}`;
-      const context = { 
-        collection: 'test_collection',
-        document_id: `doc_${i % 3}` // This should create consistent distribution
-      };
-      
-      operations.push(queue.enqueue_write_operation(operation_fn, context));
-    }
-    
-    // Wait for all operations to complete
-    const results = await Promise.all(operations);
-    
-    t.is(results.length, 10);
-    
-    // Check that operations were distributed across lanes
-    const stats = queue.get_stats();
-    t.is(stats.total_operations, 10);
-    t.is(stats.completed_operations, 10);
-    
-    // Verify lane distribution exists and totals correctly
-    t.truthy(stats.lane_distribution);
-    t.is(Array.isArray(stats.lane_distribution), true);
-    const total_distributed = stats.lane_distribution.reduce((sum, count) => sum + count, 0);
-    t.is(total_distributed, 10);
-  } finally {
-    await queue.shutdown();
-  }
-});
-
-test('BatchedWriteQueue should maintain backward compatibility with WriteQueue API', async (t) => {
-  const queue = new BatchedWriteQueue({
-    batch_size: 3,
-    batch_timeout: 50,
-    lane_count: 2,
-    queue_limit: 100
-  });
-
-  try {
-    const operation_fn = async () => 'compatible_result';
-    const context = { test: 'compatibility' };
-    
-    // Test the main API method
-    const result = await queue.enqueue_write_operation(operation_fn, context);
-    t.is(result, 'compatible_result');
-    
-    // Test statistics format
-    const stats = queue.get_stats();
-    t.is(typeof stats.total_operations, 'number');
-    t.is(typeof stats.completed_operations, 'number');
-    t.is(typeof stats.failed_operations, 'number');
-    t.is(typeof stats.current_queue_depth, 'number');
-    t.is(typeof stats.max_queue_depth, 'number');
-    t.is(typeof stats.avg_wait_time_ms, 'number');
-    t.is(typeof stats.avg_processing_time_ms, 'number');
-    t.is(typeof stats.success_rate, 'number');
-  } finally {
-    await queue.shutdown();
-  }
-});
-
-test('BatchedWriteQueue should clear statistics correctly', async (t) => {
-  const queue = new BatchedWriteQueue({
-    batch_size: 3,
-    batch_timeout: 50,
-    lane_count: 2,
-    queue_limit: 100
-  });
-
-  try {
-    // Add some operations first
-    queue.stats.total_operations = 10;
-    queue.stats.completed_operations = 8;
-    queue.stats.failed_operations = 2;
-    
-    queue.clear_stats();
-    
-    const stats = queue.get_stats();
-    t.is(stats.total_operations, 0);
-    t.is(stats.completed_operations, 0);
-    t.is(stats.failed_operations, 0);
-  } finally {
-    await queue.shutdown();
-  }
-});
-
-test('BatchedWriteQueue should flush all batches correctly', async (t) => {
-  const queue = new BatchedWriteQueue({
-    batch_size: 3,
-    batch_timeout: 50,
-    lane_count: 2,
-    queue_limit: 100
-  });
-
-  try {
-    const operations = [];
-    
-    // Add operations to different lanes
-    for (let i = 0; i < 4; i++) {
-      const operation_fn = async () => `flush_result_${i}`;
-      const context = { collection: 'test', document_id: `doc_${i}` };
-      
-      operations.push(queue.enqueue_write_operation(operation_fn, context));
-    }
-    
-    // Flush all batches
-    await queue.flush_all_batches();
-    
-    // All operations should complete
-    const results = await Promise.all(operations);
-    t.is(results.length, 4);
-  } finally {
-    await queue.shutdown();
-  }
-});
-
-test.afterEach(async () => {
-  await shutdown_batched_write_queue();
-});
-
-test('BatchedWriteQueue singleton should create singleton instance', (t) => {
-  const queue1 = get_batched_write_queue();
-  const queue2 = get_batched_write_queue();
-  
-  t.is(queue1, queue2);
-});
-
-test('BatchedWriteQueue singleton should shutdown correctly', async (t) => {
-  const queue = get_batched_write_queue();
-  t.truthy(queue);
-  
-  await shutdown_batched_write_queue();
-  
-  // Getting queue again should create new instance
-  const new_queue = get_batched_write_queue();
-  t.not(new_queue, queue);
-  
-  await shutdown_batched_write_queue();
-});
-
-test('BatchedWriteQueue should handle high throughput operations', async (t) => {
-  const queue = new BatchedWriteQueue({
-    batch_size: 50,
-    batch_timeout: 10,
-    lane_count: 4
-  });
-  
-  try {
-    const operation_count = 500; // Reduced for faster testing
-    const operations = [];
-    const start_time = Date.now();
-    
-    // Create many fast operations
-    for (let i = 0; i < operation_count; i++) {
-      const operation_fn = async () => `result_${i}`;
-      const context = { 
-        collection: 'perf_test',
-        document_id: `doc_${i % 100}` // Distribute across 100 different documents
-      };
-      
-      operations.push(queue.enqueue_write_operation(operation_fn, context));
-    }
-    
-    // Wait for all operations to complete
-    const results = await Promise.all(operations);
-    const end_time = Date.now();
-    
-    t.is(results.length, operation_count);
-    
-    const duration_ms = end_time - start_time;
-    const throughput = Math.round(operation_count / (duration_ms / 1000));
-    
-    console.log(`Processed ${operation_count} operations in ${duration_ms}ms (${throughput} ops/sec)`);
-    
-    // Verify statistics
-    const stats = queue.get_stats();
-    t.is(stats.total_operations, operation_count);
-    t.is(stats.completed_operations, operation_count);
-    t.is(stats.success_rate, 100);
-    
-  } finally {
-    await queue.shutdown();
-  }
-});
-
-test('BatchedWriteQueue should demonstrate batching efficiency', async (t) => {
-  const queue = new BatchedWriteQueue({
-    batch_size: 100,
-    batch_timeout: 5,
-    lane_count: 4
-  });
-  
-  try {
-    const operation_count = 300; // Reduced for faster testing
-    const operations = [];
-    
-    for (let i = 0; i < operation_count; i++) {
-      const operation_fn = async () => `batch_result_${i}`;
-      const context = { collection: 'batch_test', document_id: `doc_${i}` };
-      
-      operations.push(queue.enqueue_write_operation(operation_fn, context));
-    }
-    
-    await Promise.all(operations);
-    
-    const stats = queue.get_stats();
-    
-    // Should have processed significantly fewer batches than operations
-    t.true(stats.total_batches_processed < operation_count);
-    t.true(stats.avg_batch_size > 1);
-    
-    console.log(`Batching efficiency: ${operation_count} operations in ${stats.total_batches_processed} batches (avg ${stats.avg_batch_size} ops/batch)`);
-    
-  } finally {
-    await queue.shutdown();
-  }
-});

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

@@ -1,186 +0,0 @@
-/**
- * @fileoverview Integration tests for write queue backward compatibility.
- * Ensures the batched write queue maintains complete API compatibility.
- */
-
-import test from 'ava';
-import { get_write_queue, shutdown_write_queue, set_batched_queue_enabled } from '../../../src/server/lib/write_queue.js';
-
-test.afterEach(async () => {
-  await shutdown_write_queue();
-});
-
-test('WriteQueue should use batched queue by default', async (t) => {
-  const write_queue = get_write_queue();
-  
-  // Should be using the wrapper
-  t.is(write_queue.constructor.name, 'WriteQueueWrapper');
-  
-  // API should work identically
-  const result = await write_queue.enqueue_write_operation(
-    async () => 'test_result',
-    { test: 'context' }
-  );
-  
-  t.is(result, 'test_result');
-});
-
-test('WriteQueue should maintain backward compatible statistics format', async (t) => {
-  const write_queue = get_write_queue();
-  
-  // Add some operations
-  await write_queue.enqueue_write_operation(async () => 'result1', {});
-  await write_queue.enqueue_write_operation(async () => 'result2', {});
-  
-  const stats = write_queue.get_stats();
-  
-  // Check all expected properties exist with correct types
-  t.is(typeof stats.total_operations, 'number');
-  t.is(typeof stats.completed_operations, 'number');
-  t.is(typeof stats.failed_operations, 'number');
-  t.is(typeof stats.current_queue_depth, 'number');
-  t.is(typeof stats.max_queue_depth, 'number');
-  t.is(typeof stats.avg_wait_time_ms, 'number');
-  t.is(typeof stats.avg_processing_time_ms, 'number');
-  t.is(typeof stats.success_rate, 'number');
-  
-  // Verify values
-  t.is(stats.total_operations, 2);
-  t.is(stats.completed_operations, 2);
-  t.is(stats.success_rate, 100);
-});
-
-test('WriteQueue should support traditional queue when batched is disabled', async (t) => {
-  // Disable batched queue
-  set_batched_queue_enabled(false);
-  
-  const write_queue = get_write_queue();
-  
-  // Should be using traditional WriteQueue
-  t.is(write_queue.constructor.name, 'WriteQueue');
-  
-  // API should work identically
-  const result = await write_queue.enqueue_write_operation(
-    async () => 'traditional_result',
-    { test: 'traditional' }
-  );
-  
-  t.is(result, 'traditional_result');
-  
-  // Re-enable for other tests
-  set_batched_queue_enabled(true);
-});
-
-test('WriteQueue should handle errors consistently', async (t) => {
-  const write_queue = get_write_queue();
-  
-  const error_message = 'Test error';
-  
-  const error = await t.throwsAsync(
-    write_queue.enqueue_write_operation(
-      async () => {
-        throw new Error(error_message);
-      },
-      { test: 'error_handling' }
-    )
-  );
-  
-  t.is(error.message, error_message);
-  
-  const stats = write_queue.get_stats();
-  t.is(stats.failed_operations, 1);
-});
-
-test('WriteQueue should clear statistics correctly', async (t) => {
-  const write_queue = get_write_queue();
-  
-  // Add some operations
-  await write_queue.enqueue_write_operation(async () => 'result', {});
-  
-  let stats = write_queue.get_stats();
-  t.is(stats.total_operations, 1);
-  
-  // Clear stats
-  write_queue.clear_stats();
-  
-  stats = write_queue.get_stats();
-  t.is(stats.total_operations, 0);
-  t.is(stats.completed_operations, 0);
-});
-
-test('WriteQueue should shutdown gracefully', async (t) => {
-  const write_queue = get_write_queue();
-  
-  // Add operation
-  await write_queue.enqueue_write_operation(async () => 'result', {});
-  
-  // Shutdown should complete without errors
-  await shutdown_write_queue();
-  
-  // Getting queue again should create new instance
-  const new_queue = get_write_queue();
-  t.not(new_queue, write_queue);
-  
-  await shutdown_write_queue();
-});
-
-test('WriteQueue should handle concurrent operations correctly', async (t) => {
-  const write_queue = get_write_queue();
-  const operation_count = 50; // Reduced for faster testing
-  const operations = [];
-  
-  // Create many concurrent operations
-  for (let i = 0; i < operation_count; i++) {
-    operations.push(
-      write_queue.enqueue_write_operation(
-        async () => `concurrent_result_${i}`,
-        { operation_id: i }
-      )
-    );
-  }
-  
-  // Wait for all to complete
-  const results = await Promise.all(operations);
-  
-  t.is(results.length, operation_count);
-  
-  // Verify all results are unique and correct
-  const expected_results = Array.from({ length: operation_count }, (_, i) => `concurrent_result_${i}`);
-  results.sort();
-  expected_results.sort();
-  
-  t.deepEqual(results, expected_results);
-  
-  const stats = write_queue.get_stats();
-  t.is(stats.total_operations, operation_count);
-  t.is(stats.completed_operations, operation_count);
-  t.is(stats.success_rate, 100);
-});
-
-test('WriteQueue should maintain operation ordering within same context', async (t) => {
-  const write_queue = get_write_queue();
-  const results = [];
-  
-  // Create operations that will go to the same lane (same collection/document)
-  const operations = [];
-  for (let i = 0; i < 10; i++) {
-    operations.push(
-      write_queue.enqueue_write_operation(
-        async () => {
-          results.push(i);
-          return `ordered_result_${i}`;
-        },
-        { 
-          collection: 'test_collection',
-          document_id: 'same_document' // Same context = same lane
-        }
-      )
-    );
-  }
-  
-  await Promise.all(operations);
-  
-  // Results should be in order for same lane
-  // Note: This test verifies that operations with same context maintain order
-  t.is(results.length, 10);
-});