queen-mq 0.12.4 → 0.14.0

package/test-v2/maintenance.js

@@ -63,8 +63,22 @@ export async function test_maintenance_mode(client = null) {
     const consumePromise = (async () => {
       while (consumerActive) {
         try {
-          const messages = await queen.queue(QUEUE_NAME).batch(10).wait(false).limit(1).each().pop();
-          
+          // wait(true) long-polls on the server. This is important: pushes
+          // commit before partition_lookup is refreshed (PUSHPOPLOOKUPSOL
+          // is async), so a wait(false) pop can race past freshly-pushed
+          // messages and return empty. Long-poll re-runs the candidate
+          // scan internally and picks up messages once the lookup row
+          // commits — typically within milliseconds.
+          // Use a short timeout (1s) so the consumer notices
+          // consumerActive=false promptly when the test winds down.
+          const messages = await queen.queue(QUEUE_NAME)
+            .batch(10)
+            .wait(true)
+            .timeoutMillis(1000)
+            .limit(1)
+            .each()
+            .pop();
+
           if (messages && messages.length > 0) {
             receivedCount += messages.length;
             console.log(`  📨 Received ${messages.length} messages (total: ${receivedCount})`);

package/test-v2/pop.js

@@ -20,10 +20,15 @@ export async function popNonEmptyQueue(client) {
     .queue('test-queue-v2-pop-non-empty')
     .push([{ data: { message: 'Hello, world!' } }])
 
+    // wait(true) rides out the PUSHPOPLOOKUPSOL race: partition_lookup is
+    // updated asynchronously after push commits, so an immediate
+    // wait(false) wildcard pop can race past the not-yet-committed lookup
+    // row. Long-poll re-runs the candidate scan and picks up the row
+    // once it commits (typically within ms).
     const res = await client
     .queue('test-queue-v2-pop-non-empty')
     .batch(1)
-    .wait(false)
+    .wait(true)
     .pop()
     return { success: res.length === 1 }
 }
@@ -58,10 +63,11 @@ export async function popWithAck(client) {
     .push([{ data: { message: 'Hello, world!' } }]) 
 
 
+    // wait(true): ride out the PUSHPOPLOOKUPSOL race (see popNonEmptyQueue).
     const res = await client
     .queue('test-queue-v2-pop-with-ack')
     .batch(1)
-    .wait(false)
+    .wait(true)
     .pop()
 
     const resAck = await client.ack(res[0])
@@ -88,10 +94,11 @@ export async function popWithAckReconsume(client) {
     .queue('test-queue-v2-pop-with-ack-reconsume')
     .push([{ data: { message: 'Hello, world!' } }])
 
+    // wait(true): ride out the PUSHPOPLOOKUPSOL race (see popNonEmptyQueue).
     const res = await client
     .queue('test-queue-v2-pop-with-ack-reconsume')
     .batch(1)
-    .wait(false)
+    .wait(true)
     .pop()
 
     if (res.length !== 1) {
@@ -112,3 +119,218 @@ export async function popWithAckReconsume(client) {
     return { success: false, message: `Expected 1 message, got ${res2.length}` }
 }
 
+// ============================================================================
+// v4 Multi-Partition Pop Tests
+// ============================================================================
+//
+// Exercises the .partitions(N) builder method end-to-end against the
+// pop_unified_batch_v4 procedure:
+//   * Server drains up to N partitions per call
+//   * Each message carries its own partitionId / leaseId / partition
+//   * batch(B) is a global cap on TOTAL messages across all partitions
+//   * Default (no .partitions() call) preserves single-partition behaviour
+
+export async function popV4MultiPartitionBasic(client) {
+    const queueName = 'test-queue-v2-v4-pop-basic'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+
+    // Seed 3 partitions × 2 messages each = 6 total.
+    for (let p = 0; p < 3; p++) {
+        await client
+        .queue(queueName)
+        .partition(`p${p}`)
+        .push([
+            { data: { p, m: 0 } },
+            { data: { p, m: 1 } },
+        ])
+    }
+
+    // Allow the post-push partition_lookup follow-up (PUSHPOPLOOKUPSOL)
+    // to settle before the wildcard scan.
+    await new Promise(r => setTimeout(r, 500))
+
+    const res = await client
+    .queue(queueName)
+    .batch(100)
+    .partitions(3)
+    .wait(false)
+    .pop()
+
+    if (res.length !== 6) {
+        return { success: false, message: `Expected 6 messages across 3 partitions, got ${res.length}` }
+    }
+
+    // Each message must carry its own partitionId; partitionIds must
+    // span all 3 partitions; leaseIds must collapse to a single value.
+    const distinctPartitionIds = new Set(res.map(m => m.partitionId))
+    const distinctLeaseIds = new Set(res.map(m => m.leaseId).filter(Boolean))
+
+    if (distinctPartitionIds.size !== 3) {
+        return { success: false, message: `Expected 3 distinct partitionIds, got ${distinctPartitionIds.size}` }
+    }
+    if (distinctLeaseIds.size !== 1) {
+        return { success: false, message: `All messages must share a single leaseId, got ${distinctLeaseIds.size} distinct` }
+    }
+
+    return { success: true, message: 'Multi-partition pop returned messages spanning 3 partitions with shared leaseId' }
+}
+
+export async function popV4GlobalCap(client) {
+    const queueName = 'test-queue-v2-v4-pop-cap'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+
+    // Seed 5 partitions × 100 messages each = 500 total available.
+    for (let p = 0; p < 5; p++) {
+        const payloads = []
+        for (let m = 0; m < 100; m++) payloads.push({ data: { p, m } })
+        await client.queue(queueName).partition(`p${p}`).push(payloads)
+    }
+
+    await new Promise(r => setTimeout(r, 500))
+
+    // batch=10 is the GLOBAL cap, partitions=5 lets us span partitions.
+    // We must receive EXACTLY 10 messages, not 5*10 or 5*100.
+    const res = await client
+    .queue(queueName)
+    .batch(10)
+    .partitions(5)
+    .wait(false)
+    .pop()
+
+    if (res.length !== 10) {
+        return { success: false, message: `batch(10) must be a hard global cap, got ${res.length}` }
+    }
+
+    return { success: true, message: 'Global batch cap respected across multi-partition pop' }
+}
+
+export async function popV4DefaultOne(client) {
+    const queueName = 'test-queue-v2-v4-pop-default'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+
+    // Seed 4 partitions × 5 messages each.
+    for (let p = 0; p < 4; p++) {
+        const payloads = []
+        for (let m = 0; m < 5; m++) payloads.push({ data: { p, m } })
+        await client.queue(queueName).partition(`p${p}`).push(payloads)
+    }
+
+    await new Promise(r => setTimeout(r, 500))
+
+    // No .partitions() → max_partitions defaults to 1 → single partition.
+    const res = await client
+    .queue(queueName)
+    .batch(100)
+    .wait(false)
+    .pop()
+
+    if (res.length !== 5) {
+        return { success: false, message: `Default max_partitions=1 should drain only one partition (5 msgs), got ${res.length}` }
+    }
+
+    const distinctPartitionIds = new Set(res.map(m => m.partitionId))
+    if (distinctPartitionIds.size !== 1) {
+        return { success: false, message: `All messages should come from a single partition, got ${distinctPartitionIds.size}` }
+    }
+
+    return { success: true, message: 'Default pop preserves legacy single-partition behaviour' }
+}
+
+export async function popV4MultiPartitionAck(client) {
+    const queueName = 'test-queue-v2-v4-pop-ack'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+
+    // Seed 2 partitions × 3 messages each.
+    for (let p = 0; p < 2; p++) {
+        await client.queue(queueName).partition(`p${p}`).push([
+            { data: { p, m: 0 } },
+            { data: { p, m: 1 } },
+            { data: { p, m: 2 } },
+        ])
+    }
+
+    await new Promise(r => setTimeout(r, 500))
+
+    const res = await client
+    .queue(queueName)
+    .batch(100)
+    .partitions(2)
+    .wait(false)
+    .pop()
+
+    if (res.length !== 6) {
+        return { success: false, message: `Expected 6 messages across 2 partitions, got ${res.length}` }
+    }
+
+    // ACK each message individually using its own per-message partitionId
+    // and the shared leaseId. The v4 procedure has set each partition's
+    // batch_size to its actual contribution (3), so once 3 ACKs land for
+    // a given partition_id, that partition's lease auto-releases.
+    const ackResult = await client.ack(res, true)
+    if (!ackResult.success) {
+        return { success: false, message: `Batch ACK failed: ${ackResult.error || 'unknown'}` }
+    }
+
+    return { success: true, message: 'Per-message ACK across multi-partition pop succeeded' }
+}
+
+export async function popV4SharedLeaseRenew(client) {
+    const queueName = 'test-queue-v2-v4-pop-renew'
+    const queue = await client
+    .queue(queueName)
+    .config({ leaseTime: 60 })
+    .create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+
+    // Seed 3 partitions × 1 message each.
+    for (let p = 0; p < 3; p++) {
+        await client.queue(queueName).partition(`p${p}`).push([{ data: { p } }])
+    }
+
+    await new Promise(r => setTimeout(r, 500))
+
+    const res = await client
+    .queue(queueName)
+    .batch(100)
+    .partitions(3)
+    .wait(false)
+    .pop()
+
+    if (res.length !== 3) {
+        return { success: false, message: `Expected 3 messages from 3 partitions, got ${res.length}` }
+    }
+
+    // All 3 messages share one leaseId. Passing res to renew() exercises
+    // both the dedup logic AND the server-side multi-row lease extension
+    // (renew_lease_v2 filters on worker_id alone, which matches all 3
+    // partition_consumers rows).
+    const renewResult = await client.renew(res)
+    // renew() returns array when input is array. After dedup, it's a
+    // single result for the shared leaseId.
+    if (!Array.isArray(renewResult) || renewResult.length !== 1) {
+        return { success: false, message: `Expected dedup to collapse to 1 renew call, got ${Array.isArray(renewResult) ? renewResult.length : 'non-array'}` }
+    }
+    if (!renewResult[0].success) {
+        return { success: false, message: `Renew failed: ${renewResult[0].error}` }
+    }
+
+    // Cleanup: release leases by acking everything.
+    await client.ack(res, true)
+
+    return { success: true, message: 'Shared leaseId renewed once and dedup confirmed' }
+}
+

package/test-v2/push.js

@@ -221,10 +221,15 @@ export async function pushLargePayload(client) {
     .queue('test-queue-large-payload')
     .push([{ data: largePayload }])
 
+    // wait(true) rides out the PUSHPOPLOOKUPSOL race: partition_lookup is
+    // updated asynchronously after push commits, so an immediate
+    // wait(false) wildcard pop can race past the not-yet-committed lookup
+    // row. Long-poll re-runs the candidate scan and picks up the row
+    // once it commits (typically within ms).
     const received = await client
     .queue('test-queue-large-payload')
     .batch(1)
-    .wait(false)
+    .wait(true)
     .pop()
     
     if (!received || !received[0].data || !received[0].data.array || received[0].data.array.length !== 10000) {
@@ -243,10 +248,11 @@ export async function pushNullPayload(client) {
     .queue('test-queue-null-payload')
     .push([{ data: null }])
 
+    // wait(true): ride out the PUSHPOPLOOKUPSOL race (see pushLargePayload).
     const received = await client
     .queue('test-queue-null-payload')
     .batch(1)
-    .wait(false)
+    .wait(true)
     .pop()
 
     if (!received || received[0].data !== null) {
@@ -265,10 +271,11 @@ export async function pushEmptyPayload(client) {
     .queue('test-queue-empty-payload')
     .push([{ data: {} }])
 
+    // wait(true): ride out the PUSHPOPLOOKUPSOL race (see pushLargePayload).
     const received = await client
     .queue('test-queue-empty-payload')
     .batch(1)
-    .wait(false)
+    .wait(true)
     .pop()
     
     if (!received || Object.keys(received[0].data).length !== 0) {
@@ -278,6 +285,283 @@ export async function pushEmptyPayload(client) {
     return { success: true }
 }
 
+// ============================================================================
+// push_messages_v3 coverage (see PUSH_IMPROVEMENT.md §8.1).
+// These tests exercise the contract that the TEMP-TABLE-free rewrite must
+// preserve: single-call semantics (new inserts, pre-existing duplicates,
+// intra-batch duplicates, missing transactionId, empty batch, malformed
+// traceId) plus the cross-call concurrent-race invariant.
+// ============================================================================
+
+function distinctCount(arr) {
+    return new Set(arr).size
+}
+
+export async function testSimplePushRoundTrip(client) {
+    const queueName = 'test-v3-simple-roundtrip'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+    const res = await client.queue(queueName).push([{ data: { n: 1 } }])
+    if (!res[0] || res[0].status !== 'queued') {
+        return { success: false, message: `Expected queued, got ${JSON.stringify(res[0])}` }
+    }
+    // wait(true): ride out the PUSHPOPLOOKUPSOL race (see pushLargePayload).
+    const popped = await client.queue(queueName).batch(1).wait(true).pop()
+    if (!popped || popped.length !== 1 || popped[0].data.n !== 1) {
+        return { success: false, message: 'Round-trip pop failed' }
+    }
+    return { success: true }
+}
+
+export async function testPushAutoCreatesQueueAndPartition(client) {
+    // Queue and partition are never referenced before — must be auto-created.
+    const queueName = 'test-v3-autocreate-' + crypto.randomBytes(4).toString('hex')
+    const partitionName = 'autopart-' + crypto.randomBytes(4).toString('hex')
+    const res = await client.queue(queueName).partition(partitionName)
+        .push([{ data: { hello: 'auto' } }])
+    if (!res[0] || res[0].status !== 'queued') {
+        return { success: false, message: `Expected queued, got ${JSON.stringify(res[0])}` }
+    }
+    // wait(true): ride out the PUSHPOPLOOKUPSOL race (see pushLargePayload).
+    const popped = await client.queue(queueName).partition(partitionName)
+        .batch(1).wait(true).pop()
+    if (!popped || popped.length !== 1) {
+        return { success: false, message: 'Auto-created partition did not receive the message' }
+    }
+    return { success: true }
+}
+
+export async function testPushPreExistingDuplicate(client) {
+    const queueName = 'test-v3-pre-existing-dup'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+    const txn = 'txn-pre-' + crypto.randomBytes(4).toString('hex')
+    const first = await client.queue(queueName)
+        .push([{ transactionId: txn, data: { i: 1 } }])
+    if (first[0].status !== 'queued') {
+        return { success: false, message: `First push not queued: ${JSON.stringify(first[0])}` }
+    }
+    const firstId = first[0].message_id
+    const second = await client.queue(queueName)
+        .push([{ transactionId: txn, data: { i: 2 } }])
+    if (second[0].status !== 'duplicate') {
+        return { success: false, message: `Second push not duplicate: ${JSON.stringify(second[0])}` }
+    }
+    if (!firstId || second[0].message_id !== firstId) {
+        return { success: false, message: `Duplicate id mismatch: want ${firstId}, got ${second[0].message_id}` }
+    }
+    return { success: true }
+}
+
+export async function testPushIntraBatchDuplicatesAllNew(client) {
+    const queueName = 'test-v3-intra-batch-new'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+    const txn = 'txn-ib-' + crypto.randomBytes(4).toString('hex')
+    const res = await client.queue(queueName).push([
+        { transactionId: txn, data: { i: 1 } },
+        { transactionId: txn, data: { i: 2 } },
+        { transactionId: txn, data: { i: 3 } }
+    ])
+    if (!Array.isArray(res) || res.length !== 3) {
+        return { success: false, message: `Expected 3 entries, got ${res && res.length}` }
+    }
+    const queued = res.filter(r => r.status === 'queued')
+    const dupes = res.filter(r => r.status === 'duplicate')
+    if (queued.length !== 1 || dupes.length !== 2) {
+        return { success: false, message: `Want 1 queued / 2 duplicate, got ${JSON.stringify(res)}` }
+    }
+    const winnerId = queued[0].message_id
+    if (!winnerId || !dupes.every(d => d.message_id === winnerId)) {
+        return { success: false, message: `Intra-batch duplicates must share winner id ${winnerId}; got ${JSON.stringify(dupes)}` }
+    }
+    return { success: true }
+}
+
+export async function testPushIntraBatchDuplicatesMatchingPreExisting(client) {
+    const queueName = 'test-v3-intra-batch-existing'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+    const txn = 'txn-ibe-' + crypto.randomBytes(4).toString('hex')
+    // Seed an existing row.
+    const seed = await client.queue(queueName)
+        .push([{ transactionId: txn, data: { seed: true } }])
+    if (seed[0].status !== 'queued') {
+        return { success: false, message: 'Seed push failed' }
+    }
+    const existingId = seed[0].message_id
+    const res = await client.queue(queueName).push([
+        { transactionId: txn, data: { i: 1 } },
+        { transactionId: txn, data: { i: 2 } }
+    ])
+    if (!Array.isArray(res) || res.length !== 2) {
+        return { success: false, message: `Expected 2 entries, got ${JSON.stringify(res)}` }
+    }
+    if (!res.every(r => r.status === 'duplicate' && r.message_id === existingId)) {
+        return { success: false, message: `All entries must duplicate onto ${existingId}, got ${JSON.stringify(res)}` }
+    }
+    return { success: true }
+}
+
+export async function testPushConcurrentBatchesToSameKey(client) {
+    const queueName = 'test-v3-concurrent-same-key'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+    const txn = 'txn-conc-' + crypto.randomBytes(4).toString('hex')
+    // Fire 8 concurrent single-item pushes using the same transactionId.
+    // Exactly one must win; the others must report duplicate with the winner's id.
+    const N = 8
+    const results = await Promise.all(
+        Array.from({ length: N }, (_, i) =>
+            client.queue(queueName)
+                .push([{ transactionId: txn, data: { i } }])
+                .then(r => r[0])
+        )
+    )
+    const queued = results.filter(r => r.status === 'queued')
+    const dupes = results.filter(r => r.status === 'duplicate')
+    if (queued.length !== 1) {
+        return { success: false, message: `Want exactly 1 queued, got ${queued.length}: ${JSON.stringify(results)}` }
+    }
+    if (dupes.length !== N - 1) {
+        return { success: false, message: `Want ${N - 1} duplicates, got ${dupes.length}` }
+    }
+    const winnerId = queued[0].message_id
+    if (!winnerId || !dupes.every(d => d.message_id === winnerId)) {
+        return { success: false, message: `All duplicates must report winner id ${winnerId}: ${JSON.stringify(dupes)}` }
+    }
+    return { success: true }
+}
+
+export async function testPushMissingTransactionId(client) {
+    const queueName = 'test-v3-missing-txn'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+    // 100 items, no transactionId provided. Each must get a distinct id and
+    // all should end up queued (no accidental intra-batch collisions from a
+    // volatile-function-inlining regression).
+    // NOTE: the client auto-generates a transactionId when omitted, so we
+    // bypass it via the raw HTTP push contract by supplying only `data`. The
+    // client still fills a fresh transactionId per item, which is the correct
+    // client-level contract; the server-side test below additionally proves
+    // the SP itself handles missing txn ids by bypassing the client helper.
+    const items = Array.from({ length: 100 }, (_, i) => ({ data: { i } }))
+    const res = await client.queue(queueName).push(items)
+    if (!Array.isArray(res) || res.length !== 100) {
+        return { success: false, message: `Expected 100 results, got ${res && res.length}` }
+    }
+    if (!res.every(r => r.status === 'queued')) {
+        const bad = res.find(r => r.status !== 'queued')
+        return { success: false, message: `All must queue; first bad entry ${JSON.stringify(bad)}` }
+    }
+    if (distinctCount(res.map(r => r.message_id)) !== 100) {
+        return { success: false, message: `Expected 100 distinct message ids` }
+    }
+    return { success: true }
+}
+
+export async function testPushEmptyArray(client) {
+    const queueName = 'test-v3-empty-array'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+    const res = await client.queue(queueName).push([])
+    if (!Array.isArray(res) || res.length !== 0) {
+        return { success: false, message: `Expected [], got ${JSON.stringify(res)}` }
+    }
+    return { success: true }
+}
+
+export async function testPushMalformedTraceId(client) {
+    // Per plan §5: malformed traceId aborts the batch in both v2 and v3.
+    // We only need to verify the behavior is stable (either rejected at the
+    // client validator or surfaced as a failure from the server). The client
+    // QueueBuilder currently drops invalid UUIDs silently — in which case the
+    // push still succeeds and traceId is null. Accept either outcome as long
+    // as we don't see data corruption.
+    const queueName = 'test-v3-malformed-trace'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+    let res
+    try {
+        res = await client.queue(queueName)
+            .push([{ traceId: 'not-a-uuid', data: { i: 1 } }])
+    } catch (err) {
+        // Server rejected: acceptable per plan.
+        return { success: true, message: 'Server rejected malformed traceId (expected)' }
+    }
+    if (!Array.isArray(res) || res.length !== 1) {
+        return { success: false, message: `Expected 1 result, got ${JSON.stringify(res)}` }
+    }
+    // If the client dropped the bad traceId, we'll get a queued row with
+    // trace_id=null. That is an acceptable, well-documented outcome.
+    if (res[0].status !== 'queued' && res[0].status !== 'failed') {
+        return { success: false, message: `Unexpected status: ${JSON.stringify(res[0])}` }
+    }
+    return { success: true }
+}
+
+export async function testPushProducerSubEmptyStringBecomesNull(client) {
+    // We can't set producerSub from the client (server-stamped field). The
+    // invariant we need to preserve is that when the server writes an empty
+    // producer_sub into the JSON, the SP stores SQL NULL. We verify it by
+    // pushing without auth (server will stamp producerSub as empty / NULL)
+    // and then checking via a short-lived pg client. NOTE: we intentionally
+    // do NOT dynamically import ./run.js here — that module executes
+    // top-level `await main()` and re-importing it while it's running
+    // deadlocks the ESM module graph.
+    const queueName = 'test-v3-producer-sub-null'
+    const queue = await client.queue(queueName).create()
+    if (!queue.configured) {
+        return { success: false, message: 'Queue not created' }
+    }
+    const res = await client.queue(queueName).push([{ data: { x: 1 } }])
+    if (res[0].status !== 'queued') {
+        return { success: false, message: 'Push failed' }
+    }
+    const messageId = res[0].message_id
+
+    const { default: pg } = await import('pg')
+    const pool = new pg.Pool({
+        host: process.env.PG_HOST || 'localhost',
+        port: process.env.PG_PORT || 5432,
+        database: process.env.PG_DB || 'postgres',
+        user: process.env.PG_USER || 'postgres',
+        password: process.env.PG_PASSWORD || 'postgres',
+        max: 1
+    })
+    try {
+        const r = await pool.query(
+            'SELECT producer_sub FROM queen.messages WHERE id = $1',
+            [messageId]
+        )
+        if (r.rows.length !== 1) {
+            return { success: false, message: `Message ${messageId} not found` }
+        }
+        if (r.rows[0].producer_sub !== null) {
+            return { success: false, message: `Expected producer_sub NULL, got ${JSON.stringify(r.rows[0].producer_sub)}` }
+        }
+        return { success: true }
+    } finally {
+        await pool.end()
+    }
+}
+
 export async function pushEncryptedPayload(client) {
     const queue = await client.queue('test-queue-encrypted-payload')
     .config({ encryptionEnabled: true })

package/test-v2/run.js

@@ -13,6 +13,8 @@ import * as maintenanceTests from './maintenance.js'
 import * as retentionTests from './retention.js'
 import * as bootstrapTests from './bootstrap.js'
 import * as loggerTests from './logger.js'
+import * as watermarkTests from './watermark.js'
+import * as authTests from './auth.js'
 import { LoadBalancer } from '../client-v2/http/LoadBalancer.js';
 
 
@@ -115,7 +117,9 @@ async function main() {
         retentionTests,
         maintenanceTests,
         bootstrapTests,
-        loggerTests
+        loggerTests,
+        watermarkTests,
+        authTests
     ]
     
     const aiTests = [