queen-mq 0.2.23 → 0.3.1

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

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

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

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

@@ -0,0 +1,217 @@
+/**
+ * Resource & Status API Tests
+ * Tests for querying system resources and status
+ */
+
+// Helper to make direct HTTP calls
+async function httpGet(url) {
+    const response = await fetch(url)
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+    }
+    return await response.json()
+}
+
+export async function testListQueues(client) {
+    // Create some test queues
+    await client.queue('test-queue-v2-list-1').create()
+    await client.queue('test-queue-v2-list-2').create()
+    await client.queue('test-queue-v2-list-3').create()
+
+    try {
+        const result = await httpGet('http://localhost:6632/api/v1/resources/queues')
+        
+        if (!result || !Array.isArray(result)) {
+            return { success: false, message: 'Invalid queue list response' }
+        }
+
+        const testQueues = result.filter(q => q.name && q.name.startsWith('test-queue-v2-list'))
+        
+        return { 
+            success: testQueues.length >= 3,
+            message: `Found ${testQueues.length} test queues` 
+        }
+    } catch (error) {
+        return { success: false, message: `Error listing queues: ${error.message}` }
+    }
+}
+
+export async function testGetQueueDetails(client) {
+    const queueName = 'test-queue-v2-details'
+    await client.queue(queueName)
+        .config({ 
+            leaseTime: 123,
+            maxSize: 5000,
+            retryLimit: 5 
+        })
+        .create()
+
+    try {
+        const result = await httpGet(`http://localhost:6632/api/v1/resources/queues/${queueName}`)
+        
+        if (!result || !result.name) {
+            return { success: false, message: 'Invalid queue details response' }
+        }
+
+        const hasCorrectConfig = result.name === queueName
+        
+        return { 
+            success: hasCorrectConfig,
+            message: 'Queue details retrieved successfully' 
+        }
+    } catch (error) {
+        return { success: false, message: `Error getting queue details: ${error.message}` }
+    }
+}
+
+export async function testGetNamespaces(client) {
+    // Create queues with different namespaces
+    await client.queue('test-queue-v2-ns-1')
+        .namespace('test-namespace-alpha')
+        .create()
+    
+    await client.queue('test-queue-v2-ns-2')
+        .namespace('test-namespace-beta')
+        .create()
+
+    try {
+        const result = await httpGet('http://localhost:6632/api/v1/resources/namespaces')
+        
+        if (!result || !Array.isArray(result)) {
+            return { success: false, message: 'Invalid namespaces response' }
+        }
+
+        const testNamespaces = result.filter(ns => 
+            typeof ns === 'string' && ns.startsWith('test-namespace')
+        )
+        
+        return { 
+            success: testNamespaces.length >= 2,
+            message: `Found ${testNamespaces.length} test namespaces` 
+        }
+    } catch (error) {
+        return { success: false, message: `Error listing namespaces: ${error.message}` }
+    }
+}
+
+export async function testGetTasks(client) {
+    // Create queues with different tasks
+    await client.queue('test-queue-v2-task-1')
+        .task('test-task-one')
+        .create()
+    
+    await client.queue('test-queue-v2-task-2')
+        .task('test-task-two')
+        .create()
+
+    try {
+        const result = await httpGet('http://localhost:6632/api/v1/resources/tasks')
+        
+        if (!result || !Array.isArray(result)) {
+            return { success: false, message: 'Invalid tasks response' }
+        }
+
+        const testTasks = result.filter(task => 
+            typeof task === 'string' && task.startsWith('test-task')
+        )
+        
+        return { 
+            success: testTasks.length >= 2,
+            message: `Found ${testTasks.length} test tasks` 
+        }
+    } catch (error) {
+        return { success: false, message: `Error listing tasks: ${error.message}` }
+    }
+}
+
+export async function testGetMessages(client) {
+    const queueName = 'test-queue-v2-get-messages'
+    await client.queue(queueName).create()
+
+    // Push some messages
+    await client.queue(queueName).push([
+        { data: { id: 1 } },
+        { data: { id: 2 } },
+        { data: { id: 3 } }
+    ])
+
+    try {
+        const result = await httpGet(
+            `http://localhost:6632/api/v1/messages?queue=${queueName}&status=pending&limit=10`
+        )
+        
+        if (!result || !result.messages) {
+            return { success: false, message: 'Invalid messages response' }
+        }
+
+        return { 
+            success: result.messages.length >= 3,
+            message: `Found ${result.messages.length} pending messages` 
+        }
+    } catch (error) {
+        return { success: false, message: `Error getting messages: ${error.message}` }
+    }
+}
+
+export async function testSystemOverview(client) {
+    try {
+        const result = await httpGet('http://localhost:6632/api/v1/resources/overview')
+        
+        if (!result) {
+            return { success: false, message: 'Invalid overview response' }
+        }
+
+        // Check for expected overview fields
+        const hasExpectedFields = 'totalQueues' in result || 'queues' in result
+        
+        return { 
+            success: hasExpectedFields,
+            message: 'System overview retrieved successfully' 
+        }
+    } catch (error) {
+        return { success: false, message: `Error getting overview: ${error.message}` }
+    }
+}
+
+export async function testHealthCheck(client) {
+    try {
+        const result = await httpGet('http://localhost:6632/health')
+        
+        if (!result || result.status !== 'healthy') {
+            return { success: false, message: 'Health check failed' }
+        }
+
+        return { 
+            success: true,
+            message: 'Health check passed' 
+        }
+    } catch (error) {
+        return { success: false, message: `Health check error: ${error.message}` }
+    }
+}
+
+export async function testDeleteQueue(client) {
+    const queueName = 'test-queue-v2-to-delete'
+    await client.queue(queueName).create()
+
+    // Verify it exists
+    const queues1 = await httpGet('http://localhost:6632/api/v1/resources/queues')
+    const existsBefore = queues1.some(q => q.name === queueName)
+
+    if (!existsBefore) {
+        return { success: false, message: 'Queue not created' }
+    }
+
+    // Delete it
+    const deleteResult = await client.queue(queueName).delete()
+
+    if (!deleteResult.deleted) {
+        return { success: false, message: 'Queue deletion failed' }
+    }
+
+    return { 
+        success: true,
+        message: 'Queue deleted successfully' 
+    }
+}
+