queen-mq 0.3.1 → 0.6.3

package/client-js/test/qos0-tests.js

@@ -1,334 +0,0 @@
-import { startTest, passTest, failTest } from './utils.js';
-
-/**
- * Test server-side buffering
- * Uses file buffer for fast writes, server flushes every 100ms (configurable via FILE_BUFFER_FLUSH_MS)
- */
-export async function testQoS0Buffering(client) {
-  startTest('Server-side buffering', 'qos0');
-  
-  try {
-    const queue = 'test-qos0-buffer-' + Date.now();
-    await client.queue(queue);
-    
-    // Push 10 events with server-side buffering
-    const start = Date.now();
-    for (let i = 0; i < 10; i++) {
-      await client.push(queue, { index: i }, { buffer: true });
-    }
-    const pushTime = Date.now() - start;
-    
-    // Should return quickly (buffered to file, server-side batching)
-    // With file buffering, push should be fast (< 500ms for 10 messages)
-    if (pushTime >= 500) {
-      throw new Error(`Push should be fast (file buffered), took ${pushTime}ms`);
-    }
-    
-    // Wait for server to flush buffer (FILE_BUFFER_FLUSH_MS default is 100ms)
-    // Add extra margin for processing
-    await new Promise(resolve => setTimeout(resolve, 300));
-    
-    // Consume all events
-    const messages = [];
-    for await (const msg of client.take(queue, { batch: 20 })) {
-      messages.push(msg);
-      await client.ack(msg);
-      if (messages.length >= 10) break;
-    }
-    
-    if (messages.length !== 10) {
-      throw new Error(`Should receive all 10 events, got ${messages.length}`);
-    }
-    
-    // Verify all events received
-    const indices = messages.map(m => m.data.index).sort((a, b) => a - b);
-    for (let i = 0; i < 10; i++) {
-      if (!indices.includes(i)) {
-        throw new Error(`Should have event with index ${i}`);
-      }
-    }
-    
-    passTest('Server-side buffering works correctly');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test auto-acknowledgment
- */
-export async function testAutoAck(client) {
-  startTest('Auto-acknowledgment', 'qos0');
-  
-  try {
-    const queue = 'test-autoack-' + Date.now();
-    await client.queue(queue);
-    
-    // Push message
-    await client.push(queue, { test: 'autoack-data' });
-    
-    // Take with auto-ack
-    let msg;
-    for await (const m of client.take(queue, { autoAck: true })) {
-      msg = m;
-      break;
-    }
-    
-    if (msg === undefined) {
-      throw new Error('Should receive message');
-    }
-    if (msg.data.test !== 'autoack-data') {
-      throw new Error('Should have correct data');
-    }
-    
-    // Message should NOT be available again (already auto-acked)
-    await new Promise(resolve => setTimeout(resolve, 100));
-    
-    let count = 0;
-    for await (const m of client.take(queue, { wait: false, batch: 10 })) {
-      count++;
-      await client.ack(m);
-      break;
-    }
-    
-    if (count !== 0) {
-      throw new Error('Message should not be available again (auto-acked)');
-    }
-    
-    passTest('Auto-ack works correctly');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test consumer group with auto-ack
- */
-export async function testConsumerGroupAutoAck(client) {
-  startTest('Consumer group with auto-ack', 'qos0');
-  
-  try {
-    const queue = 'test-cg-autoack-' + Date.now();
-    await client.queue(queue);
-    
-    // Push message
-    await client.push(queue, { value: 42, type: 'test' });
-    
-    // Wait a bit for message to be available
-    await new Promise(resolve => setTimeout(resolve, 100));
-    
-    // Two consumer groups consume same message
-    let msgA, msgB;
-    
-    for await (const msg of client.take(`${queue}@groupA`, { autoAck: true })) {
-      msgA = msg;
-      break;
-    }
-    
-    for await (const msg of client.take(`${queue}@groupB`, { autoAck: true })) {
-      msgB = msg;
-      break;
-    }
-    
-    if (msgA === undefined) {
-      throw new Error('Group A should receive message');
-    }
-    if (msgB === undefined) {
-      throw new Error('Group B should receive message');
-    }
-    if (msgA.data.value !== 42) {
-      throw new Error('Group A should have correct data');
-    }
-    if (msgB.data.value !== 42) {
-      throw new Error('Group B should have correct data');
-    }
-    
-    // Both groups should have auto-acked - message not available again
-    await new Promise(resolve => setTimeout(resolve, 100));
-    
-    let countA = 0, countB = 0;
-    
-    for await (const msg of client.take(`${queue}@groupA`, { wait: false })) {
-      countA++;
-      await client.ack(msg, true, { group: 'groupA' });
-      break;
-    }
-    
-    for await (const msg of client.take(`${queue}@groupB`, { wait: false })) {
-      countB++;
-      await client.ack(msg, true, { group: 'groupB' });
-      break;
-    }
-    
-    if (countA !== 0) {
-      throw new Error('Group A should have auto-acked');
-    }
-    if (countB !== 0) {
-      throw new Error('Group B should have auto-acked');
-    }
-    
-    passTest('Consumer group auto-ack works correctly');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test normal push preserves FIFO ordering
- */
-export async function testFIFOOrdering(client) {
-  startTest('Normal push preserves FIFO', 'qos0');
-  
-  try {
-    const queue = 'test-fifo-' + Date.now();
-    await client.queue(queue);
-    
-    // Push without buffering (normal mode)
-    for (let i = 0; i < 20; i++) {
-      await client.push(queue, { order: i });
-    }
-    
-    // Consume and verify order
-    const messages = [];
-    for await (const msg of client.take(queue, { batch: 20 })) {
-      messages.push(msg);
-      await client.ack(msg);
-      if (messages.length >= 20) break;
-    }
-    
-    if (messages.length !== 20) {
-      throw new Error(`Should have 20 messages, got ${messages.length}`);
-    }
-    
-    // Verify FIFO ordering
-    for (let i = 0; i < 20; i++) {
-      if (messages[i].data.order !== i) {
-        throw new Error(`Message ${i} out of order: got ${messages[i].data.order}`);
-      }
-    }
-    
-    passTest('FIFO ordering preserved for normal push');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test mixed buffered and non-buffered operations
- */
-export async function testMixedOperations(client) {
-  startTest('Mixed buffered and normal operations', 'qos0');
-  
-  try {
-    const queue = 'test-mixed-' + Date.now();
-    await client.queue(queue);
-    
-    // Push with buffering (file buffered)
-    await client.push(queue, { type: 'buffered', id: 1 }, { buffer: true });
-    
-    // Push normal (direct DB)
-    await client.push(queue, { type: 'normal', id: 2 });
-    
-    // Wait for buffer flush (100ms + margin)
-    await new Promise(resolve => setTimeout(resolve, 200));
-    
-    // Should have both messages
-    const messages = [];
-    for await (const msg of client.take(queue, { batch: 10 })) {
-      messages.push(msg);
-      await client.ack(msg);
-      if (messages.length >= 2) break;
-    }
-    
-    if (messages.length !== 2) {
-      throw new Error(`Should have 2 messages, got ${messages.length}`);
-    }
-    
-    const types = messages.map(m => m.data.type);
-    if (!types.includes('buffered')) {
-      throw new Error('Should have buffered message');
-    }
-    if (!types.includes('normal')) {
-      throw new Error('Should have normal message');
-    }
-    
-    passTest('Mixed buffered and normal operations work correctly');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test buffered events are stored individually
- * Note: Buffering is a server-side optimization for DB writes,
- * not for combining events into a single message
- */
-export async function testBatchedPayload(client) {
-  startTest('Buffered events stored individually', 'qos0');
-  
-  try {
-    const queue = 'test-batch-payload-' + Date.now();
-    await client.queue(queue);
-    
-    // Push multiple events with buffering
-    for (let i = 0; i < 5; i++) {
-      await client.push(queue, { index: i, timestamp: Date.now() }, { buffer: true });
-    }
-    
-    // Wait for server flush (100ms + margin)
-    await new Promise(resolve => setTimeout(resolve, 200));
-    
-    // Consume all messages - each event should be a separate message
-    const messages = [];
-    for await (const msg of client.take(queue, { batch: 10 })) {
-      messages.push(msg);
-      await client.ack(msg);
-      if (messages.length >= 5) break;
-    }
-    
-    if (messages.length !== 5) {
-      throw new Error(`Should receive 5 separate messages, got ${messages.length}`);
-    }
-    
-    // Verify each message has individual payload (not batched into array)
-    for (const msg of messages) {
-      if (typeof msg.data !== 'object' || Array.isArray(msg.data)) {
-        throw new Error(`Each message should have object payload, got ${typeof msg.data}`);
-      }
-      if (typeof msg.data.index !== 'number') {
-        throw new Error('Each message should have index property');
-      }
-    }
-    
-    // Verify all indices are present
-    const indices = messages.map(m => m.data.index).sort((a, b) => a - b);
-    for (let i = 0; i < 5; i++) {
-      if (!indices.includes(i)) {
-        throw new Error(`Should have message with index ${i}`);
-      }
-    }
-    
-    passTest('Buffered events stored and retrieved individually');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Run all QoS 0 tests
- */
-export async function runQoS0Tests(client) {
-  console.log('\n╔════════════════════════════════════════╗');
-  console.log('║     Queen QoS 0 Test Suite            ║');
-  console.log('╚════════════════════════════════════════╝\n');
-  
-  await testQoS0Buffering(client);
-  await testAutoAck(client);
-  await testConsumerGroupAutoAck(client);
-  await testFIFOOrdering(client);
-  await testMixedOperations(client);
-  await testBatchedPayload(client);
-  
-  console.log('\n✅ All QoS 0 tests passed!\n');
-}
-

package/client-js/test/test-new.js

@@ -1,370 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Complete Test Suite for Queen Message Queue System
- * Using the new minimalist Queen client interface
- * 
- * Test Categories:
- * 1. Core Features
- * 2. Partition Locking
- * 3. Enterprise Features (coming soon)
- * 4. Bus Mode Features (coming soon)
- * 5. Edge Cases (coming soon)
- * 6. Advanced Scenarios & Patterns (coming soon)
- */
-
-import { Queen } from '../client/client.js';
-import { 
-  TEST_CONFIG, 
-  initDb, 
-  closeDb, 
-  cleanupTestData, 
-  printResults, 
-  log,
-  resetResults
-} from './utils.js';
-
-// Import human tests
-import {
-  testCreateQueue,
-  workerQueueTest
-} from './human.js';
-
-// Import test modules
-import {
-  testQueueCreationPolicy,
-  testSingleMessagePush,
-  testBatchMessagePush,
-  testQueueConfiguration,
-  testTakeAndAcknowledgment,
-  testDelayedProcessing,
-  testPartitionFIFOOrdering,
-  testWindowBuffer
-} from './core-tests.js';
-
-import {
-  testPartitionLocking,
-  testBusPartitionLocking,
-  testSpecificPartitionLocking,
-  testNamespaceTaskFiltering,
-  testNamespaceTaskBusMode
-} from './partition-locking-tests.js';
-
-import {
-  testMessageEncryption,
-  testRetentionPendingMessages,
-  testRetentionCompletedMessages,
-  testPartitionRetention,
-  testConsumerEncryption,
-  testMessageEviction,
-  testCombinedEnterpriseFeatures,
-  testEnterpriseErrorHandling
-} from './enterprise-tests.js';
-
-import {
-  testBusConsumerGroups,
-  testMixedMode,
-  testConsumerGroupSubscriptionModes,
-  testConsumerGroupIsolation
-} from './bus-mode-tests.js';
-
-import {
-  testEmptyAndNullPayloads,
-  testVeryLargePayloads,
-  testConcurrentPushOperations,
-  testConcurrentTakeOperations,
-  testManyConsumerGroups,
-  testRetryLimitExhaustion,
-  testLeaseExpiration,
-  testSQLInjectionPrevention,
-  testXSSPrevention
-} from './edge-case-tests.js';
-
-import {
-  testDuplicateTransactionIdsAcrossPartitions,
-  testBatchAckWithDuplicateTransactionIds,
-  testDLQWithDuplicateTransactionIds,
-  testAnalyticsAPIWithDuplicateTransactionIds
-} from './partition-transaction-tests.js';
-
-import {
-  testMultiStagePipeline,
-  testFanOutFanIn,
-  testComplexPriorityScenarios,
-  testDynamicPriorityAdjustment,
-  testSagaPattern,
-  testRateLimiting,
-  testTimeBatchProcessing,
-  testEventSourcing,
-  testQueueMetrics,
-  testMultipleConsumersSinglePartitionOrdering,
-  testDeadLetterQueuePattern,
-  testCircuitBreaker,
-  testMessageDeduplication
-} from './advanced-pattern-tests.js';
-
-import {
-  testPipelineBasic,
-  testPipelineErrorHandling,
-  testPipelineAutoRenewal,
-  testPipelineParallel,
-  testPipelineConcurrencyRaceCondition,
-  testPipelineContinuous,
-  testTransactionAPI,
-  testPipelineAtomic,
-  testManualLeaseRenewal,
-  testLeaseValidation,
-  testComplexPipelineWorkflow,
-  runAdvancedClientTests
-} from './advanced-client-tests.js';
-
-import {
-  testQoS0Buffering,
-  testAutoAck,
-  testConsumerGroupAutoAck,
-  testFIFOOrdering,
-  testMixedOperations,
-  testBatchedPayload
-} from './qos0-tests.js';
-
-// Helper to run a test with error handling and delay
-async function runTest(testFn) {
-  try {
-    await testFn();
-  } catch (error) {
-    log(`Unexpected error in test: ${error.message}`, 'error');
-  }
-  await new Promise(resolve => setTimeout(resolve, 100)); // Small delay between tests
-}
-
-// Parse command-line arguments
-const args = process.argv.slice(2);
-const testFilter = args[0]; // e.g., 'core', 'bus', 'edge', 'enterprise', 'partition', 'advanced'
-
-// Show help if requested
-if (testFilter === 'help' || testFilter === '--help' || testFilter === '-h') {
-  console.log('Usage: node src/test/test-new.js [category]');
-  console.log('\nAvailable test categories:');
-  console.log('  core       - Core features (queue creation, push, take, ack, etc.)');
-  console.log('  partition  - Partition locking tests');
-  console.log('  enterprise - Enterprise features (encryption, retention, eviction)');
-  console.log('  bus        - Bus mode features (consumer groups, mixed mode)');
-  console.log('  edge       - Edge cases (null payloads, large payloads, SQL injection, etc.)');
-  console.log('  qos0       - QoS 0 features (buffering, auto-ack, FIFO ordering)');
-  console.log('  advanced   - Advanced patterns (pipeline, fan-out, DLQ, circuit breaker)');
-  console.log('\nExamples:');
-  console.log('  node src/test/test-new.js              # Run all tests');
-  console.log('  node src/test/test-new.js core         # Run only core tests');
-  console.log('  node src/test/test-new.js bus          # Run only bus mode tests');
-  console.log('  node src/test/test-new.js edge         # Run only edge case tests');
-  console.log('  node src/test/test-new.js qos0         # Run only QoS 0 tests');
-  process.exit(0);
-}
-
-async function runTests() {
-  console.log('🚀 Starting Queen Message Queue Test Suite');
-  console.log('   Using the new minimalist Queen client interface\n');
-  if (testFilter) {
-    console.log(`   🎯 Running only: ${testFilter} tests\n`);
-  }
-  console.log('='.repeat(80));
-  
-  let client;
-  
-  try {
-    // Initialize database connection
-    await initDb();
-    log('Database connection established');
-    
-    // Initialize client
-    client = new Queen({ 
-      baseUrls: TEST_CONFIG.baseUrls,
-      timeout: 30000,
-      retryAttempts: 3
-    });
-    log('Queen client initialized');
-    
-    // Check for encryption key
-    if (process.env.QUEEN_ENCRYPTION_KEY) {
-      log('Encryption key detected - encryption tests will run', 'info');
-    } else {
-      log('No encryption key found - encryption tests will be skipped', 'warning');
-    }
-    
-    // Clean up any existing test data
-    await cleanupTestData();
-
-    // ============================================
-    // HUMAN TESTS
-    // ============================================
-    if (!testFilter || testFilter === 'human') {
-      console.log('\n👤 HUMAN TESTS');
-      console.log('-'.repeat(40));
-      await runTest(() => testCreateQueue(client));
-      await runTest(() => workerQueueTest(client));
-    }
-    
-    // ============================================
-    // CORE FEATURE TESTS
-    // ============================================
-    if (!testFilter || testFilter === 'core') {
-      console.log('\n📦 CORE FEATURES');
-      console.log('-'.repeat(40));
-      
-      await runTest(() => testQueueCreationPolicy(client));
-      await runTest(() => testSingleMessagePush(client));
-      await runTest(() => testBatchMessagePush(client));
-      await runTest(() => testQueueConfiguration(client));
-      await runTest(() => testTakeAndAcknowledgment(client));
-      await runTest(() => testDelayedProcessing(client));
-      await runTest(() => testPartitionFIFOOrdering(client));
-      await runTest(() => testWindowBuffer(client));
-    }
-    
-    // ============================================
-    // PARTITION LOCKING TESTS
-    // ============================================
-    if (!testFilter || testFilter === 'partition' || testFilter === 'locking') {
-      console.log('\n🔒 PARTITION LOCKING');
-      console.log('-'.repeat(40));
-      
-      await runTest(() => testPartitionLocking(client));
-      await runTest(() => testBusPartitionLocking(client));
-      await runTest(() => testSpecificPartitionLocking(client));
-      await runTest(() => testNamespaceTaskFiltering(client));
-      await runTest(() => testNamespaceTaskBusMode(client));
-    }
-    
-    // ============================================
-    // ENTERPRISE FEATURE TESTS
-    // ============================================
-    if (!testFilter || testFilter === 'enterprise') {
-      console.log('\n🏢 ENTERPRISE FEATURES');
-      console.log('-'.repeat(40));
-      
-      await runTest(() => testMessageEncryption(client));
-      await runTest(() => testRetentionPendingMessages(client));
-      await runTest(() => testRetentionCompletedMessages(client));
-      await runTest(() => testPartitionRetention(client));
-      await runTest(() => testConsumerEncryption(client));
-      await runTest(() => testMessageEviction(client));
-      await runTest(() => testCombinedEnterpriseFeatures(client));
-      await runTest(() => testEnterpriseErrorHandling(client));
-    }
-    
-    // ============================================
-    // BUS MODE FEATURE TESTS
-    // ============================================
-    if (!testFilter || testFilter === 'bus') {
-      console.log('\n🚌 BUS MODE FEATURES');
-      console.log('-'.repeat(40));
-      
-      await runTest(() => testBusConsumerGroups(client));
-      await runTest(() => testMixedMode(client));
-      await runTest(() => testConsumerGroupSubscriptionModes(client));
-      await runTest(() => testConsumerGroupIsolation(client));
-    }
-    
-    // ============================================
-    // EDGE CASE TESTS
-    // ============================================
-    if (!testFilter || testFilter === 'edge') {
-      console.log('\n🔍 EDGE CASES');
-      console.log('-'.repeat(40));
-      
-      await runTest(() => testEmptyAndNullPayloads(client));
-      await runTest(() => testVeryLargePayloads(client));
-      await runTest(() => testConcurrentPushOperations(client));
-      await runTest(() => testConcurrentTakeOperations(client));
-      await runTest(() => testManyConsumerGroups(client));
-      await runTest(() => testRetryLimitExhaustion(client));
-      await runTest(() => testLeaseExpiration(client));
-      await runTest(() => testSQLInjectionPrevention(client));
-      await runTest(() => testXSSPrevention(client));
-      
-      // Partition-scoped transaction_id tests
-      await runTest(() => testDuplicateTransactionIdsAcrossPartitions(client));
-      await runTest(() => testBatchAckWithDuplicateTransactionIds(client));
-      await runTest(() => testDLQWithDuplicateTransactionIds(client));
-      await runTest(() => testAnalyticsAPIWithDuplicateTransactionIds(client));
-    }
-    
-    // ============================================
-    // QOS 0 FEATURE TESTS
-    // ============================================
-    if (!testFilter || testFilter === 'qos0') {
-      console.log('\n⚡ QOS 0 FEATURES');
-      console.log('-'.repeat(40));
-      
-      await runTest(() => testQoS0Buffering(client));
-      await runTest(() => testAutoAck(client));
-      await runTest(() => testConsumerGroupAutoAck(client));
-      await runTest(() => testFIFOOrdering(client));
-      await runTest(() => testMixedOperations(client));
-      await runTest(() => testBatchedPayload(client));
-    }
-    
-    // ============================================
-    // ADVANCED CLIENT FEATURE TESTS
-    // ============================================
-    if (!testFilter || testFilter === 'advanced' || testFilter === 'client') {
-      console.log('\n🚀 ADVANCED CLIENT FEATURES');
-      console.log('-'.repeat(40));
-      
-      await runTest(() => testPipelineBasic(client));
-      await runTest(() => testPipelineErrorHandling(client));
-      await runTest(() => testPipelineAutoRenewal(client));
-      await runTest(() => testPipelineParallel(client));
-      await runTest(() => testPipelineConcurrencyRaceCondition(client));
-      await runTest(() => testPipelineContinuous(client));
-      await runTest(() => testTransactionAPI(client));
-      await runTest(() => testPipelineAtomic(client));
-      await runTest(() => testManualLeaseRenewal(client));
-      await runTest(() => testLeaseValidation(client));
-      await runTest(() => testComplexPipelineWorkflow(client));
-    }
-    
-    // ============================================
-    // ADVANCED SCENARIO TESTS
-    // ============================================
-    if (!testFilter || testFilter === 'advanced' || testFilter === 'pattern') {
-      console.log('\n🎯 ADVANCED PATTERNS');
-      console.log('-'.repeat(40));
-      
-      await runTest(() => testMultiStagePipeline(client));
-      await runTest(() => testFanOutFanIn(client));
-      await runTest(() => testComplexPriorityScenarios(client));
-      await runTest(() => testDynamicPriorityAdjustment(client));
-      await runTest(() => testDeadLetterQueuePattern(client));
-      await runTest(() => testSagaPattern(client));
-      await runTest(() => testRateLimiting(client));
-      await runTest(() => testMessageDeduplication(client));
-      await runTest(() => testTimeBatchProcessing(client));
-      await runTest(() => testEventSourcing(client));
-      await runTest(() => testQueueMetrics(client));
-      await runTest(() => testCircuitBreaker(client));
-      await runTest(() => testMultipleConsumersSinglePartitionOrdering(client));
-    }
-    
-  } catch (error) {
-    log(`Test suite setup failed: ${error.message}`, 'error');
-    console.error(error);
-  } finally {
-    // Cleanup
-    if (client) {
-      await client.close();
-    }
-    await cleanupTestData();
-    await closeDb();
-  }
-  
-  // Print results
-  printResults();
-}
-
-// Run the test suite
-runTests().catch(error => {
-  console.error('💥 Test suite crashed:', error);
-  process.exit(1);
-});
-