@rotorsoft/act-tck 1.26.2 → 1.26.4

package/dist/index.js

@@ -1434,6 +1434,93 @@ var runStoreTck = (options) => {
           await fresh.dispose();
         }
       });
+      it7("counts a timed-out lease reclaimed by another worker against the retry budget; ack resets it", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const s = `lease-timeout-${uid()}`;
+          await fresh.subscribe([{ stream: s }]);
+          const [e1] = await seed_stream(fresh, s, 1);
+          const a = await fresh.claim(1, 0, `wA-${uid()}`, 0);
+          expect8(a.find((l) => l.stream === s)?.retry).toBe(0);
+          const b = await fresh.claim(1, 0, `wB-${uid()}`, 3e4);
+          const b_lease = b.find((l) => l.stream === s);
+          expect8(b_lease).toBeDefined();
+          expect8(b_lease.retry).toBe(1);
+          await fresh.ack([{ ...b_lease, at: e1.id }]);
+          await seed_stream(fresh, s, 1);
+          const c = await fresh.claim(1, 0, `wC-${uid()}`, 3e4);
+          expect8(c.find((l) => l.stream === s)?.retry).toBe(0);
+        } finally {
+          await fresh.dispose();
+        }
+      });
+    });
+    describe8("claim source matching", () => {
+      it7("treats source as an exact stream name \u2014 no substring or pattern overmatch", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const base = `src-${uid()}`;
+          const sibling = `${base}2`;
+          const target = `agg-${uid()}`;
+          const control = `ctl-${uid()}`;
+          await fresh.subscribe([
+            { stream: target, source: base },
+            // Control subscription sourced from the sibling — it DOES see
+            // the sibling commit below, so the negative assertion runs
+            // through a populated claim result.
+            { stream: control, source: sibling }
+          ]);
+          const [seeded] = await seed_stream(fresh, base, 1);
+          const [ctl_seeded] = await seed_stream(fresh, sibling, 1);
+          const first = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+          const mine = first.find((l) => l.stream === target);
+          const ctl = first.find((l) => l.stream === control);
+          expect8(mine).toBeDefined();
+          expect8(ctl).toBeDefined();
+          await fresh.ack([
+            { ...mine, at: seeded.id },
+            { ...ctl, at: ctl_seeded.id }
+          ]);
+          await seed_stream(fresh, sibling, 1);
+          const second = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+          expect8(second.find((l) => l.stream === control)).toBeDefined();
+          expect8(second.find((l) => l.stream === target)).toBeUndefined();
+        } finally {
+          await fresh.dispose();
+        }
+      });
+      it7("receives exactly its source stream's events", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const base = `src-${uid()}`;
+          const target = `agg-${uid()}`;
+          await fresh.subscribe([{ stream: target, source: base }]);
+          const [e1] = await seed_stream(fresh, base, 1);
+          const first = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+          const f = first.find((l) => l.stream === target);
+          expect8(f).toBeDefined();
+          expect8(f.source).toBe(base);
+          await fresh.ack([{ ...f, at: e1.id }]);
+          const [e2] = await seed_stream(fresh, base, 1);
+          const second = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+          const sec = second.find((l) => l.stream === target);
+          expect8(sec).toBeDefined();
+          expect8(sec.at).toBe(e1.id);
+          const events2 = await collect(fresh, {
+            stream: sec.source,
+            after: sec.at
+          });
+          expect8(events2.map((e) => e.id)).toEqual([e2.id]);
+        } finally {
+          await fresh.dispose();
+        }
+      });
     });
     describe8.skipIf(!caps.concurrent_claim)("concurrency (capability)", () => {
       it7("never double-leases a stream across concurrent claimers", async () => {
@@ -1465,6 +1552,51 @@ var runStoreTck = (options) => {
           await fresh.dispose();
         }
       });
+      it7("does not hand an unexpired lease to a competing claimer", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const s = `unexpired-${uid()}`;
+          const other = `unexpired-other-${uid()}`;
+          await fresh.subscribe([{ stream: s }]);
+          await seed_stream(fresh, s, 1);
+          const a = await fresh.claim(100, 100, `wA-${uid()}`, 6e4);
+          expect8(a.find((l) => l.stream === s)).toBeDefined();
+          await fresh.subscribe([{ stream: other }]);
+          await seed_stream(fresh, other, 1);
+          const b = await fresh.claim(100, 100, `wB-${uid()}`, 6e4);
+          expect8(b.find((l) => l.stream === other)).toBeDefined();
+          expect8(b.find((l) => l.stream === s)).toBeUndefined();
+        } finally {
+          await fresh.dispose();
+        }
+      });
+      it7("hands an expired lease to exactly one competing claimer, with retry accounting shared across workers", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const s = `expired-${uid()}`;
+          await fresh.subscribe([{ stream: s }]);
+          const [e1] = await seed_stream(fresh, s, 1);
+          const dead = await fresh.claim(100, 0, `wDead-${uid()}`, 0);
+          expect8(dead.find((l) => l.stream === s)?.retry).toBe(0);
+          const [b, c] = await Promise.all([
+            fresh.claim(100, 100, `wB-${uid()}`, 6e4),
+            fresh.claim(100, 100, `wC-${uid()}`, 6e4)
+          ]);
+          const winners = [...b, ...c].filter((l) => l.stream === s);
+          expect8(winners).toHaveLength(1);
+          expect8(winners[0].retry).toBe(1);
+          await fresh.ack([{ ...winners[0], at: e1.id }]);
+          await seed_stream(fresh, s, 1);
+          const again = await fresh.claim(100, 0, `wNext-${uid()}`, 6e4);
+          expect8(again.find((l) => l.stream === s)?.retry).toBe(0);
+        } finally {
+          await fresh.dispose();
+        }
+      });
     });
     describe8("block", () => {
       it7("hides blocked streams from claim", async () => {
@@ -3455,6 +3587,89 @@ var runStoreTck = (options) => {
             await Promise.resolve(disposer());
           }
         });
+        it7("does not deliver an instance's own commits (self-filtering)", async () => {
+          const received = [];
+          let resolve_sentinel;
+          const sentinel_arrived = new Promise((res) => {
+            resolve_sentinel = res;
+          });
+          const own = `notify-self-${uid()}`;
+          const remote = `notify-remote-${uid()}`;
+          const sentinel = `notify-sentinel-${uid()}`;
+          const disposer = await store.notify.call(store, (n) => {
+            received.push(n);
+            if (n.stream === sentinel) resolve_sentinel();
+          });
+          const writer = await options.factory();
+          try {
+            await store.commit(
+              own,
+              [inc(1)],
+              make_meta({ stream: own })
+            );
+            await writer.commit(
+              remote,
+              [inc(1)],
+              make_meta({ stream: remote })
+            );
+            await writer.commit(
+              sentinel,
+              [inc(1)],
+              make_meta({ stream: sentinel })
+            );
+            await sentinel_arrived;
+            expect8(received.find((n) => n.stream === own)).toBeUndefined();
+            expect8(received.find((n) => n.stream === remote)).toBeDefined();
+            expect8(received.find((n) => n.stream === sentinel)).toBeDefined();
+          } finally {
+            await writer.dispose();
+            await Promise.resolve(disposer());
+          }
+        });
+        it7("delivers one notification per commit transaction carrying the full event batch", async () => {
+          const received = [];
+          let resolve_sentinel;
+          const sentinel_arrived = new Promise((res) => {
+            resolve_sentinel = res;
+          });
+          const batch = `notify-batch-${uid()}`;
+          const sentinel = `notify-batch-sentinel-${uid()}`;
+          const disposer = await store.notify.call(store, (n) => {
+            received.push(n);
+            if (n.stream === sentinel) resolve_sentinel();
+          });
+          const writer = await options.factory();
+          try {
+            await writer.commit(
+              batch,
+              [inc(1), inc(2), inc(3)],
+              make_meta({ stream: batch })
+            );
+            await writer.commit(
+              sentinel,
+              [inc(1)],
+              make_meta({ stream: sentinel })
+            );
+            await sentinel_arrived;
+            const batch_notifications = received.filter(
+              (n) => n.stream === batch
+            );
+            expect8(batch_notifications).toHaveLength(1);
+            const events2 = batch_notifications[0].events;
+            expect8(events2).toHaveLength(3);
+            expect8(events2.map((e) => e.name)).toEqual([
+              "Incremented",
+              "Incremented",
+              "Incremented"
+            ]);
+            expect8([...events2.map((e) => e.id)].sort((a, b) => a - b)).toEqual(
+              events2.map((e) => e.id)
+            );
+          } finally {
+            await writer.dispose();
+            await Promise.resolve(disposer());
+          }
+        });
       });
     }
   });