queen-mq 0.12.0 → 0.12.2

package/test-v2/ai_lease_renewal.js

@@ -1,206 +0,0 @@
-/**
- * Lease Renewal Tests
- * Tests manual lease extension functionality
- */
-
-export async function testManualLeaseRenewal(client) {
-    const queue = await client.queue('test-queue-v2-manual-renewal')
-        .config({ leaseTime: 2 })
-        .create()
-    
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    await client.queue('test-queue-v2-manual-renewal')
-        .push([{ data: { test: 'renewal' } }])
-
-    const messages = await client.queue('test-queue-v2-manual-renewal')
-        .batch(1)
-        .wait(false)
-        .pop()
-
-    if (messages.length === 0) {
-        return { success: false, message: 'No message to test' }
-    }
-
-    const message = messages[0]
-
-    // Wait 1 second
-    await new Promise(resolve => setTimeout(resolve, 1000))
-
-    // Renew the lease
-    const renewResult = await client.renew(message)
-
-    if (!renewResult.success) {
-        return { success: false, message: 'Lease renewal failed' }
-    }
-
-    // Wait another 2 seconds (total 3 seconds, original lease was 2 seconds)
-    await new Promise(resolve => setTimeout(resolve, 2000))
-
-    // Try to ack - should succeed because we renewed
-    const ackResult = await client.ack(message, true)
-
-    return { 
-        success: ackResult.success === true,
-        message: 'Manual lease renewal works correctly' 
-    }
-}
-
-export async function testBatchLeaseRenewal(client) {
-    const queue = await client.queue('test-queue-v2-batch-renewal')
-        .config({ leaseTime: 2 })
-        .create()
-    
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    await client.queue('test-queue-v2-batch-renewal').push([
-        { data: { id: 1 } },
-        { data: { id: 2 } },
-        { data: { id: 3 } }
-    ])
-
-    const messages = await client.queue('test-queue-v2-batch-renewal')
-        .batch(3)
-        .wait(false)
-        .pop()
-
-    if (messages.length !== 3) {
-        return { success: false, message: 'Expected 3 messages' }
-    }
-
-    // Wait 1 second
-    await new Promise(resolve => setTimeout(resolve, 1000))
-
-    // Renew all leases
-    const renewResults = await client.renew(messages)
-
-    const allSuccess = renewResults.every(r => r.success === true)
-
-    if (!allSuccess) {
-        return { success: false, message: 'Batch renewal failed' }
-    }
-
-    // Wait another 2 seconds
-    await new Promise(resolve => setTimeout(resolve, 2000))
-
-    // Try to ack all - should succeed
-    const ackResult = await client.ack(messages, true)
-
-    return { 
-        success: ackResult.success === true,
-        message: 'Batch lease renewal works correctly' 
-    }
-}
-
-export async function testRenewalWithLeaseId(client) {
-    const queue = await client.queue('test-queue-v2-renewal-leaseid')
-        .config({ leaseTime: 2 })
-        .create()
-    
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    await client.queue('test-queue-v2-renewal-leaseid')
-        .push([{ data: { test: 'data' } }])
-
-    const messages = await client.queue('test-queue-v2-renewal-leaseid')
-        .batch(1)
-        .wait(false)
-        .pop()
-
-    if (messages.length === 0 || !messages[0].leaseId) {
-        return { success: false, message: 'No message or leaseId' }
-    }
-
-    const leaseId = messages[0].leaseId
-
-    // Renew using just the leaseId string
-    const renewResult = await client.renew(leaseId)
-
-    return { 
-        success: renewResult.success === true,
-        message: 'Lease renewal with leaseId string works' 
-    }
-}
-
-export async function testRenewalOfExpiredLease(client) {
-    const queue = await client.queue('test-queue-v2-renewal-expired')
-        .config({ leaseTime: 1 })
-        .create()
-    
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    await client.queue('test-queue-v2-renewal-expired')
-        .push([{ data: { test: 'data' } }])
-
-    const messages = await client.queue('test-queue-v2-renewal-expired')
-        .batch(1)
-        .wait(false)
-        .pop()
-
-    if (messages.length === 0) {
-        return { success: false, message: 'No message to test' }
-    }
-
-    // Wait for lease to expire
-    await new Promise(resolve => setTimeout(resolve, 2000))
-
-    // Try to renew expired lease
-    const renewResult = await client.renew(messages[0])
-
-    // Should fail
-    return { 
-        success: renewResult.success === false,
-        message: 'Expired lease renewal correctly rejected' 
-    }
-}
-
-export async function testMultipleRenewals(client) {
-    const queue = await client.queue('test-queue-v2-multiple-renewals')
-        .config({ leaseTime: 2 })
-        .create()
-    
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    await client.queue('test-queue-v2-multiple-renewals')
-        .push([{ data: { test: 'data' } }])
-
-    const messages = await client.queue('test-queue-v2-multiple-renewals')
-        .batch(1)
-        .wait(false)
-        .pop()
-
-    if (messages.length === 0) {
-        return { success: false, message: 'No message to test' }
-    }
-
-    const message = messages[0]
-
-    // Renew multiple times
-    await new Promise(resolve => setTimeout(resolve, 1000))
-    const renew1 = await client.renew(message)
-
-    await new Promise(resolve => setTimeout(resolve, 1000))
-    const renew2 = await client.renew(message)
-
-    await new Promise(resolve => setTimeout(resolve, 1000))
-    const renew3 = await client.renew(message)
-
-    // After 3 seconds, ack should still work
-    const ackResult = await client.ack(message, true)
-
-    return { 
-        success: renew1.success && renew2.success && renew3.success && ackResult.success,
-        message: 'Multiple lease renewals work correctly' 
-    }
-}
-

