@rotorsoft/act-tck 1.30.5 → 1.32.0

package/dist/index.js

@@ -1759,6 +1759,146 @@ var runStoreTck = (options) => {
         await store.subscribe([{ stream: s }]);
         expect8(await read()).toBe(0);
       });
+      describe8("correlate checkpoint", () => {
+        const peek = async () => (await store.subscribe([])).correlated_at;
+        it7("round-trips an advance through subscribe", async () => {
+          const base = await peek();
+          expect8((await store.subscribe([], base + 10)).correlated_at).toBe(
+            base + 10
+          );
+          expect8(await peek()).toBe(base + 10);
+        });
+        it7("persists only when greater than the stored value", async () => {
+          const base = await peek();
+          await store.subscribe([], base - 5);
+          expect8(await peek()).toBe(base);
+          await store.subscribe([], base);
+          expect8(await peek()).toBe(base);
+          await store.subscribe([], base + 3);
+          expect8(await peek()).toBe(base + 3);
+        });
+        it7("is left untouched when subscribe omits it", async () => {
+          const base = await peek();
+          await store.subscribe([]);
+          expect8(await peek()).toBe(base);
+        });
+        it7("advances in the same call that registers discovered targets", async () => {
+          const base = await peek();
+          const s = `cp-sub-${uid()}`;
+          const { subscribed, correlated_at } = await store.subscribe(
+            [{ stream: s }],
+            base + 7
+          );
+          expect8(subscribed).toBe(1);
+          expect8(correlated_at).toBe(base + 7);
+        });
+        it7("is invisible to every stream-scoped surface", async () => {
+          const seen = [];
+          await store.query_streams((p) => seen.push(p.stream), {});
+          expect8(seen.some((n) => n.startsWith("__correlate"))).toBe(false);
+          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 }]);