queen-mq 0.12.0 → 0.12.2

package/test-v2/README_SUBSCRIPTION_TESTS.md

@@ -1,201 +0,0 @@
-# Subscription Mode Tests
-
-Tests for consumer group subscription modes, compatible with any server `DEFAULT_SUBSCRIPTION_MODE` configuration.
-
-## Test Overview
-
-| Test Function | Description | Explicit Mode Used |
-|--------------|-------------|-------------------|
-| `subscriptionModeNew` | Validates `.subscriptionMode('new')` skips historical messages | Yes (`new`) |
-| `subscriptionModeNewOnly` | Validates alias `.subscriptionMode('new-only')` | Yes (`new-only`) |
-| `subscriptionFromNow` | Validates `.subscriptionFrom('now')` | Yes (`now`) |
-| `subscriptionFromTimestamp` | Validates timestamp-based subscription | Yes (timestamp) |
-| `subscriptionModeAll` | Tests default behavior (depends on server config) | Mixed |
-| `subscriptionModeServerDefault` | **NEW:** Detects and validates server default | Mixed |
-
-## Running the Tests
-
-### Run all subscription tests:
-```bash
-cd client-js/test-v2
-node run.js subscription
-```
-
-### Run specific subscription test:
-```bash
-node run.js subscriptionModeNew
-node run.js subscriptionModeServerDefault
-```
-
-## Server Configuration Compatibility
-
-These tests work with **any** server `DEFAULT_SUBSCRIPTION_MODE` configuration:
-
-### Configuration 1: Standard (Default)
-
-```bash
-# Start server without default
-./bin/queen-server
-
-# Run tests
-node run.js subscription
-```
-
-**Expected Behavior:**
-- Consumer groups without explicit mode process all historical messages
-- Consumer groups with `.subscriptionMode('new')` skip history
-- `subscriptionModeServerDefault` reports: "all (or empty string)"
-
-### Configuration 2: With DEFAULT_SUBSCRIPTION_MODE="new"
-
-```bash
-# Start server with "new" as default
-DEFAULT_SUBSCRIPTION_MODE="new" ./bin/queen-server
-
-# Run tests
-node run.js subscription
-```
-
-**Expected Behavior:**
-- Consumer groups without explicit mode skip historical messages
-- Consumer groups with `.subscriptionMode('new')` skip history (same)
-- `subscriptionModeServerDefault` reports: "new"
-
-**✅ All tests pass with both configurations!**
-
-## Test Details
-
-### subscriptionModeNew
-
-Tests the explicit `.subscriptionMode('new')` behavior:
-
-1. Pushes 5 historical messages
-2. Creates two consumer groups:
-   - One without explicit mode (behavior depends on server)
-   - One with `.subscriptionMode('new')` (always skips)
-3. Verifies the `new` mode group gets 0 historical messages
-4. Pushes 3 new messages
-5. Verifies both groups get the new messages
-
-**Key Assertion:** `.subscriptionMode('new')` always skips historical messages.
-
-### subscriptionModeServerDefault (NEW)
-
-Detects and validates the server's default subscription mode:
-
-1. Pushes historical messages
-2. Creates consumer group WITHOUT explicit subscription mode
-3. Detects server default based on behavior:
-   - Got historical messages → server default is "all"
-   - Got 0 messages → server default is "new"
-4. Validates explicit `.subscriptionMode('new')` still works
-5. Verifies new messages are received by both groups
-
-**Key Assertion:** Server default affects groups without explicit mode, but explicit modes always work.
-
-### subscriptionFromTimestamp
-
-Tests timestamp-based subscription:
-
-1. Pushes "first batch" of messages
-2. Records cutoff timestamp
-3. Pushes "second batch" of messages
-4. Creates consumer group with `.subscriptionFrom(cutoffTimestamp)`
-5. Verifies only messages after timestamp are received
-
-**Note:** Timestamp precision may vary based on database clock.
-
-## Common Issues
-
-### Issue: Test fails with "expected X, got Y"
-
-**Cause:** Server has different default than test expects.
-
-**Solution:** Check server configuration:
-```bash
-# Check if DEFAULT_SUBSCRIPTION_MODE is set
-echo $DEFAULT_SUBSCRIPTION_MODE
-
-# Check server logs on startup
-LOG_LEVEL=debug ./bin/queen-server | grep "default subscription"
-```
-
-### Issue: Consumer group exists from previous run
-
-**Cause:** Consumer groups persist between test runs.
-
-**Solution:** The test runner cleans up test data automatically:
-```javascript
-await dbPool.query(`DELETE FROM queen.queues WHERE name LIKE 'test-%'`)
-```
-
-Or manually:
-```sql
-DELETE FROM queen.partition_consumers 
-WHERE consumer_group LIKE 'group-%';
-```
-
-### Issue: Timing-related test failures
-
-**Cause:** Messages not fully persisted before consumption.
-
-**Solution:** Tests include appropriate delays. If still failing, increase delays:
-```javascript
-await new Promise(resolve => setTimeout(resolve, 500))  // Increase if needed
-```
-
-## Adding New Subscription Tests
-
-When adding new subscription mode tests:
-
-1. **Use unique queue/group names** to avoid conflicts
-2. **Be explicit about subscription modes** in test assertions
-3. **Document expected behavior** for both server configurations
-4. **Use descriptive group names** like `group-explicit-new` vs `group-default`
-
-Example:
-```javascript
-export async function testNewFeature(client) {
-  // Setup
-  await client.queue('test-new-feature').create()
-  
-  // Test explicit behavior (works with any server default)
-  const result = await client
-    .queue('test-new-feature')
-    .group('group-explicit-new')
-    .subscriptionMode('new')  // Explicit!
-    .pop()
-  
-  // Assert based on explicit mode, not server default
-  // ...
-}
-```
-
-## Debugging Failed Tests
-
-Enable detailed logging:
-
-```bash
-# Client logging
-QUEEN_CLIENT_LOG=true node run.js subscriptionModeNew
-
-# Server logging
-LOG_LEVEL=debug ./bin/queen-server
-```
-
-Look for these log lines:
-```
-Consumer group 'group-xxx' exists: false, has subscription options: true
-Subscription mode 'new' - starting from latest message: <uuid>
-Applying default subscription mode 'new' for consumer group 'group-yyy'
-```
-
-## Summary
-
-- ✅ Tests work with any `DEFAULT_SUBSCRIPTION_MODE` configuration
-- ✅ Explicit subscription modes are always tested and validated
-- ✅ Server default behavior is detected and reported
-- ✅ All tests are documented and maintainable
-
-Run the tests and see them pass! 🎉
-

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