queen-mq 1.0.0 → 1.0.3

package/test-v2/stream/_helpers.js

@@ -84,6 +84,11 @@ export async function pushSpread(client, queueName, items) {
  * immediately, return the concatenated list of messages. Stops when a
  * pop returns 0 messages OR cumulative timeout is hit.
  *
+ * NOTE on subscription mode: the drain group is created AFTER the stream has
+ * already emitted onto the sink, so it must ask for 'all' explicitly — with
+ * the broker default of 'new' its cursor would be seeded at the sink's tail
+ * and the emits under test would be invisible.
+ *
  * NOTE on batch size: we use batch=1 so that each ack triggers
  * `acked_count >= batch_size` in queen.partition_consumers and the lease
  * is released between pops. With a larger batch the lease would stay
@@ -99,6 +104,7 @@ export async function drainSink(client, queueName, { timeoutMs = 5000, group } =
     const popped = await client
       .queue(queueName)
       .group(cg)
+      .subscriptionMode('all')
       .batch(1)
       .wait(false)
       .pop()
@@ -127,6 +133,7 @@ export async function drainUntil(client, queueName, { until, timeoutMs = 15_000,
     const popped = await client
       .queue(queueName)
       .group(cg)
+      .subscriptionMode('all')
       .batch(1)
       .wait(true)
       .timeoutMillis(500)

package/test-v2/stream/combined.js

@@ -58,7 +58,8 @@ export async function combinedFullPipeline(client) {
       url: STREAMS_URL,
       batchSize: 100,
       maxPartitions: 4,
-      reset: true
+      reset: true,
+      subscriptionMode: 'all'
     })
 
   // Wait long enough for windowEnd to pass + idle flush to close all 3
@@ -117,8 +118,8 @@ export async function combinedTwoConcurrentStreams(client) {
     .to(client.queue(sinkB))
 
   const [handleA, handleB] = await Promise.all([
-    streamA.run({ queryId: qA, url: STREAMS_URL, batchSize: 50, reset: true }),
-    streamB.run({ queryId: qB, url: STREAMS_URL, batchSize: 50, reset: true })
+    streamA.run({ queryId: qA, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' }),
+    streamB.run({ queryId: qB, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
   ])
 
   // Wait until the FULL totals are present on each sink. Each stream sees

package/test-v2/stream/cron.js

@@ -81,7 +81,7 @@ export async function cronEverySecondLive(client) {
     .windowCron({ every: 'second', idleFlushMs: 500 })
     .aggregate({ count: () => 1 })
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   await pushPromise
   const emits = await drainUntil(client, sink, {

package/test-v2/stream/eventTime.js

@@ -47,7 +47,7 @@ export async function eventTimeBucketsByExtractor(client) {
     .aggregate({ count: () => 1, sum: m => m.v })
     .map((agg, ctx) => ({ windowKey: ctx.windowKey, ...agg }))
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   // The 10:00 window closes when the 10:01:05 event advances the
   // watermark past its end. The 10:01 window stays open until either
@@ -85,7 +85,10 @@ export async function eventTimeLateDropExcludesEvent(client) {
   await client.queue(src).create()
   await client.queue(sink).create()
 
-  // Run 1: advance the watermark by emitting a fresh event.
+  // Run 1: advance the watermark by emitting a fresh event. The push happens
+  // before the runner's consumer group exists, so run 1 asks for 'all' — with
+  // the broker default of 'new' the watermark never moves and the "late"
+  // event in run 2 is not late at all.
   await client.queue(src).partition('p').push([
     { data: { v: 100, eventTs: '2026-01-01T11:00:00Z' } }
   ])
@@ -103,7 +106,7 @@ export async function eventTimeLateDropExcludesEvent(client) {
     .to(client.queue(sink))
     .run(handler)
 
-  const handle1 = await buildStream({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+  const handle1 = await buildStream({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
   await sleep(2000)
   await handle1.stop()
 
@@ -150,7 +153,7 @@ export async function eventTimeAllowedLatenessIncluded(client) {
     .to(client.queue(sink))
     .run(handler)
 
-  const handle1 = await buildStream({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+  const handle1 = await buildStream({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
   await sleep(2000)
   await handle1.stop()
 
@@ -202,7 +205,7 @@ export async function eventTimeLateIncludePolicy(client) {
     .to(client.queue(sink))
     .run(handler)
 
-  const handle1 = await buildStream({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+  const handle1 = await buildStream({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
   await sleep(2000)
   await handle1.stop()
 

package/test-v2/stream/operators.js

@@ -35,7 +35,7 @@ export async function streamMapFilterSink(client) {
     .filter(m => m.data.type !== 'heartbeat')
     .map(m => ({ ...m.data, marked: true }))
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 100, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 100, reset: true, subscriptionMode: 'all' })
 
   // 20 messages should land on the sink (10 orders + 10 logs).
   const drained = await drainUntil(client, sink, {
@@ -81,7 +81,7 @@ export async function streamFlatMapFanout(client) {
       { id: m.data.id, copy: 4 }
     ])
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 100, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 100, reset: true, subscriptionMode: 'all' })
 
   const drained = await drainUntil(client, sink, {
     until: out => out.length >= 20,
@@ -114,7 +114,7 @@ export async function streamForeachCapturesAll(client) {
   const handle = await Stream
     .from(client.queue(src))
     .foreach((value) => { captured.push(value) })
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   // Wait until at-least-once semantics catch up to 12 messages.
   const start = Date.now()
@@ -152,7 +152,7 @@ export async function streamKeyByDoesNotCrash(client) {
     .keyBy(m => m.data.region)
     .map(m => m.data)
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 100, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 100, reset: true, subscriptionMode: 'all' })
 
   const drained = await drainUntil(client, sink, {
     until: out => out.length >= 6,
@@ -192,7 +192,7 @@ export async function streamAsyncMap(client) {
       return { ...m.data, asyncEnriched: true }
     })
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 100, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 100, reset: true, subscriptionMode: 'all' })
 
   const drained = await drainUntil(client, sink, {
     until: out => out.length >= 5,

package/test-v2/stream/recovery.js

@@ -113,7 +113,10 @@ export async function recoveryMidStreamResume(client) {
   for (let i = 0; i < 5; i++) {
     await client.queue(src).partition('p').push([{ data: { v: 1 } }])
   }
-  const handle1 = await buildStream({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+  // Run 1 creates the source consumer group AFTER the pushes, so it has to
+  // ask for the backlog. Run 2 reuses the same group and resumes from its
+  // stored cursor — the mode is only consulted on a group's first contact.
+  const handle1 = await buildStream({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
   // Wait for at least one closed-window emit.
   await drainUntil(client, sink, { until: out => out.length >= 1, timeoutMs: 5000 })
   await handle1.stop()

package/test-v2/stream/session.js

@@ -38,7 +38,7 @@ export async function sessionGapClosesAndStartsNew(client) {
     .windowSession({ gap: 2, idleFlushMs: 500 })
     .aggregate({ count: () => 1, sum: m => m.v })
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   await pushPromise
   // Wait for idle flush to close the second (still-open) session.
@@ -80,7 +80,7 @@ export async function sessionIdleFlushClosesQuietSession(client) {
     .windowSession({ gap: 1, idleFlushMs: 500 })
     .aggregate({ count: () => 1, sum: m => m.v })
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   // Wait for gap + flush to elapse.
   const emits = await drainUntil(client, sink, {
@@ -125,7 +125,7 @@ export async function sessionMultipleKeysIndependent(client) {
     .aggregate({ count: () => 1, sum: m => m.v })
     .map((v, ctx) => ({ user: ctx.key, ...v }))
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   const emits = await drainUntil(client, sink, {
     until: out => out.length >= 2, timeoutMs: 8000

package/test-v2/stream/sliding.js

@@ -55,7 +55,7 @@ export async function slidingEventsAppearInOverlappingWindows(client) {
     .windowSliding({ size: 4, slide: 2, idleFlushMs: 1000 })
     .aggregate({ count: () => 1, sum: m => m.v })
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   await itemPushPromise
   // Allow idle flush to close trailing windows.

package/test-v2/stream/throughput.js

@@ -58,7 +58,8 @@ export async function throughput5kAcross20Partitions(client) {
       url: STREAMS_URL,
       batchSize: 200,
       maxPartitions: 8,
-      reset: true
+      reset: true,
+      subscriptionMode: 'all'
     })
 
   // Wait until we have at least 20 partition emits — possibly more if
@@ -130,7 +131,7 @@ export async function throughputManyWindowsSinglePartition(client) {
     .windowTumbling({ seconds: 1, idleFlushMs: 600 })
     .aggregate({ count: () => 1, sum: m => m.v })
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   // Wait for all 200 messages to be reflected in emits.
   const emits = await drainUntil(client, sink, {

package/test-v2/stream/tumbling.js

@@ -39,7 +39,7 @@ export async function tumblingBasicWindowSum(client) {
     .windowTumbling({ seconds: 2, idleFlushMs: 800 })
     .aggregate({ count: () => 1, sum: m => m.amount })
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   await itemPushPromise
   // Wait until the total count across all emits = 8 (idle flush must
@@ -94,7 +94,7 @@ export async function tumblingPerPartitionIsolation(client) {
     .aggregate({ count: () => 1, sum: m => m.amount })
     .map((agg, ctx) => ({ partition: ctx.partition, ...agg }))
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, maxPartitions: 4, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, maxPartitions: 4, reset: true, subscriptionMode: 'all' })
 
   await itemPushPromise
   // Wait until total count across all emits = 18 (3 customers × 6 events).
@@ -168,7 +168,7 @@ export async function tumblingAggregateAllStats(client) {
       avg:   m => m.v
     })
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   // Wait for idle flush to fire and emit the closed window (3s + grace + slack).
   const emits = await drainUntil(client, sink, {
@@ -216,7 +216,7 @@ export async function tumblingGracePeriodDelaysClose(client) {
     .windowTumbling({ seconds: 2, gracePeriod: 4, idleFlushMs: 500 })
     .aggregate({ count: () => 1, sum: m => m.v })
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   // After ~3s the window's end is past, but grace=4s means it should NOT
   // be closed yet (close at ~ windowStart + 2 + 4 = 6s after first event).
@@ -265,7 +265,7 @@ export async function tumblingIdleFlushClosesQuietPartitions(client) {
     .windowTumbling({ seconds: 1, idleFlushMs: 700 })
     .aggregate({ count: () => 1, sum: m => m.v })
     .to(client.queue(sink))
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   // Wait for idle flush to fire.
   const emits = await drainUntil(client, sink, {
@@ -300,7 +300,7 @@ export async function tumblingForeachCtxHasWindowAndPartition(client) {
     .windowTumbling({ seconds: 1, idleFlushMs: 700 })
     .aggregate({ count: () => 1, sum: m => m.v })
     .foreach((value, ctx) => { captured.push({ value, ctx }) })
-    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true })
+    .run({ queryId, url: STREAMS_URL, batchSize: 50, reset: true, subscriptionMode: 'all' })
 
   const start = Date.now()
   while (captured.length < 1 && Date.now() - start < 8000) await sleep(100)

package/test-v2/timers.js

@@ -0,0 +1,209 @@
+/**
+ * Timer integration suite (PLAN_KV_TIMERS.md §4, §9.6, §20.2).
+ *
+ * Repeatable only because run.js purges `queen.log_timers` for the `test-%`
+ * queues before the run: a pending timer left behind by a previous run fires
+ * into the queue of the next one and shows up as a phantom message in an
+ * unrelated test.
+ *
+ * Every delay here is either short (it is meant to fire) or minutes long (it is
+ * meant not to). Nothing in this file schedules anything that outlives the
+ * suite.
+ */
+
+import { TIMER_QUEUE, popUntil } from './_kvtimers.js'
+
+export async function timerSchedulesAndFires(client) {
+  const queueName = `${TIMER_QUEUE}-fire`
+  const queue = await client.queue(queueName).create()
+  if (!queue.configured) return { success: false, message: 'Queue not created' }
+
+  // A per-run marker, so a message left in this queue by an earlier run can
+  // never be mistaken for this run's delivery. It is the one place in these
+  // suites where per-run uniqueness is right: the assertion is about THIS
+  // timer's identity, and the purge cannot be relied on to prove identity.
+  const run = `fire-${Date.now()}`
+  const res = await client.timer(queueName)
+    .key('fire-1')
+    .delay('500ms')
+    .payload({ kind: 'reminder', run })
+    .schedule()
+
+  if (res.status !== 'scheduled' || !res.messageId || !res.deliverAt) {
+    return { success: false, message: `schedule answered ${JSON.stringify(res)}` }
+  }
+
+  // deliverAt is "not before", never "exactly at", and the visibility of a
+  // fired timer to a consumer is bounded by the hot-list reseed, not by the
+  // delay -- see popUntil, which measured it. The assertion is arrival.
+  const mine = await popUntil(client, queueName, m => m.data && m.data.run === run)
+
+  if (mine.length !== 1) {
+    return { success: false, message: 'the scheduled timer was never delivered into the queue' }
+  }
+  // The two identifiers promised at schedule time are the two the delivered
+  // frame carries -- which is what lets a client correlate without a second API.
+  if (mine[0].transactionId !== res.txn) {
+    return { success: false, message: `delivered txn ${mine[0].transactionId} != promised ${res.txn}` }
+  }
+  if (mine[0].id !== res.messageId) {
+    return { success: false, message: `delivered messageId ${mine[0].id} != promised ${res.messageId}` }
+  }
+
+  await client.ack(mine[0])
+  return { success: true, message: 'a scheduled timer was delivered carrying the txn and messageId promised at schedule time' }
+}
+
+export async function timerCancelBeforeFire(client) {
+  const queueName = `${TIMER_QUEUE}-cancel`
+  const queue = await client.queue(queueName).create()
+  if (!queue.configured) return { success: false, message: 'Queue not created' }
+
+  await client.timer(queueName).key('cancel-1').delay('30m').payload({ n: 1 }).schedule()
+
+  const pending = await client.timer(queueName).key('cancel-1').peek()
+  if (pending.found !== true) {
+    return { success: false, message: `peek did not find the pending timer: ${JSON.stringify(pending)}` }
+  }
+
+  const cancelled = await client.timer(queueName).key('cancel-1').cancel()
+  const gone = await client.timer(queueName).key('cancel-1').peek()
+
+  const ok = cancelled.ok === true && cancelled.status === 'cancelled' && gone.found === false
+  return {
+    success: ok,
+    message: ok
+      ? 'a pending timer was peeked, cancelled and is gone'
+      : `cancel=${JSON.stringify(cancelled)} peek=${JSON.stringify(gone)}`
+  }
+}
+
+/**
+ * §4.4, the point where a user gets hurt: there is no tombstone. A cancel on
+ * something that is not pending answers `absent` with **ok:false**, and echoes
+ * the txn so the log -- the only authority on "did it already go out?" -- can
+ * be consulted without a second API.
+ */
+export async function timerCancelAbsentCarriesOkFalseAndTheTxn(client) {
+  const queueName = `${TIMER_QUEUE}-absent`
+  const expected = 'txn-that-may-already-have-been-delivered'
+  const res = await client.timer(queueName).key('never-scheduled').txn(expected).cancel()
+
+  const ok = res.ok === false && res.status === 'absent' && res.txn === expected
+  return {
+    success: ok,
+    message: ok
+      ? 'absent answers ok:false and hands back the txn to check against the log'
+      : JSON.stringify(res)
+  }
+}
+
+/**
+ * §20.2: a reschedule is an UPSERT that mints a new txn, because a rescheduled
+ * timer is a new message. The corollary belongs in the docs, not in an
+ * assertion: there is no dedup net on the fire, so rescheduling one that has
+ * already gone out produces a second message.
+ */
+export async function timerRescheduleOverwritesTheTxn(client) {
+  const queueName = `${TIMER_QUEUE}-resched`
+  const queue = await client.queue(queueName).create()
+  if (!queue.configured) return { success: false, message: 'Queue not created' }
+
+  const first = await client.timer(queueName).key('resched-1').delay('30m').payload({ v: 1 }).schedule()
+  const second = await client.timer(queueName).key('resched-1').delay('45m').payload({ v: 2 }).schedule()
+  const pending = await client.timer(queueName).key('resched-1').peek()
+
+  const ok = first.status === 'scheduled'
+    && second.status === 'rescheduled'
+    && second.txn !== first.txn
+    && pending.found === true
+    && pending.txn === second.txn
+
+  return {
+    success: ok,
+    message: ok
+      ? 'the second schedule upserted the same key, reported "rescheduled" and replaced the txn'
+      : `first=${JSON.stringify(first)} second=${JSON.stringify(second)} peek=${JSON.stringify(pending)}`
+  }
+}
+
+export async function timerListIsKeysetOverOneQueue(client) {
+  const queueName = `${TIMER_QUEUE}-list`
+  const queue = await client.queue(queueName).create()
+  if (!queue.configured) return { success: false, message: 'Queue not created' }
+
+  for (const k of ['list-a', 'list-b', 'list-c']) {
+    await client.timer(queueName).key(k).delay('30m').payload({ k }).schedule()
+  }
+
+  const page1 = await client.timer(queueName).list({ limit: 2 })
+  if (page1.rows.length !== 2 || page1.truncated !== true || !page1.nextAfter) {
+    return { success: false, message: `first page: ${JSON.stringify(page1)}` }
+  }
+
+  const page2 = await client.timer(queueName).list({ after: page1.nextAfter, limit: 2 })
+  const keys = [...page1.rows, ...page2.rows].map(r => r.timerKey)
+
+  const ok = keys.length === 3 && keys.join(',') === 'list-a,list-b,list-c'
+  return {
+    success: ok,
+    message: ok
+      ? 'list pages over one queue on an exclusive keyset cursor'
+      : `saw ${JSON.stringify(keys)}`
+  }
+}
+
+/**
+ * The timer as a rider of a transaction: it commits with the push, in the same
+ * transaction, or not at all. This is the shape a saga uses -- schedule the
+ * compensation together with the work that may need compensating.
+ */
+export async function timerRidesTheTransaction(client) {
+  const queueName = `${TIMER_QUEUE}-txn`
+  const queue = await client.queue(queueName).create()
+  if (!queue.configured) return { success: false, message: 'Queue not created' }
+
+  const res = await client.transaction()
+    .queue(queueName)
+    .push([{ data: { step: 'reserved' } }])
+    .timer(queueName).key('compensate-1').delay('30m').payload({ step: 'compensate' }).schedule()
+    .commit()
+
+  if (res.success !== true) {
+    return { success: false, message: `the bundle should commit: ${JSON.stringify(res)}` }
+  }
+
+  const pending = await client.timer(queueName).key('compensate-1').peek()
+  const cancelled = await client.timer(queueName).key('compensate-1').cancel()
+
+  const ok = pending.found === true && cancelled.ok === true
+  return {
+    success: ok,
+    message: ok
+      ? 'a timer scheduled inside a transaction is pending after the commit'
+      : `peek=${JSON.stringify(pending)} cancel=${JSON.stringify(cancelled)}`
+  }
+}
+
+/**
+ * A delay in the past is LEGAL and fires on the first cycle (§4.2). It is also
+ * the cheapest end-to-end proof that the sweeper is running at all.
+ */
+export async function timerWithAPastDelayFiresImmediately(client) {
+  const queueName = `${TIMER_QUEUE}-past`
+  const queue = await client.queue(queueName).create()
+  if (!queue.configured) return { success: false, message: 'Queue not created' }
+
+  const run = `past-${Date.now()}`
+  await client.timer(queueName).key('past-1').delayMs(-5000).payload({ late: true, run }).schedule()
+
+  const mine = await popUntil(client, queueName, m => m.data && m.data.run === run)
+  if (mine.length === 1) await client.ack(mine[0])
+
+  return {
+    success: mine.length === 1,
+    message: mine.length === 1
+      ? 'a delayMs in the past fired on the first sweep cycle'
+      : 'the late timer was never delivered'
+  }
+}

package/test-v2/transaction.js

@@ -14,14 +14,12 @@ export async function transactionBasicPushAck(client) {
         return { success: false, message: 'No message to consume' }
     }
 
-    // docs:start(js-transaction)
     await client
         .transaction()
         .queue('test-queue-v2-txn-basic-b')
         .push([{ data: { value: messages[0].data.value + 1 } }])
         .ack(messages[0])
         .commit()
-    // docs:end
 
     // Verify message moved to B
     const resultB = await client.queue('test-queue-v2-txn-basic-b').batch(1).wait(false).pop()
@@ -520,9 +518,11 @@ export async function transactionAckWithConsumerGroup(client) {
         { data: { value: 2 } }
     ])
 
-    // Pop with consumer group
+    // Pop with consumer group. Both groups here are created after the push,
+    // so they must ask for 'all' to see the backlog under test.
     const messages = await client.queue('test-queue-v2-txn-cg-a')
         .group(consumerGroup)
+        .subscriptionMode('all')
         .batch(2)
         .wait(false)
         .pop()
@@ -554,6 +554,7 @@ export async function transactionAckWithConsumerGroup(client) {
     // Verify: Using a different consumer group should still see the messages
     const messagesOtherGroup = await client.queue('test-queue-v2-txn-cg-a')
         .group('other-consumer-group')
+        .subscriptionMode('all')
         .batch(2)
         .wait(false)
         .pop()