@rotorsoft/act-tck 1.36.17 → 1.36.19

package/dist/index.js

@@ -2261,6 +2261,36 @@ var runStoreTck = (options) => {
           await fresh.dispose();
         }
       });
+      it7("records the lease holder for a zero-length lease, so its ack lands", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const s = `lease-zero-${uid()}`;
+          await fresh.subscribe([{ stream: s }]);
+          const [committed] = await fresh.commit(
+            s,
+            [inc(1)],
+            make_meta({ stream: s })
+          );
+          await correlate(fresh);
+          const leased = await fresh.claim(1, 0, `w-${uid()}`, 0);
+          const mine = leased.find((l) => l.stream === s);
+          expect8(mine).toBeDefined();
+          const acked = await fresh.ack([{ ...mine, at: committed.id }]);
+          expect8(acked).toHaveLength(1);
+          let at = -1;
+          await fresh.query_streams(
+            (p) => {
+              at = p.at;
+            },
+            { stream: s, stream_exact: true }
+          );
+          expect8(at).toBe(committed.id);
+        } finally {
+          await fresh.dispose();
+        }
+      });
       it7("reports lagging=true from the lagging frontier and false from the leading frontier", async () => {
         const fresh = await options.factory();
         try {
@@ -3166,6 +3196,50 @@ var runStoreTck = (options) => {
         });
         expect8(seen).toEqual(["fast"]);
       });
+      it7("keeps the lane when a lower-priority subscribe re-registers", async () => {
+        const s = `lane-rank-${uid()}`;
+        await store.subscribe([{ stream: s, lane: "fast", priority: 10 }]);
+        await store.subscribe([{ stream: s, lane: "slow", priority: 0 }]);
+        const seen = [];
+        await store.query_streams(
+          (p) => seen.push({ lane: p.lane, priority: p.priority }),
+          { stream: s, stream_exact: true }
+        );
+        expect8(seen).toEqual([{ lane: "fast", priority: 10 }]);
+      });
+      it7("keeps the lane when a mark-only subscribe re-registers", async () => {
+        const s = `lane-mark-${uid()}`;
+        await store.subscribe([{ stream: s, lane: "fast", priority: 10 }]);
+        await store.subscribe([{ stream: s, correlated_at: 7 }]);
+        const seen = [];
+        await store.query_streams(
+          (p) => seen.push({ lane: p.lane, correlated_at: p.correlated_at }),
+          { stream: s, stream_exact: true }
+        );
+        expect8(seen).toEqual([{ lane: "fast", correlated_at: 7 }]);
+      });
+      it7("re-lanes when the subscribe outranks the stored priority", async () => {
+        const s = `lane-outrank-${uid()}`;
+        await store.subscribe([{ stream: s, lane: "fast", priority: 0 }]);
+        await store.subscribe([{ stream: s, lane: "slow", priority: 5 }]);
+        const seen = [];
+        await store.query_streams(
+          (p) => seen.push({ lane: p.lane, priority: p.priority }),
+          { stream: s, stream_exact: true }
+        );
+        expect8(seen).toEqual([{ lane: "slow", priority: 5 }]);
+      });
+      it7("re-lanes at equal priority, which is what keeps re-laning restart-driven", async () => {
+        const s = `lane-equal-${uid()}`;
+        await store.subscribe([{ stream: s, lane: "fast", priority: 7 }]);
+        await store.subscribe([{ stream: s, lane: "slow", priority: 7 }]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.lane), {
+          stream: s,
+          stream_exact: true
+        });
+        expect8(seen).toEqual(["slow"]);
+      });
       it7("claim() filters by lane when supplied and returns lane on the Lease", async () => {
         const tag = uid();
         const src1 = `lane-claim-src1-${tag}`;
@@ -3609,6 +3683,25 @@ var runStoreTck = (options) => {
         }
         expect8([...visited].sort()).toEqual([...names].sort());
       });
+      it7("limit: 0 returns no rows", async () => {
+        const s = `qs-zero-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        const seen = [];
+        const push = (p) => {
+          seen.push(p.stream);
+        };
+        const filter = { stream: s, stream_exact: true };
+        const control = await store.query_streams(push, filter);
+        expect8(control.count).toBe(1);
+        expect8(seen).toEqual([s]);
+        seen.length = 0;
+        const { count } = await store.query_streams(push, {
+          ...filter,
+          limit: 0
+        });
+        expect8(seen).toEqual([]);
+        expect8(count).toBe(0);
+      });
       it7("returns positions filtered by stream regex, exact, source, and source_exact", async () => {
         const tag = uid();
         const proj1 = `qs-${tag}-projection-tickets`;
@@ -3746,6 +3839,21 @@ var runStoreTck = (options) => {
         const unknown = await store.query_stats([`qst-${tag}-missing`]);
         expect8(unknown.size).toBe(0);
       });
+      it7("limit: 0 returns no rows", async () => {
+        const s = `qst-zero-${uid()}`;
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        const filter = { stream: s, stream_exact: true };
+        const control = await store.query_stats(filter);
+        expect8(control.size).toBe(1);
+        const stats = await store.query_stats(filter, {
+          limit: 0
+        });
+        expect8(stats.size).toBe(0);
+      });
       it7("keyset pagination visits every stream regardless of name case (#1357)", async () => {
         const tag = uid();
         const names = [