@rotorsoft/act-tck 1.31.0 → 1.32.0

package/dist/index.js

@@ -1799,6 +1799,106 @@ var runStoreTck = (options) => {
           expect8(seen).not.toContain("correlated");
         });
       });
+      describe8.skipIf(!caps.work_set)("subscription work set", () => {
+        const claimable = async (stream) => {
+          const leased = await store.claim(100, 0, `w-${uid()}`, 1);
+          const mine = leased.find((l) => l.stream === stream);
+          if (mine) await store.ack([{ ...mine, at: mine.at }]);
+          return mine !== void 0;
+        };
+        it7("claims a marked stream without probing the event log", async () => {
+          const s = `ws-mark-${uid()}`;
+          await store.subscribe([{ stream: s, source: `ws-src-${uid()}` }]);
+          expect8(await claimable(s)).toBe(false);
+          await store.subscribe([{ stream: s, correlated_at: 7 }]);
+          expect8(await claimable(s)).toBe(true);
+          const s2 = `ws-mark-nosrc-${uid()}`;
+          await store.subscribe([{ stream: s2, correlated_at: 7 }]);
+          expect8(await claimable(s2)).toBe(true);
+        });
+        it7("never regresses the mark, for every value on the number line", async () => {
+          const s = `ws-mono-${uid()}`;
+          await store.subscribe([
+            { stream: s, source: `ws-none-${uid()}`, correlated_at: 10 }
+          ]);
+          const leased = await store.claim(100, 0, `w-${uid()}`, 1e4);
+          await store.ack([
+            { ...leased.find((l) => l.stream === s), at: 5 }
+          ]);
+          expect8(await claimable(s)).toBe(true);
+          await store.subscribe([{ stream: s, correlated_at: 4 }]);
+          expect8(await claimable(s)).toBe(true);
+          await store.subscribe([{ stream: s, correlated_at: 5 }]);
+          expect8(await claimable(s)).toBe(true);
+          await store.subscribe([{ stream: s, correlated_at: -3 }]);
+          expect8(await claimable(s)).toBe(true);
+          await store.subscribe([{ stream: s, correlated_at: 0 }]);
+          expect8(await claimable(s)).toBe(true);
+          const leased2 = await store.claim(100, 0, `w-${uid()}`, 1e4);
+          await store.ack([
+            { ...leased2.find((l) => l.stream === s), at: 10 }
+          ]);
+          expect8(await claimable(s)).toBe(false);
+          await store.subscribe([{ stream: s, correlated_at: 11 }]);
+          expect8(await claimable(s)).toBe(true);
+        });
+        it7("retires a stream when ack catches the watermark up to the mark", async () => {
+          const s = `ws-retire-${uid()}`;
+          await store.subscribe([
+            { stream: s, source: `ws-none-${uid()}`, correlated_at: 5 }
+          ]);
+          const leased = await store.claim(100, 0, `w-${uid()}`, 1e4);
+          const mine = leased.find((l) => l.stream === s);
+          expect8(mine).toBeDefined();
+          await store.ack([{ ...mine, at: 5 }]);
+          expect8(await claimable(s)).toBe(false);
+          await store.subscribe([{ stream: s, correlated_at: 6 }]);
+          expect8(await claimable(s)).toBe(true);
+        });
+        it7("keeps the mark across reset, so a rebuild is claimable", async () => {
+          const s = `ws-reset-${uid()}`;
+          await store.subscribe([
+            { stream: s, source: `ws-none-${uid()}`, correlated_at: 3 }
+          ]);
+          const leased = await store.claim(100, 0, `w-${uid()}`, 1e4);
+          await store.ack([
+            { ...leased.find((l) => l.stream === s), at: 3 }
+          ]);
+          expect8(await claimable(s)).toBe(false);
+          await store.reset([s]);
+          expect8(await claimable(s)).toBe(true);
+        });
+        it7("keeps the mark across unblock, defer, and prioritize", async () => {
+          const s = `ws-ops-${uid()}`;
+          await store.subscribe([
+            { stream: s, source: `ws-none-${uid()}`, correlated_at: 9 }
+          ]);
+          const leased = await store.claim(100, 0, `w-${uid()}`, 1e4);
+          const mine = leased.find((l) => l.stream === s);
+          await store.block([{ ...mine, error: "poison" }]);
+          expect8(await claimable(s)).toBe(false);
+          expect8(await store.unblock([s])).toBe(1);
+          expect8(await claimable(s)).toBe(true);
+          await store.defer([s], Date.now() + 6e4);
+          expect8(await claimable(s)).toBe(false);
+          await store.defer([s], Date.now() - 1);
+          expect8(await claimable(s)).toBe(true);
+          await store.prioritize({ stream: s, stream_exact: true }, 5);
+          expect8(await claimable(s)).toBe(true);
+        });
+        it7("falls back to the legacy probe for an unmarked stream", async () => {
+          const s = `ws-legacy-${uid()}`;
+          const src = `ws-legacy-src-${uid()}`;
+          await store.subscribe([{ stream: s, source: src }]);
+          expect8(await claimable(s)).toBe(false);
+          await store.commit(
+            src,
+            [inc(1)],
+            make_meta({ stream: src })
+          );
+          expect8(await claimable(s)).toBe(true);
+        });
+      });
       it7("claims a subscribed stream and ack releases the lease", async () => {
         const s = `claim-${uid()}`;
         await store.subscribe([{ stream: s }]);