@rotorsoft/act-tck 0.3.0 → 0.4.0

package/dist/index.js

@@ -875,6 +875,169 @@ var runStoreTck = (options) => {
         expect3(got2.priority).toBe(5);
       });
     });
+    describe3("lanes", () => {
+      it3("subscribe defaults lane to 'default' when omitted", async () => {
+        const s = `lane-default-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.lane), {
+          stream: s,
+          stream_exact: true
+        });
+        expect3(seen).toEqual(["default"]);
+      });
+      it3("subscribe records the lane passed in", async () => {
+        const s = `lane-set-${uid()}`;
+        await store.subscribe([{ stream: s, lane: "slow" }]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.lane), {
+          stream: s,
+          stream_exact: true
+        });
+        expect3(seen).toEqual(["slow"]);
+      });
+      it3("subscribe re-lanes existing streams on subsequent calls", async () => {
+        const s = `lane-upsert-${uid()}`;
+        await store.subscribe([{ stream: s, lane: "slow" }]);
+        await store.subscribe([{ stream: s, lane: "fast" }]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.lane), {
+          stream: s,
+          stream_exact: true
+        });
+        expect3(seen).toEqual(["fast"]);
+      });
+      it3("claim() filters by lane when supplied and returns lane on the Lease", async () => {
+        const tag = uid();
+        const src1 = `lane-claim-src1-${tag}`;
+        const src2 = `lane-claim-src2-${tag}`;
+        const subDefault = `lane-claim-def-${tag}`;
+        const subSlow = `lane-claim-slow-${tag}`;
+        await store.commit(
+          src1,
+          [inc(1)],
+          makeMeta({ stream: src1 })
+        );
+        await store.commit(
+          src2,
+          [inc(1)],
+          makeMeta({ stream: src2 })
+        );
+        await store.subscribe([
+          { stream: subDefault, source: src1 },
+          { stream: subSlow, source: src2, lane: "slow" }
+        ]);
+        const slow = await store.claim(50, 0, `w-slow-${tag}`, 1e3, "slow");
+        const slowMine = slow.filter(
+          (l) => l.stream === subDefault || l.stream === subSlow
+        );
+        expect3(slowMine.map((l) => l.stream)).toEqual([subSlow]);
+        expect3(slowMine[0]?.lane).toBe("slow");
+        await store.ack(slowMine.map((l) => ({ ...l, at: l.at + 1 })));
+        const all = await store.claim(50, 0, `w-all-${tag}`, 1e3);
+        const allMine = all.filter((l) => l.stream === subDefault || l.stream === subSlow).map((l) => ({ stream: l.stream, lane: l.lane }));
+        expect3(allMine).toEqual(
+          expect3.arrayContaining([
+            { stream: subDefault, lane: "default" },
+            { stream: subSlow, lane: "slow" }
+          ])
+        );
+      });
+      it3("query_streams filters by lane", async () => {
+        const tag = uid();
+        const a = `lane-q-a-${tag}`;
+        const b = `lane-q-b-${tag}`;
+        const c = `lane-q-c-${tag}`;
+        await store.subscribe([
+          { stream: a, lane: "qslow" },
+          { stream: b, lane: "qfast" },
+          { stream: c, lane: "qslow" }
+        ]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.stream), {
+          lane: "qslow",
+          stream: `lane-q-.*-${tag}`,
+          limit: 100
+        });
+        expect3(seen.sort()).toEqual([a, c]);
+      });
+      it3("prioritize filters by lane", async () => {
+        const tag = uid();
+        const a = `lane-pri-a-${tag}`;
+        const b = `lane-pri-b-${tag}`;
+        await store.subscribe([
+          { stream: a, lane: `pslow-${tag}` },
+          { stream: b, lane: `pfast-${tag}` }
+        ]);
+        const updated = await store.prioritize({ lane: `pslow-${tag}` }, 7);
+        expect3(updated).toBe(1);
+        const seen = /* @__PURE__ */ new Map();
+        await store.query_streams((p) => seen.set(p.stream, p.priority), {
+          stream: `lane-pri-.*-${tag}`,
+          limit: 100
+        });
+        expect3(seen.get(a)).toBe(7);
+        expect3(seen.get(b)).toBe(0);
+      });
+      it3("reset filters by lane", async () => {
+        const tag = uid();
+        const src = `lane-reset-src-${tag}`;
+        const a = `lane-reset-a-${tag}`;
+        const b = `lane-reset-b-${tag}`;
+        await store.commit(
+          src,
+          [inc(1)],
+          makeMeta({ stream: src })
+        );
+        await store.subscribe([
+          { stream: a, source: src, lane: `rslow-${tag}` },
+          { stream: b, source: src, lane: `rfast-${tag}` }
+        ]);
+        const leases = await store.claim(50, 0, `w-${tag}`, 5e3);
+        const mine = leases.filter((l) => l.stream === a || l.stream === b);
+        await store.ack(mine.map((l) => ({ ...l, at: l.at + 1 })));
+        const count = await store.reset({ lane: `rslow-${tag}` });
+        expect3(count).toBe(1);
+        const ats = /* @__PURE__ */ new Map();
+        for (const name of [a, b]) {
+          await store.query_streams((p) => ats.set(p.stream, p.at), {
+            stream: name,
+            stream_exact: true
+          });
+        }
+        expect3(ats.get(a)).toBe(-1);
+        expect3(ats.get(b)).toBeGreaterThanOrEqual(0);
+      });
+      it3("unblock filters by lane", async () => {
+        const tag = uid();
+        const src = `lane-ub-src-${tag}`;
+        const a = `lane-ub-a-${tag}`;
+        const b = `lane-ub-b-${tag}`;
+        await store.commit(
+          src,
+          [inc(1)],
+          makeMeta({ stream: src })
+        );
+        await store.subscribe([
+          { stream: a, source: src, lane: `uslow-${tag}` },
+          { stream: b, source: src, lane: `ufast-${tag}` }
+        ]);
+        const leases = await store.claim(50, 0, `w-${tag}`, 5e3);
+        const mine = leases.filter((l) => l.stream === a || l.stream === b);
+        await store.block(mine.map((l) => ({ ...l, error: "boom" })));
+        const count = await store.unblock({ lane: `uslow-${tag}` });
+        expect3(count).toBe(1);
+        const blocked = /* @__PURE__ */ new Map();
+        for (const name of [a, b]) {
+          await store.query_streams((p) => blocked.set(p.stream, p.blocked), {
+            stream: name,
+            stream_exact: true
+          });
+        }
+        expect3(blocked.get(a)).toBe(false);
+        expect3(blocked.get(b)).toBe(true);
+      });
+    });
     describe3("truncate", () => {
       it3("seeds a tombstone when no snapshot is provided", async () => {
         const s = `trunc-tomb-${uid()}`;