@rotorsoft/act-tck 1.35.0 → 1.36.0

package/dist/index.js

@@ -908,6 +908,7 @@ var opArb = fc.oneof(
 var events = (count) => Array.from({ length: count }, () => inc(1));
 var runStorePropertyTck = (options) => {
   const numRuns = options.numRuns ?? 100;
+  const timeout = options.timeoutMs ?? 5e3;
   describe7(`TCK / Store properties / ${options.name}`, () => {
     let store;
     beforeAll3(async () => {
@@ -947,7 +948,8 @@ var runStorePropertyTck = (options) => {
               expect7(e.version).toBe(i);
             });
           }
-        }
+        },
+        timeout
       );
       test.prop([fc.array(commitArb, { minLength: 1, maxLength: 20 })], {
         numRuns
@@ -974,7 +976,8 @@ var runStorePropertyTck = (options) => {
           ).rejects.toThrow();
           const after = await collect(store, { stream, stream_exact: true });
           expect7(after.length).toBe(before.length);
-        }
+        },
+        timeout
       );
     });
     describe7("claim/lease lifecycle invariants", () => {
@@ -1021,7 +1024,8 @@ var runStorePropertyTck = (options) => {
             }
           }
           expect7(totalResolved + pending.length).toBe(totalClaims);
-        }
+        },
+        timeout
       );
       test.prop(
         [
@@ -1064,35 +1068,40 @@ var runStorePropertyTck = (options) => {
               watermark1.get(lease.stream)
             );
           }
-        }
+        },
+        timeout
       );
       test.prop([fc.array(claimStreamArb, { minLength: 1, maxLength: 5 })], {
         numRuns
-      })("blocked streams cannot be claimed again", async (commits) => {
-        await reset2();
-        const streams = [...new Set(commits)];
-        await store.subscribe(streams.map((stream) => ({ stream })));
-        for (const stream of commits) {
+      })(
+        "blocked streams cannot be claimed again",
+        async (commits) => {
+          await reset2();
+          const streams = [...new Set(commits)];
+          await store.subscribe(streams.map((stream) => ({ stream })));
+          for (const stream of commits) {
+            await store.commit(
+              stream,
+              [inc(1)],
+              make_meta({ stream })
+            );
+          }
+          await mark_all2(store);
+          const claimed = await store.claim(10, 10, "worker", 6e4);
+          await store.block(claimed.map((l) => ({ ...l, error: "test" })));
+          const blockedSet = new Set(claimed.map((l) => l.stream));
+          await store.subscribe([{ stream: "ctrl" }]);
           await store.commit(
-            stream,
+            "ctrl",
             [inc(1)],
-            make_meta({ stream })
+            make_meta({ stream: "ctrl" })
           );
-        }
-        await mark_all2(store);
-        const claimed = await store.claim(10, 10, "worker", 6e4);
-        await store.block(claimed.map((l) => ({ ...l, error: "test" })));
-        const blockedSet = new Set(claimed.map((l) => l.stream));
-        await store.subscribe([{ stream: "ctrl" }]);
-        await store.commit(
-          "ctrl",
-          [inc(1)],
-          make_meta({ stream: "ctrl" })
-        );
-        await mark_all2(store);
-        const reclaim = await store.claim(10, 10, "worker2", 6e4);
-        for (const l of reclaim) expect7(blockedSet.has(l.stream)).toBe(false);
-      });
+          await mark_all2(store);
+          const reclaim = await store.claim(10, 10, "worker2", 6e4);
+          for (const l of reclaim) expect7(blockedSet.has(l.stream)).toBe(false);
+        },
+        timeout
+      );
     });
   });
 };
@@ -4149,6 +4158,103 @@ var runStoreTck = (options) => {
         }
       });
     });
+    describe8.skipIf(!caps.lease_correlation)(
+      "correlation lease via subscribe (capability)",
+      () => {
+        const by = () => `corr-${uid()}`;
+        const key = () => `key-${uid()}`;
+        const take = (k, who, millis = 1e4) => store.subscribe([], void 0, { key: k, by: who, millis });
+        const release = async (k, who) => {
+          await take(k, who, 1);
+          await new Promise((r) => setTimeout(r, 20));
+        };
+        it7("grants the lease to the first caller", async () => {
+          const k = key();
+          const who = by();
+          expect8((await take(k, who)).correlating).toBe(true);
+          await release(k, who);
+        });
+        it7("answers undefined when no correlator is supplied", async () => {
+          expect8(await store.subscribe([])).not.toHaveProperty("correlating");
+        });
+        it7("refuses a second holder while the lease is live", async () => {
+          const k = key();
+          const who = by();
+          expect8((await take(k, who)).correlating).toBe(true);
+          expect8((await take(k, by())).correlating).toBe(false);
+          await release(k, who);
+        });
+        it7("lets the same holder renew rather than failing", async () => {
+          const k = key();
+          const who = by();
+          expect8((await take(k, who)).correlating).toBe(true);
+          expect8((await take(k, who)).correlating).toBe(true);
+          await release(k, who);
+        });
+        it7("becomes available again once the lease expires", async () => {
+          const k = key();
+          expect8((await take(k, by(), 1)).correlating).toBe(true);
+          await new Promise((r) => setTimeout(r, 30));
+          const next = by();
+          expect8((await take(k, next)).correlating).toBe(true);
+          await release(k, next);
+        });
+        it7("keys leases independently, so one correlator cannot starve another", async () => {
+          const a = key();
+          const b = key();
+          const holder_a = by();
+          const holder_b = by();
+          expect8((await take(a, holder_a)).correlating).toBe(true);
+          expect8((await take(b, holder_b)).correlating).toBe(true);
+          await release(a, holder_a);
+          await release(b, holder_b);
+        });
+        it7("still advances the checkpoint for a caller that loses the lease", async () => {
+          const k = key();
+          const holder = by();
+          expect8((await take(k, holder)).correlating).toBe(true);
+          const loser = await store.subscribe([], 7777, {
+            key: k,
+            by: by(),
+            millis: 1e4
+          });
+          expect8(loser.correlating).toBe(false);
+          expect8(loser.correlated_at).toBeGreaterThanOrEqual(7777);
+          await release(k, holder);
+        });
+        it7("seeds a new key from the shared floor, then lets it diverge", async () => {
+          const a = key();
+          const holder_a = by();
+          const first = await store.subscribe([], 4100, {
+            key: a,
+            by: holder_a,
+            millis: 1e4
+          });
+          expect8(first.correlated_at).toBeGreaterThanOrEqual(4100);
+          const b = key();
+          const holder_b = by();
+          const second = await store.subscribe([], void 0, {
+            key: b,
+            by: holder_b,
+            millis: 1e4
+          });
+          expect8(second.correlated_at).toBeGreaterThanOrEqual(4100);
+          await store.subscribe([], 9e3, {
+            key: a,
+            by: holder_a,
+            millis: 1e4
+          });
+          const b_again = await store.subscribe([], void 0, {
+            key: b,
+            by: holder_b,
+            millis: 1e4
+          });
+          expect8(b_again.correlated_at).toBe(second.correlated_at);
+          await release(a, holder_a);
+          await release(b, holder_b);
+        });
+      }
+    );
     describe8.skipIf(!caps.restore)("restore (capability)", () => {
       beforeEach(async () => {
         await store.drop();