@rotorsoft/act-tck 1.30.0 → 1.30.2

package/dist/index.js

@@ -1691,6 +1691,74 @@ var runStoreTck = (options) => {
         await store.subscribe([{ stream: s }]);
         expect8(await read()).toBe(10);
       });
+      it7("does not claim a fresh subscription with no matching events", async () => {
+        const s = `fresh-empty-${uid()}`;
+        const src = `fresh-src-${uid()}`;
+        await store.subscribe([{ stream: s, source: src }]);
+        const leases = await store.claim(5, 5, `w-${uid()}`, 5e3);
+        expect8(leases.filter((l) => l.stream === s)).toHaveLength(0);
+      });
+      it7("claims a fresh subscription as soon as its first event lands", async () => {
+        const s = `fresh-first-${uid()}`;
+        const src = `fresh-first-src-${uid()}`;
+        await store.subscribe([{ stream: s, source: src }]);
+        await store.commit(
+          src,
+          [inc(1)],
+          make_meta({ stream: src })
+        );
+        const leases = await store.claim(5, 5, `w-${uid()}`, 5e3);
+        const mine = leases.filter((l) => l.stream === s);
+        expect8(mine).toHaveLength(1);
+        expect8(mine[0].at).toBe(-1);
+        const in_window = [];
+        await store.query((e) => in_window.push(e), {
+          stream: src,
+          stream_exact: true,
+          after: mine[0].at
+        });
+        expect8(in_window).toHaveLength(1);
+      });
+      it7("keeps the maximum for negative and zero priorities too", async () => {
+        const s = `sub-pri-neg-${uid()}`;
+        const read = async () => {
+          const got = {};
+          await store.query_streams(
+            (p) => {
+              got.priority = p.priority;
+            },
+            { stream: s, stream_exact: true }
+          );
+          return got.priority;
+        };
+        await store.subscribe([{ stream: s, priority: -5 }]);
+        expect8(await read()).toBe(-5);
+        await store.subscribe([{ stream: s, priority: -1 }]);
+        expect8(await read()).toBe(-1);
+        await store.subscribe([{ stream: s, priority: -9 }]);
+        expect8(await read()).toBe(-1);
+        await store.subscribe([{ stream: s }]);
+        expect8(await read()).toBe(0);
+      });
+      it7("restores the declared priority on the next subscribe after a prioritize() downgrade", async () => {
+        const s = `sub-pri-restore-${uid()}`;
+        const read = async () => {
+          const got = {};
+          await store.query_streams(
+            (p) => {
+              got.priority = p.priority;
+            },
+            { stream: s, stream_exact: true }
+          );
+          return got.priority;
+        };
+        await store.subscribe([{ stream: s }]);
+        expect8(await read()).toBe(0);
+        await store.prioritize({ stream: s, stream_exact: true }, -5);
+        expect8(await read()).toBe(-5);
+        await store.subscribe([{ stream: s }]);
+        expect8(await read()).toBe(0);
+      });
       it7("claims a subscribed stream and ack releases the lease", async () => {
         const s = `claim-${uid()}`;
         await store.subscribe([{ stream: s }]);
@@ -2089,12 +2157,8 @@ var runStoreTck = (options) => {
             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 }
-            ]);
+            expect8(first.map((s) => s.stream)).not.toContain(control);
+            await fresh.ack([{ ...l1, at: ea.id }]);
             await seed_stream(fresh, other, 1);
             const claimed = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
             const streams = claimed.map((s) => s.stream);