@rotorsoft/act-tck 1.17.1 → 1.18.0

package/dist/index.cjs

@@ -1464,6 +1464,104 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(blocked).toHaveLength(0);
       });
     });
+    (0, import_vitest9.describe)("defer", () => {
+      (0, import_vitest9.it)("hides a stream from claim until its deferred_at passes", async () => {
+        const s = `defer-${uid()}`;
+        const ctl = `defer-ctl-${uid()}`;
+        await store.subscribe([{ stream: s }, { stream: ctl }]);
+        for (const st of [s, ctl])
+          await store.commit(
+            st,
+            [inc(1)],
+            make_meta({ stream: st })
+          );
+        (0, import_vitest9.expect)(await store.defer([s], Date.now() + 36e5)).toBe(1);
+        const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
+        (0, import_vitest9.expect)(leased.find((l) => l.stream === ctl)).toBeDefined();
+        (0, import_vitest9.expect)(leased.find((l) => l.stream === s)).toBeUndefined();
+      });
+      (0, import_vitest9.it)("makes a stream claimable once the deferred_at is in the past", async () => {
+        const s = `defer-past-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        (0, import_vitest9.expect)(await store.defer([s], Date.now() - 1e3)).toBe(1);
+        const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
+        const mine = leased.find((l) => l.stream === s);
+        (0, import_vitest9.expect)(mine).toBeDefined();
+        await store.ack(
+          leased.filter((l) => l.stream !== s).concat(mine)
+        );
+      });
+      (0, import_vitest9.it)("does not bump retry while a stream is deferred", async () => {
+        const s = `defer-retry-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        await store.defer([s], Date.now() + 36e5);
+        await store.claim(100, 100, `w1-${uid()}`, 1e5);
+        await store.claim(100, 100, `w2-${uid()}`, 1e5);
+        await store.defer([s], Date.now() - 1e3);
+        const leased = await store.claim(100, 100, `w3-${uid()}`, 1e5);
+        const mine = leased.find((l) => l.stream === s);
+        (0, import_vitest9.expect)(mine).toBeDefined();
+        (0, import_vitest9.expect)(mine.retry).toBe(0);
+        await store.ack(
+          leased.filter((l) => l.stream !== s).concat(mine)
+        );
+      });
+      (0, import_vitest9.it)("reset clears a pending defer", async () => {
+        const s = `defer-reset-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        await store.defer([s], Date.now() + 36e5);
+        (0, import_vitest9.expect)(await store.reset([s])).toBe(1);
+        const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
+        (0, import_vitest9.expect)(leased.find((l) => l.stream === s)).toBeDefined();
+      });
+      (0, import_vitest9.it)("defers streams matching a filter and counts matches", async () => {
+        const tag = uid();
+        const a = `deferfilter-${tag}-a`;
+        const b = `deferfilter-${tag}-b`;
+        await store.subscribe([{ stream: a }, { stream: b }]);
+        for (const s of [a, b])
+          await store.commit(
+            s,
+            [inc(1)],
+            make_meta({ stream: s })
+          );
+        const ctl = `defer-filterctl-${tag}`;
+        await store.subscribe([{ stream: ctl }]);
+        await store.commit(
+          ctl,
+          [inc(1)],
+          make_meta({ stream: ctl })
+        );
+        const n = await store.defer(
+          { stream: `^deferfilter-${tag}-`, stream_exact: false },
+          Date.now() + 36e5
+        );
+        (0, import_vitest9.expect)(n).toBe(2);
+        const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
+        (0, import_vitest9.expect)(leased.find((l) => l.stream === ctl)).toBeDefined();
+        (0, import_vitest9.expect)(leased.find((l) => l.stream === a)).toBeUndefined();
+        (0, import_vitest9.expect)(leased.find((l) => l.stream === b)).toBeUndefined();
+      });
+      (0, import_vitest9.it)("returns 0 for unknown streams and empty input", async () => {
+        (0, import_vitest9.expect)(await store.defer([`missing-${uid()}`], Date.now())).toBe(0);
+        (0, import_vitest9.expect)(await store.defer([], Date.now())).toBe(0);
+      });
+    });
     (0, import_vitest9.describe)("reset", () => {
       (0, import_vitest9.it)("rewinds a stream watermark to -1", async () => {
         const s = `reset-${uid()}`;