package/test-v2/ai_mixed_scenarios.js

@@ -1,278 +0,0 @@
-/**
- * Mixed Scenario Tests
- * Complex tests combining multiple features
- */
-
-export async function testMultipleQueuesSimultaneous(client) {
-    // Create multiple queues with different configurations
-    await client.queue('test-queue-v2-mixed-1')
-        .config({ priority: 1, leaseTime: 60 })
-        .create()
-    
-    await client.queue('test-queue-v2-mixed-2')
-        .config({ priority: 5, retryLimit: 5 })
-        .create()
-    
-    await client.queue('test-queue-v2-mixed-3')
-        .config({ priority: 10, delayedProcessing: 1 })
-        .create()
-
-    // Push to all queues
-    await Promise.all([
-        client.queue('test-queue-v2-mixed-1').push([{ data: { queue: 1 } }]),
-        client.queue('test-queue-v2-mixed-2').push([{ data: { queue: 2 } }]),
-        client.queue('test-queue-v2-mixed-3').push([{ data: { queue: 3 } }])
-    ])
-
-    // Wait for delayed queue
-    await new Promise(resolve => setTimeout(resolve, 1500))
-
-    // Pop from all
-    const results = await Promise.all([
-        client.queue('test-queue-v2-mixed-1').batch(1).wait(false).pop(),
-        client.queue('test-queue-v2-mixed-2').batch(1).wait(false).pop(),
-        client.queue('test-queue-v2-mixed-3').batch(1).wait(false).pop()
-    ])
-
-    const totalMessages = results.reduce((sum, msgs) => sum + msgs.length, 0)
-
-    return { 
-        success: totalMessages === 3,
-        message: `Multiple queues working: ${totalMessages} messages` 
-    }
-}
-
-export async function testCrossQueueWorkflow(client) {
-    // Setup: 3-stage processing pipeline
-    await client.queue('test-queue-v2-workflow-stage1').create()
-    await client.queue('test-queue-v2-workflow-stage2').create()
-    await client.queue('test-queue-v2-workflow-stage3').create()
-
-    // Stage 1: Initial message
-    await client.queue('test-queue-v2-workflow-stage1')
-        .push([{ data: { stage: 1, value: 10 } }])
-
-    // Process stage 1 -> stage 2
-    const msg1 = await client.queue('test-queue-v2-workflow-stage1')
-        .batch(1).wait(false).pop()
-    
-    if (msg1.length === 0) {
-        return { success: false, message: 'Stage 1 failed' }
-    }
-
-    await client.transaction()
-        .queue('test-queue-v2-workflow-stage2')
-        .push([{ data: { stage: 2, value: msg1[0].data.value * 2 } }])
-        .ack(msg1[0])
-        .commit()
-
-    // Process stage 2 -> stage 3
-    const msg2 = await client.queue('test-queue-v2-workflow-stage2')
-        .batch(1).wait(false).pop()
-    
-    if (msg2.length === 0) {
-        return { success: false, message: 'Stage 2 failed' }
-    }
-
-    await client.transaction()
-        .queue('test-queue-v2-workflow-stage3')
-        .push([{ data: { stage: 3, value: msg2[0].data.value + 5 } }])
-        .ack(msg2[0])
-        .commit()
-
-    // Verify final result
-    const msg3 = await client.queue('test-queue-v2-workflow-stage3')
-        .batch(1).wait(false).pop()
-
-    return { 
-        success: msg3.length === 1 && msg3[0].data.value === 25,
-        message: `Cross-queue workflow completed: final value ${msg3[0]?.data.value}` 
-    }
-}
-
-export async function testPartitionWithConsumerGroupAndRetries(client) {
-    const queue = await client.queue('test-queue-v2-complex-partition')
-        .config({ retryLimit: 2 })
-        .create()
-    
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    // Push to specific partition
-    await client.queue('test-queue-v2-complex-partition')
-        .partition('complex-partition-1')
-        .push([{ data: { test: 'complex' } }])
-
-    let attemptCount = 0
-
-    // Consume with consumer group, fail first time
-    await client.queue('test-queue-v2-complex-partition')
-        .partition('complex-partition-1')
-        .group('complex-group')
-        .batch(1)
-        .wait(false)
-        .limit(2)
-        .each()
-        .consume(async (msg) => {
-            attemptCount++
-            if (attemptCount === 1) {
-                throw new Error('First attempt fails')
-            }
-            // Second attempt succeeds
-        })
-
-    return { 
-        success: attemptCount === 2,
-        message: 'Complex partition/group/retry scenario works' 
-    }
-}
-
-export async function testBufferedPushWithTransactionConsume(client) {
-    await client.queue('test-queue-v2-buf-txn-source').create()
-    await client.queue('test-queue-v2-buf-txn-dest').create()
-
-    // Buffered push to source
-    for (let i = 0; i < 10; i++) {
-        await client.queue('test-queue-v2-buf-txn-source')
-            .buffer({ messageCount: 10, timeMillis: 2000 })
-            .push([{ data: { id: i } }])
-    }
-
-    // Wait for flush
-    await new Promise(resolve => setTimeout(resolve, 2500))
-
-    // Consume with transaction to move to destination
-    let processed = 0
-    await client.queue('test-queue-v2-buf-txn-source')
-        .batch(10)
-        .wait(false)
-        .limit(1)
-        .autoAck(false)
-        .consume(async (msgs) => {
-            for (const msg of msgs) {
-                await client.transaction()
-                    .queue('test-queue-v2-buf-txn-dest')
-                    .push([{ data: { processed: true, originalId: msg.data.id } }])
-                    .ack(msg)
-                    .commit()
-                processed++
-            }
-        })
-
-    // Verify destination
-    const destMsgs = await client.queue('test-queue-v2-buf-txn-dest')
-        .batch(20).wait(false).pop()
-
-    return { 
-        success: processed === 10 && destMsgs.length === 10,
-        message: `Buffered push + transaction consume: ${destMsgs.length} messages` 
-    }
-}
-
-export async function testNamespaceWithMultipleQueues(client) {
-    const namespace = 'test-mixed-namespace'
-
-    // Create multiple queues in same namespace
-    await client.queue('test-queue-v2-ns-multi-a')
-        .namespace(namespace)
-        .config({ priority: 10 })
-        .create()
-    
-    await client.queue('test-queue-v2-ns-multi-b')
-        .namespace(namespace)
-        .config({ priority: 5 })
-        .create()
-    
-    await client.queue('test-queue-v2-ns-multi-c')
-        .namespace(namespace)
-        .config({ priority: 1 })
-        .create()
-
-    // Push to all
-    await client.queue('test-queue-v2-ns-multi-a').push([{ data: { from: 'a' } }])
-    await client.queue('test-queue-v2-ns-multi-b').push([{ data: { from: 'b' } }])
-    await client.queue('test-queue-v2-ns-multi-c').push([{ data: { from: 'c' } }])
-
-    // Consume from namespace (should get all 3)
-    const messages = []
-    await client.queue()
-        .namespace(namespace)
-        .batch(10)
-        .wait(false)
-        .limit(1)
-        .consume(async (msgs) => {
-            messages.push(...msgs)
-        })
-
-    return { 
-        success: messages.length === 3,
-        message: `Namespace multi-queue: ${messages.length} messages` 
-    }
-}
-
-export async function testEncryptedWithPartitionAndGroup(client) {
-    const queue = await client.queue('test-queue-v2-encrypted-complex')
-        .config({ encryptionEnabled: true })
-        .create()
-    
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    // Push encrypted to partition
-    await client.queue('test-queue-v2-encrypted-complex')
-        .partition('secure-partition')
-        .push([{ data: { secret: 'sensitive-data', id: 123 } }])
-
-    // Consume with group
-    let receivedData = null
-    await client.queue('test-queue-v2-encrypted-complex')
-        .partition('secure-partition')
-        .group('secure-group')
-        .batch(1)
-        .wait(false)
-        .limit(1)
-        .each()
-        .consume(async (msg) => {
-            receivedData = msg.data
-        })
-
-    return { 
-        success: receivedData && receivedData.secret === 'sensitive-data',
-        message: 'Encrypted + partition + group works' 
-    }
-}
-
-export async function testHighConcurrencyMixedOperations(client) {
-    await client.queue('test-queue-v2-concurrency-mixed').create()
-
-    // Push many messages
-    const pushPromises = []
-    for (let i = 0; i < 50; i++) {
-        pushPromises.push(
-            client.queue('test-queue-v2-concurrency-mixed')
-                .push([{ data: { id: i } }])
-        )
-    }
-    await Promise.all(pushPromises)
-
-    // Consume with high concurrency
-    let processedCount = 0
-    await client.queue('test-queue-v2-concurrency-mixed')
-        .concurrency(10)
-        .batch(5)
-        .wait(false)
-        .limit(10)
-        .each()
-        .consume(async (msg) => {
-            processedCount++
-            await new Promise(resolve => setTimeout(resolve, 10))
-        })
-
-    return { 
-        success: processedCount === 50,
-        message: `High concurrency mixed ops: ${processedCount} messages` 
-    }
-}
-

