queen-mq 0.2.23 → 0.3.0

package/client-js/test-v2/ai_buffering.js

@@ -0,0 +1,194 @@
+/**
+ * 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/client-js/test-v2/ai_error_handling.js

@@ -0,0 +1,223 @@
+/**
+ * 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/client-js/test-v2/ai_lease_renewal.js

@@ -0,0 +1,206 @@
+/**
+ * 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' 
+    }
+}
+