queen-mq 0.12.1 → 0.12.2

package/test-v2/ai_buffering.js

@@ -1,194 +0,0 @@
-/**
- * Client-Side Buffering Tests
- * Tests for buffer management and statistics
- */
-
-export async function testBufferStatistics(client) {
-    const queue = await client.queue('test-queue-v2-buffer-stats').create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    // Get initial stats
-    const statsBefore = client.getBufferStats()
-    
-    if (!statsBefore || typeof statsBefore !== 'object') {
-        return { success: false, message: 'Buffer stats not available' }
-    }
-
-    // Push some buffered messages
-    for (let i = 0; i < 5; i++) {
-        await client.queue('test-queue-v2-buffer-stats')
-            .buffer({ messageCount: 10, timeMillis: 5000 })
-            .push([{ data: { id: i } }])
-    }
-
-    // Get stats after buffering
-    const statsAfter = client.getBufferStats()
-    
-    // Stats should show buffer activity
-    return { 
-        success: statsAfter !== null,
-        message: `Buffer stats retrieved: ${JSON.stringify(statsAfter)}` 
-    }
-}
-
-export async function testManualBufferFlush(client) {
-    const queue = await client.queue('test-queue-v2-manual-flush').create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    // Push buffered messages (with high threshold so they don't auto-flush)
-    for (let i = 0; i < 5; i++) {
-        await client.queue('test-queue-v2-manual-flush')
-            .buffer({ messageCount: 100, timeMillis: 30000 })
-            .push([{ data: { id: i } }])
-    }
-
-    // Check that messages are not in queue yet
-    const beforeFlush = await client.queue('test-queue-v2-manual-flush')
-        .batch(10)
-        .wait(false)
-        .pop()
-
-    if (beforeFlush.length > 0) {
-        return { success: false, message: 'Messages not buffered (flushed too early)' }
-    }
-
-    // Manually flush all buffers
-    await client.flushAllBuffers()
-
-    // Now messages should be in the queue
-    const afterFlush = await client.queue('test-queue-v2-manual-flush')
-        .batch(10)
-        .wait(false)
-        .pop()
-
-    return { 
-        success: afterFlush.length === 5,
-        message: `Manual flush successful: ${afterFlush.length} messages` 
-    }
-}
-
-export async function testBufferTimeThreshold(client) {
-    const queue = await client.queue('test-queue-v2-buffer-time').create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    // Push with time-based buffer (1 second)
-    await client.queue('test-queue-v2-buffer-time')
-        .buffer({ messageCount: 1000, timeMillis: 1000 })
-        .push([{ data: { test: 'data' } }])
-
-    // Wait for time threshold
-    await new Promise(resolve => setTimeout(resolve, 1500))
-
-    // Message should be auto-flushed by time
-    const messages = await client.queue('test-queue-v2-buffer-time')
-        .batch(1)
-        .wait(false)
-        .pop()
-
-    return { 
-        success: messages.length === 1,
-        message: 'Time-based buffer flush works' 
-    }
-}
-
-export async function testBufferCountThreshold(client) {
-    const queue = await client.queue('test-queue-v2-buffer-count').create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    // Push exactly 5 messages with count threshold of 5
-    for (let i = 0; i < 5; i++) {
-        await client.queue('test-queue-v2-buffer-count')
-            .buffer({ messageCount: 5, timeMillis: 30000 })
-            .push([{ data: { id: i } }])
-    }
-
-    // Small delay for flush to process
-    await new Promise(resolve => setTimeout(resolve, 200))
-
-    // All 5 should be flushed when threshold reached
-    const messages = await client.queue('test-queue-v2-buffer-count')
-        .batch(10)
-        .wait(false)
-        .pop()
-
-    return { 
-        success: messages.length === 5,
-        message: `Count-based buffer flush: ${messages.length} messages` 
-    }
-}
-
-export async function testMultipleBuffers(client) {
-    // Create multiple queues with buffering
-    await client.queue('test-queue-v2-multi-buf-1').create()
-    await client.queue('test-queue-v2-multi-buf-2').create()
-    await client.queue('test-queue-v2-multi-buf-3').create()
-
-    // Buffer messages to different queues
-    for (let i = 0; i < 3; i++) {
-        await client.queue('test-queue-v2-multi-buf-1')
-            .buffer({ messageCount: 100, timeMillis: 10000 })
-            .push([{ data: { queue: 1, id: i } }])
-        
-        await client.queue('test-queue-v2-multi-buf-2')
-            .buffer({ messageCount: 100, timeMillis: 10000 })
-            .push([{ data: { queue: 2, id: i } }])
-        
-        await client.queue('test-queue-v2-multi-buf-3')
-            .buffer({ messageCount: 100, timeMillis: 10000 })
-            .push([{ data: { queue: 3, id: i } }])
-    }
-
-    // Get stats to see multiple buffers
-    const stats = client.getBufferStats()
-
-    // Flush all buffers
-    await client.flushAllBuffers()
-
-    // Verify all queues received messages
-    const msgs1 = await client.queue('test-queue-v2-multi-buf-1').batch(10).wait(false).pop()
-    const msgs2 = await client.queue('test-queue-v2-multi-buf-2').batch(10).wait(false).pop()
-    const msgs3 = await client.queue('test-queue-v2-multi-buf-3').batch(10).wait(false).pop()
-
-    return { 
-        success: msgs1.length === 3 && msgs2.length === 3 && msgs3.length === 3,
-        message: `Multiple buffers flushed: ${msgs1.length + msgs2.length + msgs3.length} total` 
-    }
-}
-
-export async function testBufferWithPartition(client) {
-    const queue = await client.queue('test-queue-v2-buffer-partition').create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    // Buffer messages to specific partition
-    for (let i = 0; i < 5; i++) {
-        await client.queue('test-queue-v2-buffer-partition')
-            .partition('test-partition-buf')
-            .buffer({ messageCount: 100, timeMillis: 10000 })
-            .push([{ data: { id: i } }])
-    }
-
-    await client.flushAllBuffers()
-
-    // Pop from that partition
-    const messages = await client.queue('test-queue-v2-buffer-partition')
-        .partition('test-partition-buf')
-        .batch(10)
-        .wait(false)
-        .pop()
-
-    return { 
-        success: messages.length === 5,
-        message: 'Buffering with partition works' 
-    }
-}
-

