queen-mq 0.3.0 → 0.4.0

package/client-js/test/edge-case-tests.js

@@ -1,562 +0,0 @@
-/**
- * Edge Case Tests for Queen Message Queue
- * Tests: Empty payloads, large payloads, concurrent operations, retry limits, lease expiration, security
- */
-
-import crypto from 'crypto';
-import { startTest, passTest, failTest, sleep, dbPool, getMessageCount, log } from './utils.js';
-
-/**
- * Test: Empty and null payloads
- */
-export async function testEmptyAndNullPayloads(client) {
-  startTest('Empty and Null Payloads', 'edge');
-  
-  try {
-    const queue = 'edge-empty-payloads';
-    
-    // Configure queue
-    await client.queue(queue, {});
-    
-    // Test null payload
-    await client.push(queue, null);
-    
-    // Test empty object
-    await client.push(queue, {});
-    
-    // Test empty string
-    await client.push(queue, '');
-    
-    // Take and verify all messages
-    const messages = [];
-    for await (const msg of client.take(queue, { limit: 10 })) {
-      if (!msg) {
-        throw new Error('Received null/undefined message from take()');
-      }
-      if (!msg.transactionId) {
-        log(`Warning: Message has no transactionId: ${JSON.stringify(msg)}`, 'warning');
-        throw new Error('Message has no transactionId');
-      }
-      messages.push(msg);
-      await client.ack(msg);
-    }
-    
-    if (messages.length !== 3) {
-      throw new Error(`Expected 3 messages, got ${messages.length}`);
-    }
-    
-    // Verify payloads
-    const payloads = messages.map(m => m.data);
-    
-    // Check for null
-    if (payloads[0] !== null) {
-      throw new Error(`Expected null for first payload, got ${JSON.stringify(payloads[0])}`);
-    }
-    
-    // Empty object
-    if (typeof payloads[1] !== 'object' || Object.keys(payloads[1]).length !== 0) {
-      throw new Error(`Expected empty object, got ${JSON.stringify(payloads[1])}`);
-    }
-    
-    // Empty string
-    if (payloads[2] !== '') {
-      throw new Error(`Expected empty string, got ${JSON.stringify(payloads[2])}`);
-    }
-    
-    passTest('Empty and null payloads handled correctly');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Very large payloads
- */
-export async function testVeryLargePayloads(client) {
-  startTest('Very Large Payloads', 'edge');
-  
-  try {
-    const queue = 'edge-large-payloads';
-    
-    // Configure queue
-    await client.queue(queue, {});
-    
-    // Create a large payload (1MB of data)
-    const largeArray = new Array(10000).fill({
-      id: crypto.randomBytes(16).toString('hex'),
-      data: 'x'.repeat(100),
-      nested: {
-        field1: 'value1',
-        field2: 'value2',
-        field3: 'value3'
-      }
-    });
-    
-    const largePayload = {
-      array: largeArray,
-      metadata: {
-        size: JSON.stringify(largeArray).length,
-        timestamp: Date.now()
-      }
-    };
-    
-    // Push large message
-    await client.push(queue, largePayload);
-    
-    // Take and verify
-    let received = null;
-    for await (const msg of client.take(queue, { limit: 1, timeout: 20000 })) {
-      received = msg.data;
-      await client.ack(msg);
-    }
-
-    
-    if (!received || !received.array || received.array.length !== 10000) {
-      throw new Error('Large payload corrupted');
-    }
-    
-    passTest('Very large payloads handled correctly');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Concurrent push operations
- */
-export async function testConcurrentPushOperations(client) {
-  startTest('Concurrent Push Operations', 'edge');
-  
-  try {
-    const queue = 'edge-concurrent-push';
-    const concurrentPushes = 10;
-    const messagesPerPush = 5;
-    
-    // Configure queue
-    await client.queue(queue, {});
-    
-    // Create multiple push promises
-    const pushPromises = [];
-    for (let i = 0; i < concurrentPushes; i++) {
-      const messages = Array.from({ length: messagesPerPush }, (_, j) => ({
-        pushBatch: i,
-        messageIndex: j,
-        timestamp: Date.now()
-      }));
-      
-      pushPromises.push(client.push(queue, messages));
-    }
-    
-    // Execute all pushes concurrently
-    await Promise.all(pushPromises);
-    
-    // Verify total message count
-    const totalExpected = concurrentPushes * messagesPerPush;
-    const count = await getMessageCount(queue);
-    
-    if (count !== totalExpected) {
-      throw new Error(`Expected ${totalExpected} messages, got ${count}`);
-    }
-    
-    passTest(`${concurrentPushes} concurrent pushes completed successfully`);
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Retry limit exhaustion
- */
-export async function testRetryLimitExhaustion(client) {
-  startTest('Retry Limit Exhaustion', 'edge');
-  
-  try {
-    const queue = 'edge-retry-exhaustion';
-    
-    // Configure with low retry limit and DLQ
-    await client.queue(queue, {
-      retryLimit: 2,
-      leaseTime: 1, // Very short lease
-      dlqAfterMaxRetries: true
-    });
-    
-    // Push a message
-    await client.push(queue, { test: 'retry exhaustion' });
-    await sleep(100);
-    
-    // Take and fail multiple times (retryLimit is 2, so after 3 attempts it should be exhausted)
-    let attempts = 0;
-    for (let i = 0; i < 4; i++) { // Try up to 4 times to ensure we exhaust retries
-      let gotMessage = false;
-      for await (const msg of client.take(queue, { limit: 1 })) {
-        attempts++;
-        await client.ack(msg, false, { error: `Attempt ${attempts}` });
-        gotMessage = true;
-        log(`Attempt ${attempts}: Failed message`, 'info');
-      }
-      
-      if (!gotMessage) {
-        // No message available - it's been exhausted
-        log(`No message available after ${attempts} attempts`, 'info');
-        break;
-      }
-      
-      // Wait longer for lease to expire and retry to be processed
-      await sleep(2000);
-    }
-    
-    // Wait a bit more to ensure final state is processed
-    await sleep(500);
-    
-    // Try to take again - should get nothing
-    let finalGotMessage = false;
-    for await (const msg of client.take(queue, { limit: 1 })) {
-      finalGotMessage = true;
-      log('Unexpected: Got message in final check', 'warning');
-    }
-    
-    // If we still got a message, it means retry limit isn't working as expected
-    // But this might be acceptable behavior depending on implementation
-    if (finalGotMessage && attempts < 3) {
-      throw new Error('Message still available but not enough retry attempts');
-    }
-    
-    // If we got 3+ attempts and message is exhausted, test passes
-    if (!finalGotMessage && attempts >= 3) {
-      log(`Message exhausted after ${attempts} attempts`, 'success');
-    } else if (!finalGotMessage) {
-      log(`Message exhausted after ${attempts} attempts (may have been moved to DLQ)`, 'info');
-    } else {
-      // Message still available - might be in failed state but not yet exhausted
-      log(`Message still processing after ${attempts} attempts (retry logic may vary)`, 'warning');
-    }
-    
-    log('Message no longer available after retry exhaustion', 'info');
-    passTest('Retry limit exhaustion handled correctly');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Lease expiration and redelivery
- */
-export async function testLeaseExpiration(client) {
-  startTest('Lease Expiration and Redelivery', 'edge');
-  
-  try {
-    const queue = 'edge-lease-expiration';
-    
-    // Configure with short lease time
-    await client.queue(queue, {
-      leaseTime: 2 // 2 seconds
-    });
-    
-    // Push a message
-    await client.push(queue, { test: 'lease expiration' });
-    
-    // Take the message (acquires lease)
-    let firstTransactionId = null;
-    for await (const msg of client.take(queue, { limit: 1 })) {
-      firstTransactionId = msg.transactionId;
-      // Don't acknowledge - let lease expire
-    }
-    
-    if (!firstTransactionId) {
-      throw new Error('Failed to take message');
-    }
-    
-    // Wait for lease to expire (2 seconds + buffer)
-    await sleep(2500);
-    
-    // Check partition lease status in database
-    const statusCheck = await dbPool.query(`
-      SELECT pc.lease_expires_at,
-             CASE 
-               WHEN (m.created_at, m.id) <= (pc.last_consumed_created_at, COALESCE(pc.last_consumed_id, '00000000-0000-0000-0000-000000000000'::uuid)) 
-               THEN 'completed'
-               WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() 
-               THEN 'processing'
-               ELSE 'pending'
-             END as status
-      FROM queen.messages m
-      LEFT JOIN queen.partition_consumers pc ON pc.partition_id = m.partition_id AND pc.consumer_group = '__QUEUE_MODE__'
-      WHERE m.transaction_id = $1
-    `, [firstTransactionId]);
-    
-    if (statusCheck.rows.length > 0) {
-      log(`Message status before second take: ${statusCheck.rows[0].status}, lease expires: ${statusCheck.rows[0].lease_expires_at}`, 'info');
-    }
-    
-    // Try to take again - should get the same message (reclaim happens in take)
-    let secondTransactionId = null;
-    for await (const msg of client.take(queue, { limit: 1 })) {
-      secondTransactionId = msg.transactionId;
-      await client.ack(msg);
-    }
-    
-    if (!secondTransactionId) {
-      throw new Error('Message not redelivered after lease expiration');
-    }
-    
-    // Transaction ID should be the same - it's the same message being redelivered
-    if (firstTransactionId !== secondTransactionId) {
-      throw new Error('Transaction ID changed unexpectedly - should be same message');
-    }
-    
-    passTest('Lease expiration and redelivery works correctly');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: SQL injection prevention
- */
-export async function testSQLInjectionPrevention(client) {
-  startTest('SQL Injection Prevention', 'edge');
-  
-  try {
-    const queue = 'edge-sql-test';
-    
-    // Configure queue for SQL injection tests
-    await client.queue(queue, {});
-    
-    // Try various SQL injection attempts
-    const injectionAttempts = [
-      "'; DROP TABLE queen.messages; --",
-      "1' OR '1'='1",
-      "admin'--",
-      "' UNION SELECT * FROM queen.queues--",
-      "'; UPDATE queen.messages SET payload = 'hacked'--"
-    ];
-    
-    for (const attempt of injectionAttempts) {
-      // Try injection in queue name
-      try {
-        await client.push(attempt, { test: 'sql injection' });
-      } catch (error) {
-        // Expected to fail or be sanitized
-      }
-      
-      // Try injection in partition name
-      try {
-        await client.push(`${queue}/${attempt}`, { test: 'sql injection' });
-      } catch (error) {
-        // Expected to fail or be sanitized
-      }
-      
-      // Try injection in payload
-      await client.push(queue, {
-        injection: attempt,
-        nested: {
-          attempt: attempt
-        }
-      });
-    }
-    
-    // Verify database is still intact
-    const tableCheck = await dbPool.query(`
-      SELECT COUNT(*) as count 
-      FROM information_schema.tables 
-      WHERE table_schema = 'queen' AND table_name = 'messages'
-    `);
-    
-    if (tableCheck.rows[0].count !== '1') {
-      throw new Error('Database structure compromised!');
-    }
-    
-    passTest('SQL injection attempts properly prevented');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Concurrent take operations
- */
-export async function testConcurrentTakeOperations(client) {
-  startTest('Concurrent Take Operations', 'edge');
-  
-  try {
-    const queue = 'edge-concurrent-take';
-    const totalMessages = 50;
-    const concurrentTakes = 10;
-    
-    // Configure queue
-    await client.queue(queue, {});
-    
-    // Push messages
-    const messages = Array.from({ length: totalMessages }, (_, i) => ({
-      id: i,
-      data: `Message ${i}`
-    }));
-    
-    await client.push(queue, messages);
-    await sleep(200);
-    
-    // Verify messages were pushed
-    const pushCheck = await getMessageCount(queue);
-    if (pushCheck !== totalMessages) {
-      throw new Error(`Push failed: expected ${totalMessages}, got ${pushCheck}`);
-    }
-    
-    // Create multiple take promises
-    const takePromises = [];
-    const batchSize = 5;
-    
-    for (let i = 0; i < concurrentTakes; i++) {
-      const takePromise = (async () => {
-        const takenMessages = [];
-        for await (const msg of client.take(queue, { limit: batchSize, batch: batchSize })) {
-          takenMessages.push(msg);
-          await client.ack(msg);
-        }
-        return takenMessages;
-      })();
-      
-      takePromises.push(takePromise);
-    }
-    
-    // Execute all takes concurrently
-    const results = await Promise.all(takePromises);
-    
-    // Collect all messages
-    const allMessages = results.flat();
-    
-    // Verify no duplicate messages
-    const transactionIds = allMessages.map(m => m.transactionId);
-    const uniqueIds = new Set(transactionIds);
-    
-    if (uniqueIds.size !== allMessages.length) {
-      throw new Error('Duplicate messages detected in concurrent takes');
-    }
-    
-    log(`Concurrent takes: Got ${allMessages.length}/${totalMessages} messages`, 'info');
-    
-    // If we didn't get all messages, it's acceptable due to partition locking
-    if (allMessages.length < totalMessages) {
-      log(`Note: Some messages may still be locked in partitions`, 'warning');
-      passTest(`${concurrentTakes} concurrent takes completed (${allMessages.length}/${totalMessages} messages, no duplicates)`);
-    } else {
-      passTest(`${concurrentTakes} concurrent takes handled correctly`);
-    }
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Many consumer groups on same queue
- */
-export async function testManyConsumerGroups(client) {
-  startTest('Many Consumer Groups on Same Queue', 'edge');
-  
-  try {
-    const queue = 'edge-many-groups';
-    const numGroups = 10;
-    const numMessages = 5;
-    
-    // Configure queue
-    await client.queue(queue, {});
-    
-    // Push messages
-    const messages = Array.from({ length: numMessages }, (_, i) => ({
-      id: i,
-      data: `Broadcast message ${i}`
-    }));
-    
-    await client.push(queue, messages);
-    await sleep(100);
-    
-    // Each consumer group should get all messages
-    const groupResults = [];
-    for (let g = 0; g < numGroups; g++) {
-      const groupName = `group-${g}`;
-      const groupMessages = [];
-      
-      for await (const msg of client.take(`${queue}@${groupName}`, { limit: numMessages })) {
-        groupMessages.push(msg);
-        await client.ack(msg, true, { group: groupName });
-      }
-      
-      if (groupMessages.length !== numMessages) {
-        throw new Error(`Group ${g} didn't receive all messages (got ${groupMessages.length})`);
-      }
-      
-      groupResults.push(groupMessages);
-    }
-    
-    // Verify all groups got the same messages
-    const firstGroupIds = groupResults[0].map(m => m.data.id).sort();
-    
-    for (let g = 1; g < numGroups; g++) {
-      const groupIds = groupResults[g].map(m => m.data.id).sort();
-      if (JSON.stringify(groupIds) !== JSON.stringify(firstGroupIds)) {
-        throw new Error(`Group ${g} got different messages`);
-      }
-    }
-    
-    passTest(`${numGroups} consumer groups all received all messages`);
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: XSS prevention in payloads
- */
-export async function testXSSPrevention(client) {
-  startTest('XSS Prevention in Payloads', 'edge');
-  
-  try {
-    const queue = 'edge-xss-test';
-    
-    // Configure queue
-    await client.queue(queue, {});
-    
-    // Various XSS attempts
-    const xssPayloads = [
-      '<script>alert("XSS")</script>',
-      '<img src=x onerror=alert("XSS")>',
-      'javascript:alert("XSS")',
-      '<svg onload=alert("XSS")>',
-      '"><script>alert("XSS")</script>'
-    ];
-    
-    // Push messages with XSS attempts
-    const messages = xssPayloads.map(xss => ({
-      userInput: xss,
-      html: xss,
-      nested: {
-        script: xss
-      }
-    }));
-    
-    await client.push(queue, messages);
-    
-    // Take and verify payloads are intact (not sanitized at storage level)
-    const received = [];
-    for await (const msg of client.take(queue, { limit: xssPayloads.length })) {
-      received.push(msg);
-      await client.ack(msg);
-    }
-    
-    if (received.length !== xssPayloads.length) {
-      throw new Error('Failed to retrieve XSS test messages');
-    }
-    
-    // Verify payloads are stored as-is (sanitization should happen at display)
-    for (let i = 0; i < received.length; i++) {
-      const msg = received[i];
-      if (msg.data.userInput !== xssPayloads[i]) {
-        throw new Error('Payload was modified during storage');
-      }
-    }
-    
-    passTest('XSS payloads handled safely (stored as-is for application-level handling)');
-  } catch (error) {
-    failTest(error);
-  }
-}
-