queen-mq 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "queen-mq",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "description": "Partitioned message queue on PostgreSQL — broker client + fluent streaming SDK (windows, joins, gates) in one package",
   "main": "client-v2/index.js",

package/test-v2/retention.js

@@ -1,6 +1,27 @@
 
-// To pass this test the server needs to 
-// be started with RETENTION_INTERVAL=2000
+// The sweep is periodic AND backs off, so the wait below is a bound, not a guess.
+//
+// retention.rs gives a partition a strike for every visit that deletes nothing
+// and skips it for BACKOFF_BASE_CYCLES (8) cycles after the first one. The
+// sweep that runs while these 100 messages are still younger than
+// `retentionSeconds` is exactly such a fruitless visit, so the partition is
+// parked for 8 * RETENTION_INTERVAL before anything can be deleted:
+//
+//     worst case = retentionSeconds + BACKOFF_BASE_CYCLES * RETENTION_INTERVAL
+//                = 10s             + 8                   * 5s (the default)
+//                = 50s
+//
+// The old wait was 15s, taken from a comment that assumed the broker ran with
+// RETENTION_INTERVAL=2000 -- which no stack in test/compose has ever set. It
+// could not pass once the backoff landed (751435f5), and it is why `suites (js)`
+// was 172/173 red on master for weeks. Measured on the single stack: still
+// present at 15s/25s/35s, deleted by 50s.
+//
+// Do NOT turn this into a poll loop: pop() CONSUMES, so a poll that pops early
+// empties the queue itself and the next read returns 0 whether retention ran or
+// not -- a test that passes for the wrong reason.
+const RETENTION_SWEEP_WAIT_MS = 65000
+
 export async function retentionTest(client) {
     const queueName = 'test-queue-retention-01';
     const queue = await client
@@ -20,7 +41,7 @@ export async function retentionTest(client) {
         .push([{ data: { message: i } }])
     }
 
-    await new Promise(resolve => setTimeout(resolve, 15000))
+    await new Promise(resolve => setTimeout(resolve, RETENTION_SWEEP_WAIT_MS))
 
     const messages = await client
     .queue(queueName)
@@ -32,12 +53,12 @@ export async function retentionTest(client) {
         return { success: true, message: 'Messages cleaned up' }
     }
 
-    return { success: false }
+    return { success: false, message: `retention left ${messages.length}/100 messages after ${RETENTION_SWEEP_WAIT_MS / 1000}s` }
 }
 
 
-// To pass this test the server needs to 
-// be started with RETENTION_INTERVAL=2000
+// maxWaitTimeSeconds eviction, which is a different retention phase with its own
+// backoff map -- so it is not subject to the bound above and 15s has held.
 export async function retentionTestMaxTime(client) {
     const queueName = 'test-queue-retention-02';
     const queue = await client
@@ -65,5 +86,5 @@ export async function retentionTestMaxTime(client) {
         return { success: true, message: 'Messages cleaned up' }
     }
 
-    return { success: false }
+    return { success: false, message: `max-wait eviction left ${messages.length}/100 messages` }
 }

package/test-v2/stream/tumbling.js

@@ -149,12 +149,16 @@ export async function tumblingAggregateAllStats(client) {
   await client.queue(src).create()
   await client.queue(sink).create()
 
-  // Push 5 values into the SAME window (all within 1 second), then idle
-  // flush will close it. Sum = 50, count = 5, avg = 10, min = 2, max = 30.
-  const values = [10, 5, 30, 2, 3]
-  for (const v of values) {
-    await client.queue(src).partition('p').push([{ data: { v } }])
-  }
+  // One batched push = one segment = one timestamp, so the five values cannot
+  // straddle a 3-second window boundary. Pushing them "within 1 second" of each
+  // other does NOT put them in one window: the bucket is absolute-aligned
+  // (floor(ts / 3000) * 3000), so two pushes milliseconds apart still split when
+  // a boundary falls between them, and the assertion below reads only the FIRST
+  // emit. Sum = 50, count = 5, avg = 10, min = 2, max = 30.
+  await client.queue(src).partition('p').push([
+    { data: { v: 10 } }, { data: { v: 5 } }, { data: { v: 30 } },
+    { data: { v: 2 } }, { data: { v: 3 } },
+  ])
 
   const handle = await Stream
     .from(client.queue(src))