package/test-v2/ai_error_handling.js

@@ -1,223 +0,0 @@
-/**
- * Error Handling & Edge Cases Tests
- * Tests various error conditions and edge cases
- */
-
-export async function testInvalidQueueName(client) {
-    try {
-        await client.queue('').create()
-        return { success: false, message: 'Empty queue name should fail' }
-    } catch (error) {
-        return { success: true, message: 'Empty queue name correctly rejected' }
-    }
-}
-
-export async function testInvalidConfiguration(client) {
-    try {
-        await client.queue('test-queue-invalid-config')
-            .config({ leaseTime: -1 })
-            .create()
-        return { success: false, message: 'Negative leaseTime should fail' }
-    } catch (error) {
-        return { success: true, message: 'Invalid config correctly rejected' }
-    }
-}
-
-export async function testInvalidMessageFormat(client) {
-    const queue = await client.queue('test-queue-v2-invalid-msg').create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    try {
-        // Push without data property
-        await client.queue('test-queue-v2-invalid-msg').push([{ invalid: 'structure' }])
-        // If it doesn't throw, check if it still works
-        return { success: true, message: 'Client handles flexible message format' }
-    } catch (error) {
-        return { success: true, message: 'Invalid message format correctly handled' }
-    }
-}
-
-export async function testPushEmptyArray(client) {
-    const queue = await client.queue('test-queue-v2-empty-array').create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    const result = await client.queue('test-queue-v2-empty-array').push([])
-    return { success: result.length === 0, message: 'Empty array push handled correctly' }
-}
-
-export async function testAckWithoutPartitionId(client) {
-    const queue = await client.queue('test-queue-v2-ack-no-partition').create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    await client.queue('test-queue-v2-ack-no-partition')
-        .push([{ data: { test: 'data' } }])
-
-    const messages = await client.queue('test-queue-v2-ack-no-partition')
-        .batch(1)
-        .wait(false)
-        .pop()
-
-    if (messages.length === 0) {
-        return { success: false, message: 'No message to test' }
-    }
-
-    // Try to ack without partitionId (should fail)
-    const messageWithoutPartition = { transactionId: messages[0].transactionId }
-    const result = await client.ack(messageWithoutPartition)
-
-    return { 
-        success: result.success === false && result.error.includes('partitionId'), 
-        message: 'Ack without partitionId correctly rejected' 
-    }
-}
-
-export async function testPopFromNonExistentQueue(client) {
-    try {
-        const result = await client
-            .queue('non-existent-queue-xyz')
-            .batch(1)
-            .wait(false)
-            .pop()
-        
-        // It's okay if it returns empty or throws
-        return { success: true, message: 'Non-existent queue handled gracefully' }
-    } catch (error) {
-        return { success: true, message: 'Non-existent queue error handled' }
-    }
-}
-
-export async function testMultiplePushesWithSameTransactionId(client) {
-    const queue = await client.queue('test-queue-v2-same-txid').create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    const txId = 'duplicate-transaction-id-test'
-    
-    const result1 = await client.queue('test-queue-v2-same-txid')
-        .push([{ transactionId: txId, data: { first: true } }])
-    
-    const result2 = await client.queue('test-queue-v2-same-txid')
-        .push([{ transactionId: txId, data: { second: true } }])
-
-    const result3 = await client.queue('test-queue-v2-same-txid')
-        .push([{ transactionId: txId, data: { third: true } }])
-
-    const duplicates = [result1[0], result2[0], result3[0]].filter(r => r.status === 'duplicate').length
-
-    return { 
-        success: duplicates >= 2, 
-        message: `Duplicate detection working (${duplicates} duplicates found)` 
-    }
-}
-
-export async function testAckExpiredLease(client) {
-    const queue = await client.queue('test-queue-v2-expired-lease')
-        .config({ leaseTime: 1 })
-        .create()
-    
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    await client.queue('test-queue-v2-expired-lease')
-        .push([{ data: { test: 'data' } }])
-
-    const messages = await client.queue('test-queue-v2-expired-lease')
-        .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 ack expired lease
-    const result = await client.ack(messages[0], true)
-
-    return { 
-        success: result.success === false, 
-        message: 'Expired lease ack correctly rejected' 
-    }
-}
-
-export async function testBatchAckMixedResults(client) {
-    const queue = await client.queue('test-queue-v2-batch-ack-mixed')
-        .config({ leaseTime: 2 })
-        .create()
-    
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    await client.queue('test-queue-v2-batch-ack-mixed').push([
-        { data: { id: 1 } },
-        { data: { id: 2 } },
-        { data: { id: 3 } }
-    ])
-
-    const messages = await client.queue('test-queue-v2-batch-ack-mixed')
-        .batch(3)
-        .wait(false)
-        .pop()
-
-    if (messages.length !== 3) {
-        return { success: false, message: 'Expected 3 messages' }
-    }
-
-    // Wait for one lease to expire
-    await new Promise(resolve => setTimeout(resolve, 2500))
-
-    // Try to ack all three (one should fail due to expired lease)
-    const result = await client.ack(messages, true)
-
-    // Should indicate some failures
-    return { 
-        success: result.success === true, // Batch ack returns overall success
-        message: 'Batch ack with expired lease handled' 
-    }
-}
-
-export async function testVeryLargePayload(client) {
-    const queue = await client.queue('test-queue-v2-very-large').create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    // Create a very large payload (attempt to push near limits)
-    const hugeArray = new Array(50000).fill({
-        id: Math.random().toString(36),
-        data: 'x'.repeat(100)
-    })
-
-    try {
-        const result = await client.queue('test-queue-v2-very-large')
-            .push([{ data: hugeArray }])
-
-        const received = await client.queue('test-queue-v2-very-large')
-            .batch(1)
-            .wait(false)
-            .pop()
-
-        return { 
-            success: received.length === 1 && received[0].data.length === 50000,
-            message: 'Very large payload handled correctly' 
-        }
-    } catch (error) {
-        // It's okay if it fails - system has limits
-        return { 
-            success: true, 
-            message: `Large payload limit enforced: ${error.message}` 
-        }
-    }
-}
-

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' 
-    }
-}
-