@rotorsoft/act-tck 1.19.2 → 1.19.3

package/dist/index.js

@@ -798,7 +798,8 @@ import {
   ConcurrencyError,
   InMemoryCache,
   SNAP_EVENT as SNAP_EVENT2,
-  TOMBSTONE_EVENT
+  TOMBSTONE_EVENT,
+  ValidationError
 } from "@rotorsoft/act";
 import { afterAll as afterAll4, beforeAll as beforeAll4, describe as describe8, expect as expect8, it as it7 } from "vitest";
 var runStoreTck = (options) => {
@@ -1155,6 +1156,94 @@ var runStoreTck = (options) => {
         expect8(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
       });
     });
+    describe8("stream filter grammar", () => {
+      const seed_streams = async (streams) => {
+        for (const s of streams)
+          await store.commit(
+            s,
+            [inc(1)],
+            make_meta({ stream: s })
+          );
+      };
+      const streams_matching = async (pattern) => (await collect(store, { stream: pattern })).map((e) => e.stream).sort();
+      const match_exactly_or_throw = async (pattern, expected) => {
+        let matched;
+        let error;
+        try {
+          matched = await streams_matching(pattern);
+        } catch (e) {
+          error = e;
+        }
+        if (error !== void 0) expect8(error).toBeInstanceOf(ValidationError);
+        else expect8(matched).toEqual(expected.sort());
+      };
+      it7("portable subset: anchors, `.`, and `.*` match identically", async () => {
+        const tag = uid();
+        const plain = `g-${tag}-plain`;
+        const dotted = `g-${tag}.dot`;
+        const scored = `g-${tag}_us`;
+        const pct = `g-${tag}%pc`;
+        await seed_streams([plain, dotted, scored, pct]);
+        expect8(await streams_matching(`^g-${tag}`)).toEqual(
+          [plain, dotted, scored, pct].sort()
+        );
+        expect8(await streams_matching(`${tag}-plain$`)).toEqual([plain]);
+        expect8(await streams_matching(`^g-${tag}-plain$`)).toEqual([plain]);
+        expect8(await streams_matching(`^g-${tag}.dot$`)).toEqual([dotted]);
+        expect8(await streams_matching(`^g-${tag}.plain$`)).toEqual([plain]);
+        expect8(await streams_matching(`^g-${tag}.*dot$`)).toEqual([dotted]);
+      });
+      it7("literal `_` and `%` in patterns are not wildcards", async () => {
+        const tag = uid();
+        const scored = `u-${tag}_x`;
+        const scored_decoy = `u-${tag}Zx`;
+        const pct = `p-${tag}%y`;
+        const pct_decoy = `p-${tag}ZZy`;
+        await seed_streams([scored, scored_decoy, pct, pct_decoy]);
+        expect8(await streams_matching(`^u-${tag}_x$`)).toEqual([scored]);
+        expect8(await streams_matching(`^p-${tag}%y$`)).toEqual([pct]);
+      });
+      it7("portable subset applies to stream-position filters", async () => {
+        const tag = uid();
+        const scored = `sf-${tag}_a`;
+        const decoy = `sf-${tag}Za`;
+        await store.subscribe([{ stream: scored }, { stream: decoy }]);
+        const got = [];
+        await store.query_streams((p) => got.push(p.stream), {
+          stream: `^sf-${tag}_a$`
+        });
+        expect8(got).toEqual([scored]);
+      });
+      it7("non-portable patterns match with full regex semantics or throw", async () => {
+        const tag = uid();
+        const a = `np-${tag}-a`;
+        const b = `np-${tag}-b`;
+        const c = `np-${tag}-c`;
+        const one = `np-${tag}-1`;
+        const aaa = `np-${tag}-aaa`;
+        const dot = `e-${tag}.d`;
+        const dot_decoy = `e-${tag}xd`;
+        await seed_streams([a, b, c, one, aaa, dot, dot_decoy]);
+        await match_exactly_or_throw(`^np-${tag}-(a|b)$`, [a, b]);
+        await match_exactly_or_throw(`^np-${tag}-[0-9]$`, [one]);
+        await match_exactly_or_throw(`^np-${tag}-a+$`, [a, aaa]);
+        await match_exactly_or_throw(`^e-${tag}\\.d$`, [dot]);
+      });
+      it7("bulk stream ops reject non-portable filters instead of mis-matching", async () => {
+        const tag = uid();
+        const s = `bo-${tag}-a`;
+        await store.subscribe([{ stream: s }]);
+        let count;
+        let error;
+        try {
+          count = await store.reset({ stream: `^bo-${tag}-(a|b)$` });
+        } catch (e) {
+          error = e;
+        }
+        if (error !== void 0) expect8(error).toBeInstanceOf(ValidationError);
+        else expect8(count).toBe(1);
+      });
+    });
     describe8("subscribe + claim + ack", () => {
       it7("subscribes new streams and is idempotent on repeat", async () => {
         const s = `sub-${uid()}`;