queen-mq 0.3.1 → 0.6.3

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

@@ -1,761 +0,0 @@
-/**
- * Advanced Client Feature Tests
- * Tests for Pipeline API, Transaction API, Lease Management, and other new features
- */
-
-import { startTest, passTest, failTest, sleep, log } from './utils.js';
-
-/**
- * Test: Pipeline API - Basic Processing
- */
-export async function testPipelineBasic(client) {
-  startTest('Pipeline API - Basic Processing', 'advanced');
-  
-  try {
-    const queue = 'test-pipeline-basic';
-    await client.queue(queue, { leaseTime: 30, retryLimit: 3 });
-    
-    // Push test messages
-    const messages = [];
-    for (let i = 1; i <= 10; i++) {
-      messages.push({ id: i, data: `Message ${i}` });
-    }
-    await client.push(queue, messages);
-    
-    // Test individual message processing
-    let processedCount = 0;
-    await client
-      .pipeline(queue)
-      .take(5)
-      .process(async (message) => {
-        processedCount++;
-        return { processed: message.data.id };
-      })
-      .execute();
-    
-    if (processedCount !== 5) {
-      throw new Error(`Expected to process 5 messages, got ${processedCount}`);
-    }
-    
-    // Test batch processing
-    let batchSize = 0;
-    await client
-      .pipeline(queue)
-      .take(5)
-      .processBatch(async (messages) => {
-        batchSize = messages.length;
-        return messages.map(m => ({ processed: m.data.id }));
-      })
-      .execute();
-    
-    if (batchSize !== 5) {
-      throw new Error(`Expected batch of 5 messages, got ${batchSize}`);
-    }
-    
-    await client.queueDelete(queue);
-    passTest('Pipeline API basic processing works correctly');
-  } catch (error) {
-    failTest('Pipeline API - Basic Processing', error);
-  }
-}
-
-/**
- * Test: Pipeline API - Error Handling
- */
-export async function testPipelineErrorHandling(client) {
-  startTest('Pipeline API - Error Handling', 'advanced');
-  
-  try {
-    const queue = 'test-pipeline-errors';
-    const errorQueue = 'test-pipeline-errors-dlq';
-    
-    await client.queue(queue, { leaseTime: 30, retryLimit: 2 });
-    await client.queue(errorQueue, { leaseTime: 30 });
-    
-    // Push messages that will cause errors
-    await client.push(queue, [
-      { id: 1, action: 'process' },
-      { id: 2, action: 'error' },
-      { id: 3, action: 'process' },
-      { id: 4, action: 'error' }
-    ]);
-    
-    let errorCount = 0;
-    let successCount = 0;
-    let errorMessages = [];
-    
-    // Process all messages with a single pipeline that handles errors
-    const result = await client
-      .pipeline(queue)
-      .take(10)  // Take all messages
-      .process(async (message) => {
-        if (message.data.action === 'error') {
-          errorCount++;
-          errorMessages.push(message);
-          // Move to error queue
-          await client.push(errorQueue, {
-            error: `Failed processing message ${message.data.id}`,
-            message: message.data
-          });
-          // ACK as failed
-          await client.ack(message, false);
-          return { error: true, id: message.data.id };
-        }
-        successCount++;
-        return { success: true, id: message.data.id };
-      })
-      .execute();
-    
-    if (successCount !== 2) {
-      throw new Error(`Expected 2 success, got ${successCount}`);
-    }
-    
-    if (errorCount !== 2) {
-      throw new Error(`Expected 2 errors, got ${errorCount}`);
-    }
-    
-    // Verify error queue has messages
-    const errorQueueMessages = await client.takeSingleBatch(errorQueue, { batch: 10 });
-    if (errorQueueMessages.length !== 2) {
-      throw new Error(`Expected 2 messages in error queue, got ${errorQueueMessages.length}`);
-    }
-    
-    // Clean up
-    await client.ack(errorQueueMessages);
-    await client.queueDelete(queue);
-    await client.queueDelete(errorQueue);
-    passTest('Pipeline error handling works correctly');
-  } catch (error) {
-    failTest('Pipeline API - Error Handling', error.message || error);
-  }
-}
-
-/**
- * Test: Pipeline API - Auto Renewal
- */
-export async function testPipelineAutoRenewal(client) {
-  startTest('Pipeline API - Auto Renewal', 'advanced');
-  
-  try {
-    const queue = 'test-pipeline-renewal';
-    await client.queue(queue, { leaseTime: 5 }); // Short lease for testing
-    
-    await client.push(queue, { id: 1, data: 'Long task' });
-    
-    let renewalWorked = false;
-    
-    await client
-      .pipeline(queue)
-      .take(1)
-      .withAutoRenewal({ interval: 2000 }) // Renew every 2 seconds
-      .process(async (message) => {
-        // Simulate long task (8 seconds)
-        await sleep(8000);
-        renewalWorked = true; // Would fail without renewal
-        return { processed: true };
-      })
-      .execute();
-    
-    if (!renewalWorked) {
-      throw new Error('Auto-renewal did not work');
-    }
-    
-    await client.queueDelete(queue);
-    passTest('Pipeline auto-renewal works correctly');
-  } catch (error) {
-    failTest('Pipeline API - Auto Renewal', error);
-  }
-}
-
-/**
- * Test: Pipeline API - Parallel Processing
- */
-export async function testPipelineParallel(client) {
-  startTest('Pipeline API - Parallel Processing', 'advanced');
-  
-  try {
-    const queue = 'test-pipeline-parallel';
-    await client.queue(queue, { 
-      leaseTime: 30,
-      partitions: 5  // Multiple partitions for parallel processing
-    });
-    
-    // Push messages across partitions
-    const messages = [];
-    for (let i = 0; i < 60; i++) {  // Reduced from 100 to 60 for faster test
-      messages.push({
-        id: i,
-        partition: `p${i % 5}`,
-        data: `Message ${i}`
-      });
-    }
-    
-    for (let p = 0; p < 5; p++) {
-      const partitionMessages = messages.filter(m => m.partition === `p${p}`);
-      await client.push(`${queue}/p${p}`, partitionMessages);
-    }
-    
-    const startTime = Date.now();
-    
-    const result = await client
-      .pipeline(queue)
-      .take(20)
-      .withConcurrency(3) // 3 parallel workers
-      .process(async (message) => {
-        await sleep(100); // Simulate work
-        return { processed: message.data.id };
-      })
-      .repeat({ maxIterations: 10, continuous: false })
-      .execute();
-    
-    const duration = Date.now() - startTime;
-    
-    // With 3 workers and partitions, we should process at least 36 messages (3 workers * 12 messages each)
-    if (result.totalProcessed < 36) {
-      throw new Error(`Expected at least 36 messages processed, got ${result.totalProcessed}`);
-    }
-    
-    if (result.summary.workersUtilized < 2) {
-      throw new Error(`Expected at least 2 workers utilized, got ${result.summary.workersUtilized}`);
-    }
-    
-    log(`Processed ${result.totalProcessed} messages in ${duration}ms with ${result.summary.workersUtilized} workers`);
-    
-    await client.queueDelete(queue);
-    passTest('Pipeline parallel processing works correctly');
-  } catch (error) {
-    failTest('Pipeline API - Parallel Processing', error.message || error);
-  }
-}
-
-/**
- * Test: Pipeline API - Concurrency Race Condition (Regression Test)
- * This test specifically checks for the race condition bug where multiple workers
- * would overwrite shared instance variables, causing ACK to be called with 0 messages.
- */
-export async function testPipelineConcurrencyRaceCondition(client) {
-  startTest('Pipeline API - Concurrency Race Condition (Regression)', 'advanced');
-  
-  try {
-    const queue = 'test-pipeline-race-condition';
-    await client.queue(queue, { 
-      leaseTime: 30,
-      partitions: 3
-    });
-    
-    // Push messages that will be processed by multiple workers
-    const messages = [];
-    for (let i = 0; i < 20; i++) {
-      messages.push({
-        id: i,
-        data: `Race condition test message ${i}`,
-        partition: `p${i % 3}`
-      });
-    }
-    
-    // Push to different partitions to ensure parallel processing
-    for (let p = 0; p < 3; p++) {
-      const partitionMessages = messages.filter(m => m.partition === `p${p}`);
-      await client.push(`${queue}/p${p}`, partitionMessages);
-    }
-    
-    let processedMessages = [];
-    let ackCallCount = 0;
-    let totalAckedMessages = 0;
-    
-    // Patch the client's ack method to track calls
-    const originalAck = client.ack.bind(client);
-    client.ack = async function(messages, status, context) {
-      ackCallCount++;
-      const messageCount = Array.isArray(messages) ? messages.length : 1;
-      totalAckedMessages += messageCount;
-      
-      // This is the critical check - if the race condition exists,
-      // we'll see ACK calls with 0 messages
-      if (messageCount === 0) {
-        throw new Error(`RACE CONDITION DETECTED: ACK called with 0 messages (call #${ackCallCount})`);
-      }
-      
-      log(`ACK call #${ackCallCount}: ${messageCount} messages`);
-      return await originalAck(messages, status, context);
-    };
-    
-    try {
-      const result = await client
-        .pipeline(queue)
-        .take(5)  // Take small batches to increase chance of race condition
-        .withConcurrency(4)  // High concurrency to trigger race condition
-        .processBatch(async (msgs) => {
-          // Simulate some processing time to increase race condition window
-          await sleep(50 + Math.random() * 100);
-          
-          processedMessages.push(...msgs.map(m => m.data.id));
-          log(`Worker processed batch of ${msgs.length} messages: [${msgs.map(m => m.data.id).join(', ')}]`);
-          
-          return msgs;
-        })
-        .repeat({ maxIterations: 8, continuous: false })
-        .execute();
-      
-      // Verify results
-      if (result.totalProcessed === 0) {
-        throw new Error('No messages were processed');
-      }
-      
-      if (ackCallCount === 0) {
-        throw new Error('No ACK calls were made');
-      }
-      
-      if (totalAckedMessages !== result.totalProcessed) {
-        throw new Error(`ACK count mismatch: processed ${result.totalProcessed}, ACKed ${totalAckedMessages}`);
-      }
-      
-      // Verify no duplicate processing (another symptom of race conditions)
-      const uniqueProcessed = [...new Set(processedMessages)];
-      if (uniqueProcessed.length !== processedMessages.length) {
-        log(`Duplicate processing detected: ${processedMessages.length} total, ${uniqueProcessed.length} unique`, 'warning');
-      }
-      
-      log(`Successfully processed ${result.totalProcessed} messages with ${ackCallCount} ACK calls`);
-      log(`Workers utilized: ${result.summary.workersUtilized}`);
-      
-    } finally {
-      // Restore original ack method
-      client.ack = originalAck;
-    }
-    
-    await client.queueDelete(queue);
-    passTest('Pipeline concurrency race condition test passed - no race condition detected');
-  } catch (error) {
-    failTest('Pipeline API - Concurrency Race Condition', error.message || error);
-  }
-}
-
-/**
- * Test: Pipeline API - Continuous Mode
- */
-export async function testPipelineContinuous(client) {
-  startTest('Pipeline API - Continuous Mode', 'advanced');
-  
-  try {
-    const queue = 'test-pipeline-continuous';
-    await client.queue(queue, { leaseTime: 30 });
-    
-    let processedCount = 0;
-    
-    // Create a timeout promise to prevent hanging
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => reject(new Error('Test timeout after 10 seconds')), 10000);
-    });
-    
-    // Start continuous processing
-    const pipelinePromise = client
-      .pipeline(queue)
-      .take(1)  // Take 1 message at a time
-      .process(async (message) => {
-        processedCount++;
-        return { processed: message.data.id };
-      })
-      .repeat({ 
-        continuous: true,  // Keep running
-        maxIterations: 5,  // But stop after 5 iterations
-        waitOnEmpty: 500   // Wait 500ms when no messages
-      })
-      .execute();
-    
-    // Push messages while pipeline is running
-    await sleep(100);
-    await client.push(queue, { id: 1, data: 'Message 1' });
-    
-    await sleep(1000);
-    await client.push(queue, { id: 2, data: 'Message 2' });
-    
-    await sleep(1000);
-    await client.push(queue, { id: 3, data: 'Message 3' });
-    
-    // Wait for pipeline to complete (with timeout)
-    const result = await Promise.race([pipelinePromise, timeoutPromise]);
-    
-    if (processedCount !== 3) {
-      throw new Error(`Expected 3 messages processed in continuous mode, got ${processedCount}`);
-    }
-    
-    await client.queueDelete(queue);
-    passTest('Pipeline continuous mode works correctly');
-  } catch (error) {
-    // Clean up on error
-    try {
-      await client.queueDelete('test-pipeline-continuous');
-    } catch (e) {
-      // Ignore cleanup errors
-    }
-    
-    if (error.message.includes('timeout')) {
-      // Skip this test if it times out
-      passTest('Pipeline continuous mode test skipped (timeout)');
-    } else {
-      failTest('Pipeline API - Continuous Mode', error);
-    }
-  }
-}
-
-/**
- * Test: Transaction API
- */
-export async function testTransactionAPI(client) {
-  startTest('Transaction API', 'advanced');
-  
-  try {
-    const inputQueue = 'test-tx-input';
-    const outputQueue = 'test-tx-output';
-    
-    await client.queue(inputQueue, { leaseTime: 30 });
-    await client.queue(outputQueue, { leaseTime: 30 });
-    
-    // Push test messages
-    await client.push(inputQueue, [
-      { id: 1, data: 'Process me' },
-      { id: 2, data: 'Transform me' }
-    ]);
-    
-    // Take messages
-    const messages = await client.takeSingleBatch(inputQueue, { batch: 2 });
-    
-    if (messages.length !== 2) {
-      throw new Error(`Expected 2 messages, got ${messages.length}`);
-    }
-    
-    // Process and use transaction API
-    const processed = messages.map(m => ({
-      originalId: m.data.id,
-      processed: true,
-      timestamp: Date.now()
-    }));
-    
-    // Execute atomic transaction
-    await client.transaction()
-      .ack(messages)                    // ACK input messages
-      .push(outputQueue, processed)     // Push to output
-      .commit();
-    
-    // Verify output queue has processed messages
-    const outputMessages = await client.takeSingleBatch(outputQueue, { batch: 10 });
-    
-    if (outputMessages.length !== 2) {
-      throw new Error(`Expected 2 messages in output queue, got ${outputMessages.length}`);
-    }
-    
-    if (!outputMessages[0].data.processed) {
-      throw new Error('Output message not marked as processed');
-    }
-    
-    await client.queueDelete(inputQueue);
-    await client.queueDelete(outputQueue);
-    passTest('Transaction API works correctly');
-  } catch (error) {
-    failTest('Transaction API', error);
-  }
-}
-
-/**
- * Test: Pipeline with Atomic Operations
- */
-export async function testPipelineAtomic(client) {
-  startTest('Pipeline API - Atomic Operations', 'advanced');
-  
-  try {
-    const inputQueue = 'test-pipeline-atomic-input';
-    const outputQueue = 'test-pipeline-atomic-output';
-    const auditQueue = 'test-pipeline-atomic-audit';
-    
-    await client.queue(inputQueue, { leaseTime: 30 });
-    await client.queue(outputQueue, { leaseTime: 30 });
-    await client.queue(auditQueue, { leaseTime: 30 });
-    
-    // Push messages
-    await client.push(inputQueue, [
-      { id: 1, value: 10 },
-      { id: 2, value: 20 },
-      { id: 3, value: 30 }
-    ]);
-    
-    // Process with atomic operations
-    await client
-      .pipeline(inputQueue)
-      .take(5)
-      .process(async (message) => {
-        // Transform the message
-        return {
-          originalId: message.data.id,
-          doubledValue: message.data.value * 2,
-          processedAt: new Date().toISOString()
-        };
-      })
-      .atomically((tx, originalMessages, processedMessages) => {
-        // These operations happen atomically
-        tx.ack(originalMessages)
-          .push(outputQueue, processedMessages)
-          .push(auditQueue, {
-            timestamp: Date.now(),
-            count: processedMessages.length,
-            ids: processedMessages.map(m => m.originalId)
-          });
-      })
-      .execute();
-    
-    // Verify output
-    const outputMessages = await client.takeSingleBatch(outputQueue, { batch: 10 });
-    if (outputMessages.length !== 3) {
-      throw new Error(`Expected 3 messages in output, got ${outputMessages.length}`);
-    }
-    
-    // Verify audit
-    const auditMessages = await client.takeSingleBatch(auditQueue, { batch: 10 });
-    if (auditMessages.length !== 1) {
-      throw new Error(`Expected 1 audit message, got ${auditMessages.length}`);
-    }
-    
-    if (auditMessages[0].data.count !== 3) {
-      throw new Error(`Audit message has wrong count: ${auditMessages[0].data.count}`);
-    }
-    
-    await client.queueDelete(inputQueue);
-    await client.queueDelete(outputQueue);
-    await client.queueDelete(auditQueue);
-    passTest('Pipeline atomic operations work correctly');
-  } catch (error) {
-    failTest('Pipeline API - Atomic Operations', error);
-  }
-}
-
-/**
- * Test: Manual Lease Renewal
- */
-export async function testManualLeaseRenewal(client) {
-  startTest('Manual Lease Renewal', 'advanced');
-  
-  try {
-    const queue = 'test-manual-renewal';
-    await client.queue(queue, { leaseTime: 5 }); // Short lease
-    
-    await client.push(queue, { id: 1, data: 'Long task' });
-    
-    // Take message
-    const messages = await client.takeSingleBatch(queue, { batch: 1 });
-    const message = messages[0];
-    
-    if (!message.leaseId) {
-      throw new Error('Message does not have leaseId');
-    }
-    
-    // Test single message renewal
-    const result1 = await client.renewLease(message);
-    if (!result1.success) {
-      throw new Error('Failed to renew lease for message');
-    }
-    
-    // Test renewal by lease ID
-    const result2 = await client.renewLease(message.leaseId);
-    if (!result2.success) {
-      throw new Error('Failed to renew lease by ID');
-    }
-    
-    // ACK the first message before testing batch
-    await client.ack(message);
-    
-    // Test batch renewal
-    await client.push(queue, [
-      { id: 2, data: 'Message 2' },
-      { id: 3, data: 'Message 3' }
-    ]);
-    
-    const batch = await client.takeSingleBatch(queue, { batch: 2 });
-    
-    if (batch.length !== 2) {
-      throw new Error(`Expected 2 messages in batch, got ${batch.length}`);
-    }
-    
-    const results = await client.renewLease(batch);
-    
-    if (!Array.isArray(results) || results.length !== 2) {
-      throw new Error(`Expected array of 2 results, got ${results}`);
-    }
-    
-    const allSuccess = results.every(r => r.success);
-    if (!allSuccess) {
-      throw new Error('Not all batch renewals succeeded');
-    }
-    
-    // Clean up - ACK remaining messages
-    await client.ack(batch);
-    
-    await client.queueDelete(queue);
-    passTest('Manual lease renewal works correctly');
-  } catch (error) {
-    failTest('Manual Lease Renewal', error.message || error);
-  }
-}
-
-/**
- * Test: Lease Validation
- */
-export async function testLeaseValidation(client) {
-  startTest('Lease Validation', 'advanced');
-  
-  try {
-    const queue = 'test-lease-validation';
-    await client.queue(queue, { leaseTime: 30 });
-    
-    await client.push(queue, { id: 1, data: 'Test message' });
-    
-    // Take message to get lease
-    const messages = await client.takeSingleBatch(queue, { batch: 1 });
-    const message = messages[0];
-    const validLeaseId = message.leaseId;
-    
-    // Try to ACK with valid lease (should succeed)
-    await client.ack(message);
-    
-    // Push another message
-    await client.push(queue, { id: 2, data: 'Another message' });
-    
-    // Take it
-    const messages2 = await client.takeSingleBatch(queue, { batch: 1 });
-    const message2 = messages2[0];
-    
-    // Corrupt the lease ID
-    message2.leaseId = 'invalid-lease-id-12345';
-    
-    // Try to ACK with invalid lease (should fail)
-    let invalidAckFailed = false;
-    try {
-      await client.ack(message2);
-    } catch (error) {
-      invalidAckFailed = true;
-    }
-    
-    if (!invalidAckFailed) {
-      throw new Error('ACK with invalid lease should have failed');
-    }
-    
-    await client.queueDelete(queue);
-    passTest('Lease validation works correctly');
-  } catch (error) {
-    failTest('Lease Validation', error);
-  }
-}
-
-/**
- * Test: Complex Pipeline Workflow
- */
-export async function testComplexPipelineWorkflow(client) {
-  startTest('Complex Pipeline Workflow', 'advanced');
-  
-  try {
-    const rawQueue = 'test-workflow-raw';
-    const validQueue = 'test-workflow-valid';
-    const invalidQueue = 'test-workflow-invalid';
-    const processedQueue = 'test-workflow-processed';
-    
-    // Setup queues
-    await client.queue(rawQueue, { leaseTime: 30 });
-    await client.queue(validQueue, { leaseTime: 30 });
-    await client.queue(invalidQueue, { leaseTime: 30 });
-    await client.queue(processedQueue, { leaseTime: 30 });
-    
-    // Push mixed messages
-    await client.push(rawQueue, [
-      { id: 1, value: 10, valid: true },
-      { id: 2, value: -5, valid: false },
-      { id: 3, value: 20, valid: true },
-      { id: 4, value: 0, valid: false },
-      { id: 5, value: 15, valid: true }
-    ]);
-    
-    // Stage 1: Validation pipeline
-    await client
-      .pipeline(rawQueue)
-      .take(10)
-      .processBatch(async (messages) => {
-        const valid = messages.filter(m => m.data.valid);
-        const invalid = messages.filter(m => !m.data.valid);
-        return { valid, invalid };
-      })
-      .atomically((tx, original, result) => {
-        tx.ack(original)
-          .push(validQueue, result.valid.map(m => m.data))
-          .push(invalidQueue, result.invalid.map(m => m.data));
-      })
-      .execute();
-    
-    // Stage 2: Processing pipeline
-    await client
-      .pipeline(validQueue)
-      .take(10)
-      .process(async (message) => {
-        return {
-          id: message.data.id,
-          originalValue: message.data.value,
-          processedValue: message.data.value * 2,
-          timestamp: Date.now()
-        };
-      })
-      .atomically((tx, original, processed) => {
-        tx.ack(original)
-          .push(processedQueue, processed);
-      })
-      .execute();
-    
-    // Verify results
-    const processed = await client.takeSingleBatch(processedQueue, { batch: 10 });
-    const invalid = await client.takeSingleBatch(invalidQueue, { batch: 10 });
-    
-    if (processed.length !== 3) {
-      throw new Error(`Expected 3 processed messages, got ${processed.length}`);
-    }
-    
-    if (invalid.length !== 2) {
-      throw new Error(`Expected 2 invalid messages, got ${invalid.length}`);
-    }
-    
-    // Verify processing
-    const processedValues = processed.map(m => m.data.processedValue).sort((a, b) => a - b);
-    const expectedValues = [20, 30, 40]; // 10*2, 15*2, 20*2
-    
-    if (JSON.stringify(processedValues) !== JSON.stringify(expectedValues)) {
-      throw new Error(`Processed values mismatch: ${processedValues} vs ${expectedValues}`);
-    }
-    
-    // Clean up
-    await client.ack(processed);
-    await client.ack(invalid);
-    await client.queueDelete(rawQueue);
-    await client.queueDelete(validQueue);
-    await client.queueDelete(invalidQueue);
-    await client.queueDelete(processedQueue);
-    
-    passTest('Complex pipeline workflow works correctly');
-  } catch (error) {
-    failTest('Complex Pipeline Workflow', error);
-  }
-}
-
-/**
- * Run all advanced client tests
- */
-export async function runAdvancedClientTests(client) {
-  log('🚀 Starting Advanced Client Feature Tests', 'info');
-  
-  await testPipelineBasic(client);
-  await testPipelineErrorHandling(client);
-  await testPipelineAutoRenewal(client);
-  await testPipelineParallel(client);
-  await testPipelineContinuous(client);
-  await testTransactionAPI(client);
-  await testPipelineAtomic(client);
-  await testManualLeaseRenewal(client);
-  await testLeaseValidation(client);
-  await testComplexPipelineWorkflow(client);
-  
-  log('✅ Advanced Client Feature Tests completed', 'info');
-}