@rotorsoft/act-tck 1.26.4 → 1.26.6

package/dist/index.js

@@ -1521,7 +1521,130 @@ var runStoreTck = (options) => {
           await fresh.dispose();
         }
       });
+      it7("fetches only the exact source stream's events, never a sibling prefix", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const base = `fx-${uid()}`;
+          const sibling = `${base}2`;
+          const target = `agg-${uid()}`;
+          await fresh.subscribe([{ stream: target, source: base }]);
+          const [b1] = await seed_stream(fresh, base, 1);
+          await seed_stream(fresh, sibling, 1);
+          const claimed = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+          const lease = claimed.find((l) => l.stream === target);
+          expect8(lease).toBeDefined();
+          const events2 = await collect(fresh, {
+            stream: lease.source,
+            stream_exact: true,
+            after: -1
+          });
+          expect8(events2.map((e) => e.stream)).toEqual([base]);
+          expect8(events2.map((e) => e.id)).toEqual([b1.id]);
+        } finally {
+          await fresh.dispose();
+        }
+      });
     });
+    describe8.skipIf(!caps.pattern_claim_source)(
+      "claim pattern source matching (capability)",
+      () => {
+        it7("claims a pattern-source target when any matched stream has work (^(A|B)$)", async () => {
+          const fresh = await options.factory();
+          try {
+            await fresh.drop();
+            await fresh.seed();
+            const a = `A-${uid()}`;
+            const b = `B-${uid()}`;
+            const target = `board-${uid()}`;
+            const pattern = `^(${a}|${b})$`;
+            await fresh.subscribe([{ stream: target, source: pattern }]);
+            const [ea] = await seed_stream(fresh, a, 1);
+            const first = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+            const l1 = first.find((s) => s.stream === target);
+            expect8(l1).toBeDefined();
+            await fresh.ack([{ ...l1, at: ea.id }]);
+            const [eb] = await seed_stream(fresh, b, 1);
+            const second = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+            expect8(second.find((s) => s.stream === target)).toBeDefined();
+            expect8(eb.stream).toBe(b);
+          } finally {
+            await fresh.dispose();
+          }
+        });
+        it7("does not claim a pattern-source target when no matched stream has work", async () => {
+          const fresh = await options.factory();
+          try {
+            await fresh.drop();
+            await fresh.seed();
+            const a = `A-${uid()}`;
+            const b = `B-${uid()}`;
+            const other = `Z-${uid()}`;
+            const target = `board-${uid()}`;
+            const control = `ctl-${uid()}`;
+            const pattern = `^(${a}|${b})$`;
+            await fresh.subscribe([
+              { stream: target, source: pattern },
+              { stream: control, source: other }
+            ]);
+            const [ea] = await seed_stream(fresh, a, 1);
+            const first = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+            const l1 = first.find((s) => s.stream === target);
+            expect8(l1).toBeDefined();
+            const c1 = first.find((s) => s.stream === control);
+            expect8(c1).toBeDefined();
+            await fresh.ack([
+              { ...l1, at: ea.id },
+              { ...c1, at: -1 }
+            ]);
+            await seed_stream(fresh, other, 1);
+            const claimed = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+            const streams = claimed.map((s) => s.stream);
+            expect8(streams).toContain(control);
+            expect8(streams).not.toContain(target);
+          } finally {
+            await fresh.dispose();
+          }
+        });
+      }
+    );
+    describe8.skipIf(!caps.rejects_nonportable_claim_source)(
+      "claim source registration (capability)",
+      () => {
+        it7("throws at subscribe for a non-portable (alternation) claim source", async () => {
+          const fresh = await options.factory();
+          try {
+            await fresh.drop();
+            await fresh.seed();
+            await expect8(
+              fresh.subscribe([
+                { stream: `board-${uid()}`, source: `^(${uid()}|${uid()})$` }
+              ])
+            ).rejects.toThrow(ValidationError);
+          } finally {
+            await fresh.dispose();
+          }
+        });
+        it7("accepts a portable-subset pattern claim source (^prefix.*) and claims on match", async () => {
+          const fresh = await options.factory();
+          try {
+            await fresh.drop();
+            await fresh.seed();
+            const prefix = `pfx${uid()}`.replace(/-/g, "");
+            const matched = `${prefix}child`;
+            const target = `board-${uid()}`;
+            await fresh.subscribe([{ stream: target, source: `^${prefix}.*` }]);
+            const [e] = await seed_stream(fresh, matched, 1);
+            const claimed = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+            expect8(claimed.find((s) => s.stream === target)).toBeDefined();
+            expect8(e.stream).toBe(matched);
+          } finally {
+            await fresh.dispose();
+          }
+        });
+      }
+    );
     describe8.skipIf(!caps.concurrent_claim)("concurrency (capability)", () => {
       it7("never double-leases a stream across concurrent claimers", async () => {
         const fresh = await options.factory();