queen-mq 0.3.1 → 0.6.3

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

@@ -1,637 +0,0 @@
-/**
- * Enterprise Feature Tests for Queen Message Queue
- * Tests: Encryption, retention policies, message eviction, combined enterprise features
- */
-
-import { startTest, passTest, failTest, sleep, dbPool, getMessageCount, log } from './utils.js';
-
-/**
- * Test: Message Encryption
- */
-export async function testMessageEncryption(client) {
-  startTest('Message Encryption', 'enterprise');
-  
-  try {
-    // Check if encryption is enabled
-    const encryptionKey = process.env.QUEEN_ENCRYPTION_KEY;
-    if (!encryptionKey) {
-      log('Skipping encryption test - QUEEN_ENCRYPTION_KEY not set', 'warning');
-      passTest('Skipped - encryption key not configured');
-      return;
-    }
-    
-    const queue = 'test-encryption-queue';
-    
-    // Configure queue with encryption
-    await client.queue(queue, {
-      encryptionEnabled: true
-    });
-    
-    // Verify encryption is enabled in database
-    const queueResult = await dbPool.query(`
-      SELECT encryption_enabled
-      FROM queen.queues
-      WHERE name = $1
-    `, [queue]);
-    
-    if (!queueResult.rows[0]?.encryption_enabled) {
-      throw new Error('Encryption not enabled on queue');
-    }
-    
-    // Push sensitive data
-    const sensitiveData = {
-      creditCard: '4111111111111111',
-      ssn: '123-45-6789',
-      password: 'super-secret-password',
-      timestamp: Date.now()
-    };
-    
-    await client.push(queue, sensitiveData);
-    await sleep(100);
-    
-    // Check that the message is encrypted in database
-    const dbResult = await dbPool.query(`
-      SELECT m.payload, m.is_encrypted
-      FROM queen.messages m
-      JOIN queen.partitions p ON m.partition_id = p.id
-      JOIN queen.queues q ON p.queue_id = q.id
-      WHERE q.name = $1
-      ORDER BY m.created_at DESC
-      LIMIT 1
-    `, [queue]);
-    
-    if (!dbResult.rows[0]?.is_encrypted) {
-      throw new Error('Message not marked as encrypted in database');
-    }
-    
-    const storedData = dbResult.rows[0].payload;
-    
-    // Verify the stored data is encrypted
-    if (!storedData.encrypted || !storedData.iv || !storedData.authTag) {
-      throw new Error('Message not properly encrypted in database');
-    }
-    
-    // Verify the stored data doesn't contain plain text sensitive info
-    const storedStr = JSON.stringify(storedData);
-    if (storedStr.includes('4111111111111111') || 
-        storedStr.includes('123-45-6789') || 
-        storedStr.includes('super-secret-password')) {
-      throw new Error('Sensitive data found in plain text - encryption failed!');
-    }
-    
-    // Take the message (should be decrypted automatically)
-    let decryptedData = null;
-    for await (const msg of client.take(queue, { limit: 1 })) {
-      decryptedData = msg.data;
-      await client.ack(msg);
-    }
-    
-    if (!decryptedData) {
-      throw new Error('Failed to take encrypted message');
-    }
-    
-    // Verify decrypted data matches original
-    if (decryptedData.creditCard !== sensitiveData.creditCard ||
-        decryptedData.ssn !== sensitiveData.ssn ||
-        decryptedData.password !== sensitiveData.password) {
-      throw new Error('Decrypted data does not match original');
-    }
-    
-    passTest('Message encryption/decryption works correctly');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Retention Policy - Pending Messages
- */
-export async function testRetentionPendingMessages(client) {
-  startTest('Retention Policy - Pending Messages', 'enterprise');
-  
-  try {
-    const queue = 'test-retention-pending';
-    
-    // Configure queue with retention for pending messages
-    await client.queue(queue, {
-      retentionEnabled: true,
-      retentionSeconds: 3 // 3 seconds retention for pending messages
-    });
-    
-    // Push messages
-    await client.push(queue, [
-      { message: 'Message to be retained', order: 1 },
-      { message: 'Another message to be retained', order: 2 }
-    ]);
-    
-    // Verify messages are in database
-    const initialCount = await getMessageCount(queue, 'Default');
-    if (initialCount !== 2) {
-      throw new Error(`Expected 2 messages, got ${initialCount}`);
-    }
-    
-    // Wait for retention period
-    log('Waiting for retention period (3 seconds)...', 'info');
-    await sleep(3500);
-    
-    // Trigger retention by attempting a take
-    for await (const msg of client.take(queue, { limit: 1 })) {
-      // Should get nothing or expired messages
-    }
-    
-    // Check if messages were retained
-    const finalCount = await getMessageCount(queue, 'Default');
-    log(`Messages after retention period: ${finalCount} (from ${initialCount})`, 'info');
-    
-    // Check retention history
-    const retentionHistory = await dbPool.query(`
-      SELECT rh.messages_deleted, rh.retention_type
-      FROM queen.retention_history rh
-      JOIN queen.partitions p ON rh.partition_id = p.id
-      JOIN queen.queues q ON p.queue_id = q.id
-      WHERE q.name = $1
-      ORDER BY rh.executed_at DESC
-      LIMIT 1
-    `, [queue]);
-    
-    if (retentionHistory.rows.length > 0) {
-      log(`Retention history: ${retentionHistory.rows[0].messages_deleted} messages deleted (${retentionHistory.rows[0].retention_type})`, 'info');
-    }
-    
-    passTest('Retention policy for pending messages configured successfully');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Message Eviction
- */
-export async function testMessageEviction(client) {
-  startTest('Message Eviction', 'enterprise');
-  
-  try {
-    const queue = 'test-eviction-queue';
-    
-    // Configure queue with max wait time
-    await client.queue(queue, {
-      maxWaitTimeSeconds: 3
-    });
-    
-    // Push message
-    await client.push(`${queue}/eviction-partition`, {
-      message: 'Message to be evicted',
-      timestamp: Date.now()
-    });
-    
-    // Verify message exists and is pending
-    const pendingCheck = await dbPool.query(`
-      SELECT m.id, m.created_at,
-             pc.last_consumed_id, pc.last_consumed_created_at,
-             dlq.id as dlq_id
-      FROM queen.messages m
-      JOIN queen.partitions p ON m.partition_id = p.id
-      JOIN queen.queues q ON p.queue_id = q.id
-      LEFT JOIN queen.partition_consumers pc ON pc.partition_id = p.id AND pc.consumer_group = '__QUEUE_MODE__'
-      LEFT JOIN queen.dead_letter_queue dlq ON dlq.message_id = m.id AND dlq.consumer_group = '__QUEUE_MODE__'
-      WHERE q.name = $1 AND p.name = 'eviction-partition'
-      ORDER BY m.created_at DESC
-      LIMIT 1
-    `, [queue]);
-    
-    if (pendingCheck.rows.length === 0) {
-      throw new Error('Message not found');
-    }
-    
-    // Derive status from cursor position
-    const msg = pendingCheck.rows[0];
-    const isDLQ = msg.dlq_id != null;
-    const isConsumed = msg.last_consumed_id && 
-                       ((msg.created_at < msg.last_consumed_created_at) || 
-                        (msg.created_at.getTime() === msg.last_consumed_created_at?.getTime() && msg.id <= msg.last_consumed_id));
-    const status = isDLQ ? 'dead_letter' : (isConsumed ? 'completed' : 'pending');
-    
-    if (status !== 'pending') {
-      throw new Error(`Message not in pending status, got: ${status}`);
-    }
-    
-    // Wait for max wait time to expire
-    log('Waiting for max wait time (3 seconds)...', 'info');
-    await sleep(3500);
-    
-    // Try to take (should trigger eviction)
-    let gotMessage = false;
-    for await (const msg of client.take(`${queue}/eviction-partition`, { limit: 1 })) {
-      gotMessage = true;
-    }
-    
-    // Check if message was evicted (moved to DLQ)
-    const evictionCheck = await dbPool.query(`
-      SELECT m.id, dlq.error_message,
-             CASE WHEN dlq.id IS NOT NULL THEN 'evicted' ELSE 'pending' END as status
-      FROM queen.messages m
-      JOIN queen.partitions p ON m.partition_id = p.id
-      JOIN queen.queues q ON p.queue_id = q.id
-      LEFT JOIN queen.dead_letter_queue dlq ON dlq.message_id = m.id AND dlq.consumer_group = '__QUEUE_MODE__'
-      WHERE q.name = $1 AND p.name = 'eviction-partition'
-      ORDER BY m.created_at DESC
-      LIMIT 1
-    `, [queue]);
-    
-    if (evictionCheck.rows.length > 0) {
-      const status = evictionCheck.rows[0].status;
-      const errorMsg = evictionCheck.rows[0].error_message;
-      
-      if (status === 'evicted') {
-        log(`Message evicted with reason: ${errorMsg}`, 'info');
-        passTest('Message eviction works correctly');
-      } else if (!gotMessage) {
-        log('Message may be evicted by background service', 'info');
-        passTest('Eviction configured successfully');
-      } else {
-        passTest('Eviction configuration accepted');
-      }
-    } else {
-      passTest('Message processed or evicted');
-    }
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Combined Enterprise Features
- */
-export async function testCombinedEnterpriseFeatures(client) {
-  startTest('Combined Enterprise Features', 'enterprise');
-  
-  try {
-    const queue = 'test-enterprise-combined';
-    const encryptionEnabled = !!process.env.QUEEN_ENCRYPTION_KEY;
-    
-    // Configure queue with all enterprise features
-    await client.queue(queue, {
-      // Core options
-      leaseTime: 300,
-      retryLimit: 3,
-      priority: 10,
-      
-      // Enterprise options
-      encryptionEnabled: encryptionEnabled,
-      retentionEnabled: true,
-      retentionSeconds: 60,
-      completedRetentionSeconds: 30,
-      partitionRetentionSeconds: 120
-    });
-    
-    // Also set max wait time on the queue
-    await dbPool.query(`
-      UPDATE queen.queues 
-      SET max_wait_time_seconds = 45
-      WHERE name = $1
-    `, [queue]);
-    
-    // Verify all configurations
-    const configCheck = await dbPool.query(`
-      SELECT 
-        q.encryption_enabled,
-        q.max_wait_time_seconds,
-        q.retention_enabled,
-        q.retention_seconds,
-        q.completed_retention_seconds,
-        q.lease_time,
-        q.retry_limit,
-        q.priority
-      FROM queen.queues q
-      WHERE q.name = $1
-    `, [queue]);
-    
-    if (configCheck.rows.length === 0) {
-      throw new Error('Configuration not found');
-    }
-    
-    const config = configCheck.rows[0];
-    
-    // Verify enterprise configurations
-    if (encryptionEnabled && config.encryption_enabled !== encryptionEnabled) {
-      throw new Error('Encryption not configured correctly');
-    }
-    
-    if (config.max_wait_time_seconds !== 45) {
-      throw new Error('Max wait time not configured correctly');
-    }
-    
-    if (!config.retention_enabled || 
-        config.retention_seconds !== 60 ||
-        config.completed_retention_seconds !== 30) {
-      throw new Error('Retention options not configured correctly');
-    }
-    
-    // Push a test message
-    await client.push(queue, {
-      message: 'Enterprise test message',
-      sensitive: 'confidential-data',
-      timestamp: Date.now()
-    });
-    
-    await sleep(100);
-    
-    // If encryption is enabled, verify message is encrypted in DB
-    if (encryptionEnabled) {
-      const encCheck = await dbPool.query(`
-        SELECT is_encrypted FROM queen.messages m
-        JOIN queen.partitions p ON m.partition_id = p.id
-        JOIN queen.queues q ON p.queue_id = q.id
-        WHERE q.name = $1
-        ORDER BY m.created_at DESC
-        LIMIT 1
-      `, [queue]);
-      
-      if (encCheck.rows[0] && !encCheck.rows[0].is_encrypted) {
-        throw new Error('Message not encrypted despite encryption being enabled');
-      }
-    }
-    
-    // Take and complete the message
-    for await (const msg of client.take(queue, { limit: 1 })) {
-      await client.ack(msg);
-    }
-    
-    passTest('All enterprise features can be configured together successfully');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Retention Policy - Completed Messages
- */
-export async function testRetentionCompletedMessages(client) {
-  startTest('Retention Policy - Completed Messages', 'enterprise');
-  
-  try {
-    const queue = 'test-retention-completed';
-    
-    // Configure queue with retention for completed messages
-    await client.queue(queue, {
-      retentionEnabled: true,
-      completedRetentionSeconds: 2 // 2 seconds retention for completed messages
-    });
-    
-    // Push messages
-    await client.push(queue, { message: 'Message to complete and retain' });
-    await sleep(100);
-    
-    // Take and complete the message
-    let transactionId;
-    for await (const msg of client.take(queue, { limit: 1 })) {
-      transactionId = msg.transactionId;
-      await client.ack(msg);
-    }
-    
-    if (!transactionId) {
-      throw new Error('Failed to take message for completion');
-    }
-    
-    // Verify message is marked as completed (cursor-based check using UUIDv7 ordering)
-    const statusCheck = await dbPool.query(`
-      SELECT 
-        m.id, m.created_at,
-        pc.last_consumed_id, pc.last_consumed_created_at,
-        CASE 
-          WHEN pc.last_consumed_id IS NOT NULL AND m.id <= pc.last_consumed_id
-          THEN 'completed'
-          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
-    `, [transactionId]);
-    
-    if (!statusCheck.rows[0] || statusCheck.rows[0].status !== 'completed') {
-      const row = statusCheck.rows[0];
-      throw new Error(
-        `Message not marked as completed.\n` +
-        `  Status: ${row?.status}\n` +
-        `  Message ID: ${row?.id}\n` +
-        `  Cursor ID: ${row?.last_consumed_id}\n` +
-        `  Has cursor: ${row?.last_consumed_id != null}`
-      );
-    }
-    
-    // Wait for retention period
-    log('Waiting for completed retention period (2 seconds)...', 'info');
-    await sleep(2500);
-    
-    // Trigger retention check
-    for await (const msg of client.take(queue, { limit: 1 })) {
-      // Should get nothing
-    }
-    
-    // Check if completed message still exists
-    const retainedCheck = await dbPool.query(`
-      SELECT m.id, 
-             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' 
-               ELSE 'pending' 
-             END as status,
-             pc.last_consumed_at as completed_at
-      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
-    `, [transactionId]);
-    
-    const messageExists = retainedCheck.rows.length > 0;
-    const isCompleted = retainedCheck.rows[0]?.status === 'completed';
-    
-    if (!messageExists) {
-      log('Message was deleted after retention period', 'info');
-    } else if (isCompleted) {
-      log('Message retained with completed status', 'info');
-    }
-    
-    passTest('Retention policy for completed messages works correctly');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Partition Retention
- */
-export async function testPartitionRetention(client) {
-  startTest('Partition Management', 'enterprise');
-  
-  try {
-    const queue = 'test-partition-management';
-    
-    // Configure queue
-    await client.queue(queue, {
-      retentionEnabled: false
-    });
-    
-    // Push a message to create Default partition
-    await client.push(queue, { message: 'Test message' });
-    
-    // Verify partition exists
-    const partitionCheck = await dbPool.query(`
-      SELECT p.id, p.last_activity
-      FROM queen.partitions p
-      JOIN queen.queues q ON p.queue_id = q.id
-      WHERE q.name = $1 AND p.name = 'Default'
-    `, [queue]);
-    
-    if (partitionCheck.rows.length === 0) {
-      throw new Error('Default partition not created');
-    }
-    
-    const partitionId = partitionCheck.rows[0].id;
-    log(`Partition created with ID: ${partitionId}`, 'info');
-    
-    // Push another message to update last_activity
-    await client.push(queue, { message: 'Another message' });
-    
-    // Take and complete the messages
-    for await (const msg of client.take(queue, { limit: 2 })) {
-      await client.ack(msg);
-    }
-    
-    // Check partition still exists
-    const stillExists = await dbPool.query(`
-      SELECT COUNT(*) as count FROM queen.partitions WHERE id = $1
-    `, [partitionId]);
-    
-    if (stillExists.rows[0].count === '0') {
-      throw new Error('Partition deleted too early');
-    }
-    
-    passTest('Partition management works correctly');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Consumer Encryption/Decryption
- */
-export async function testConsumerEncryption(client) {
-  startTest('Consumer Encryption/Decryption', 'enterprise');
-  
-  try {
-    // Check if encryption is enabled
-    const encryptionKey = process.env.QUEEN_ENCRYPTION_KEY;
-    if (!encryptionKey) {
-      log('Skipping consumer encryption test - QUEEN_ENCRYPTION_KEY not set', 'warning');
-      passTest('Skipped - encryption key not configured');
-      return;
-    }
-    
-    const queue = 'test-consumer-encryption';
-    
-    // Configure queue with encryption
-    await client.queue(queue, {
-      encryptionEnabled: true
-    });
-    
-    // Push sensitive data
-    const sensitiveData = {
-      creditCard: '4111111111111111',
-      ssn: '123-45-6789',
-      apiKey: 'sk_test_12345',
-      timestamp: Date.now()
-    };
-    
-    await client.push(queue, sensitiveData);
-    await sleep(100);
-    
-    // Take and verify decryption
-    let decryptedCorrectly = false;
-    for await (const msg of client.take(queue, { limit: 1 })) {
-      // Check if data is properly decrypted
-      if (msg.data && typeof msg.data === 'object') {
-        if (msg.data.encrypted || msg.data.iv || msg.data.authTag) {
-          throw new Error('Consumer received encrypted data instead of decrypted!');
-        }
-        if (msg.data.creditCard === sensitiveData.creditCard &&
-            msg.data.ssn === sensitiveData.ssn) {
-          decryptedCorrectly = true;
-        }
-      }
-      await client.ack(msg);
-    }
-    
-    if (!decryptedCorrectly) {
-      throw new Error('Decrypted data does not match original');
-    }
-    
-    passTest('Consumer receives properly decrypted messages');
-  } catch (error) {
-    failTest(error);
-  }
-}
-
-/**
- * Test: Enterprise Error Handling
- */
-export async function testEnterpriseErrorHandling(client) {
-  startTest('Enterprise Error Handling', 'enterprise');
-  
-  try {
-    let errorsCaught = 0;
-    
-    // Test 1: Invalid retention seconds
-    try {
-      await client.queue('test-enterprise-errors', {
-        retentionEnabled: true,
-        retentionSeconds: -10 // Invalid negative value
-      });
-      errorsCaught++;
-    } catch (error) {
-      errorsCaught++;
-    }
-    
-    // Test 2: Configure encryption without key (if key not set)
-    if (!process.env.QUEEN_ENCRYPTION_KEY) {
-      try {
-        await client.queue('test-enterprise-no-key', {
-          encryptionEnabled: true
-        });
-        
-        // Try to push encrypted message without key
-        await client.push('test-enterprise-no-key', {
-          message: 'Should fail without key'
-        });
-        
-        errorsCaught++;
-      } catch (error) {
-        errorsCaught++;
-      }
-    } else {
-      errorsCaught++; // Count as handled
-    }
-    
-    // Test 3: Invalid max wait time
-    try {
-      await dbPool.query(`
-        INSERT INTO queen.queues (name, max_wait_time_seconds) 
-        VALUES ('test-invalid-wait', -100)
-        ON CONFLICT (name) DO UPDATE SET max_wait_time_seconds = EXCLUDED.max_wait_time_seconds
-      `);
-      errorsCaught++;
-    } catch (error) {
-      errorsCaught++;
-    }
-    
-    if (errorsCaught >= 2) {
-      passTest(`Enterprise error handling works (${errorsCaught} scenarios handled)`);
-    } else {
-      throw new Error(`Only ${errorsCaught} error scenarios handled`);
-    }
-  } catch (error) {
-    failTest(error);
-  }
-}
-