@rotorsoft/act-tck 1.17.1 → 1.19.0

package/dist/index.js

@@ -1416,6 +1416,104 @@ var runStoreTck = (options) => {
         expect8(blocked).toHaveLength(0);
       });
     });
+    describe8("defer", () => {
+      it7("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 })
+          );
+        expect8(await store.defer([s], Date.now() + 36e5)).toBe(1);
+        const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
+        expect8(leased.find((l) => l.stream === ctl)).toBeDefined();
+        expect8(leased.find((l) => l.stream === s)).toBeUndefined();
+      });
+      it7("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 })
+        );
+        expect8(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);
+        expect8(mine).toBeDefined();
+        await store.ack(
+          leased.filter((l) => l.stream !== s).concat(mine)
+        );
+      });
+      it7("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);
+        expect8(mine).toBeDefined();
+        expect8(mine.retry).toBe(0);
+        await store.ack(
+          leased.filter((l) => l.stream !== s).concat(mine)
+        );
+      });
+      it7("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);
+        expect8(await store.reset([s])).toBe(1);
+        const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
+        expect8(leased.find((l) => l.stream === s)).toBeDefined();
+      });
+      it7("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
+        );
+        expect8(n).toBe(2);
+        const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
+        expect8(leased.find((l) => l.stream === ctl)).toBeDefined();
+        expect8(leased.find((l) => l.stream === a)).toBeUndefined();
+        expect8(leased.find((l) => l.stream === b)).toBeUndefined();
+      });
+      it7("returns 0 for unknown streams and empty input", async () => {
+        expect8(await store.defer([`missing-${uid()}`], Date.now())).toBe(0);
+        expect8(await store.defer([], Date.now())).toBe(0);
+      });
+    });
     describe8("reset", () => {
       it7("rewinds a stream watermark to -1", async () => {
         const s = `reset-${uid()}`;