package/test-v2/ai_priority.js

@@ -1,169 +0,0 @@
-/**
- * Priority Queue Tests
- * Tests for message priority handling
- */
-
-export async function testBasicPriority(client) {
-    // Create queues with different priorities
-    const highPriorityQueue = await client.queue('test-queue-v2-priority-high')
-        .config({ priority: 10 })
-        .create()
-    
-    const lowPriorityQueue = await client.queue('test-queue-v2-priority-low')
-        .config({ priority: 1 })
-        .create()
-
-    if (!highPriorityQueue.configured || !lowPriorityQueue.configured) {
-        return { success: false, message: 'Queues not created' }
-    }
-
-    // Push to low priority first
-    await client.queue('test-queue-v2-priority-low')
-        .push([{ data: { priority: 'low', message: 'Should process second' } }])
-
-    // Then push to high priority
-    await client.queue('test-queue-v2-priority-high')
-        .push([{ data: { priority: 'high', message: 'Should process first' } }])
-
-    // Note: Testing actual priority processing order requires namespace/task filtering
-    // as pop() from specific queue will only get that queue's messages
-    
-    return { 
-        success: true,
-        message: 'Priority queues configured successfully' 
-    }
-}
-
-export async function testPriorityWithNamespace(client) {
-    const namespace = 'test-priority-namespace'
-    
-    // Create multiple queues in same namespace with different priorities
-    await client.queue('test-queue-v2-pri-ns-high')
-        .namespace(namespace)
-        .config({ priority: 10 })
-        .create()
-    
-    await client.queue('test-queue-v2-pri-ns-medium')
-        .namespace(namespace)
-        .config({ priority: 5 })
-        .create()
-    
-    await client.queue('test-queue-v2-pri-ns-low')
-        .namespace(namespace)
-        .config({ priority: 1 })
-        .create()
-
-    // Push messages in reverse priority order
-    await client.queue('test-queue-v2-pri-ns-low')
-        .push([{ data: { order: 'third', value: 1 } }])
-    
-    await client.queue('test-queue-v2-pri-ns-medium')
-        .push([{ data: { order: 'second', value: 5 } }])
-    
-    await client.queue('test-queue-v2-pri-ns-high')
-        .push([{ data: { order: 'first', value: 10 } }])
-
-    // Pop from namespace (should respect priority)
-    const messages = []
-    await client.queue()
-        .namespace(namespace)
-        .batch(3)
-        .wait(false)
-        .limit(1)
-        .consume(async (msgs) => {
-            messages.push(...msgs)
-        })
-
-    // Messages should be in priority order
-    if (messages.length !== 3) {
-        return { success: false, message: `Expected 3 messages, got ${messages.length}` }
-    }
-
-    // High priority should come first
-    const firstIsHighPriority = messages[0].data.value === 10
-    
-    return { 
-        success: firstIsHighPriority,
-        message: `Priority ordering: ${messages.map(m => m.data.order).join(', ')}` 
-    }
-}
-
-export async function testPriorityWithTask(client) {
-    const task = 'test-priority-task'
-    
-    // Create queues with same task but different priorities
-    await client.queue('test-queue-v2-pri-task-urgent')
-        .task(task)
-        .config({ priority: 100 })
-        .create()
-    
-    await client.queue('test-queue-v2-pri-task-normal')
-        .task(task)
-        .config({ priority: 50 })
-        .create()
-
-    // Push to normal first
-    await client.queue('test-queue-v2-pri-task-normal')
-        .push([{ data: { urgency: 'normal' } }])
-    
-    // Then urgent
-    await client.queue('test-queue-v2-pri-task-urgent')
-        .push([{ data: { urgency: 'urgent' } }])
-
-    // Pop from task
-    const messages = []
-    await client.queue()
-        .task(task)
-        .batch(2)
-        .wait(false)
-        .limit(1)
-        .consume(async (msgs) => {
-            messages.push(...msgs)
-        })
-
-    if (messages.length !== 2) {
-        return { success: false, message: `Expected 2 messages, got ${messages.length}` }
-    }
-
-    // Urgent should come first
-    const urgentFirst = messages[0].data.urgency === 'urgent'
-    
-    return { 
-        success: urgentFirst,
-        message: 'Task-based priority ordering works' 
-    }
-}
-
-export async function testDynamicPriorityChange(client) {
-    const queueName = 'test-queue-v2-priority-dynamic'
-    
-    // Create with low priority
-    await client.queue(queueName)
-        .config({ priority: 1 })
-        .create()
-
-    // Push a message
-    await client.queue(queueName)
-        .push([{ data: { phase: 'low-priority' } }])
-
-    // Reconfigure with high priority
-    await client.queue(queueName)
-        .config({ priority: 10 })
-        .create()
-
-    // Push another message
-    await client.queue(queueName)
-        .push([{ data: { phase: 'high-priority' } }])
-
-    // Pop messages
-    const messages = await client.queue(queueName)
-        .batch(2)
-        .wait(false)
-        .pop()
-
-    return { 
-        success: messages.length === 2,
-        message: 'Dynamic priority change handled' 
-    }
-}
-