@dudousxd/nestjs-durable-testing 0.18.0 → 0.19.0

package/dist/index.js

@@ -1324,6 +1324,9 @@ function runStateStoreContract(name, makeStore) {
       engine.register("p-other", "1", async () => "done");
       await engine.start("p-root", {}, "pr");
       await engine.start("p-other", {}, "po");
+      expect3((await engine.waitForRun("pr", {
+        timeoutMs: 2e4
+      })).status).toBe("suspended");
       expect3((await engine.waitForRun("pc", {
         timeoutMs: 2e4
       })).status).toBe("suspended");
@@ -1495,6 +1498,148 @@ function runStateStoreContract(name, makeStore) {
       expect3(await store.countCheckpoints("r1", 0, 4, [])).toBe(0);
     });
     registerCheckpointAggregationCases(t, () => store, run);
+    t("listOrphanedRuns returns incomplete runs with a free or expired lease, oldest first", async () => {
+      expect3(store.listOrphanedRuns).toBeDefined();
+      if (!store.listOrphanedRuns) return;
+      const created = /* @__PURE__ */ __name((offset) => new Date(at.getTime() + offset * 1e3), "created");
+      await store.createRun(run({
+        id: "held",
+        createdAt: created(1)
+      }));
+      expect3(await store.tryLockRun("held", "live", NOW + 3e4, NOW)).toBe(true);
+      await store.createRun(run({
+        id: "expired",
+        createdAt: created(3)
+      }));
+      expect3(await store.tryLockRun("expired", "dead", NOW, NOW - 1)).toBe(true);
+      await store.createRun(run({
+        id: "free",
+        createdAt: created(2)
+      }));
+      await store.createRun(run({
+        id: "compensating",
+        status: "cancelling",
+        createdAt: created(4)
+      }));
+      await store.createRun(run({
+        id: "parked",
+        status: "suspended",
+        createdAt: created(0)
+      }));
+      await store.createRun(run({
+        id: "done",
+        status: "completed",
+        createdAt: created(0)
+      }));
+      await store.createRun(run({
+        id: "tenant",
+        namespace: "beta",
+        createdAt: created(5)
+      }));
+      expect3((await store.listOrphanedRuns(NOW, 10)).map((r) => r.id)).toEqual([
+        "free",
+        "expired",
+        "compensating",
+        "tenant"
+      ]);
+      expect3((await store.listOrphanedRuns(NOW, 2)).map((r) => r.id)).toEqual([
+        "free",
+        "expired"
+      ]);
+      expect3((await store.listOrphanedRuns(NOW, 10, "beta")).map((r) => r.id)).toEqual([
+        "tenant"
+      ]);
+      expect3((await store.listOrphanedRuns(NOW + 3e4, 10)).map((r) => r.id)).toContain("held");
+      expect3(await store.listOrphanedRuns(NOW, 0)).toEqual([]);
+    });
+    t("updateRunIf writes only over an expected status", async () => {
+      expect3(store.updateRunIf).toBeDefined();
+      if (!store.updateRunIf) return;
+      await store.createRun(run({
+        error: {
+          message: "earlier attempt"
+        }
+      }));
+      expect3(await store.updateRunIf("r1", [
+        "suspended",
+        "blocked"
+      ], {
+        status: "completed",
+        output: {
+          total: 1
+        }
+      })).toBe(false);
+      let current = await store.getRun("r1");
+      expect3(current?.status).toBe("running");
+      expect3(current?.output).toBeUndefined();
+      expect3(await store.updateRunIf("r1", [
+        "pending",
+        "running"
+      ], {
+        status: "suspended",
+        wakeAt: 7e3,
+        error: void 0,
+        updatedAt: new Date(at.getTime() + 1e3)
+      })).toBe(true);
+      current = await store.getRun("r1");
+      expect3(current?.status).toBe("suspended");
+      expect3(current?.wakeAt).toBe(7e3);
+      expect3(current?.error).toBeUndefined();
+      expect3(current?.updatedAt.getTime()).toBe(at.getTime() + 1e3);
+      await store.updateRun("r1", {
+        status: "cancelled",
+        error: {
+          message: "cancelled"
+        }
+      });
+      expect3(await store.updateRunIf("r1", [
+        "running",
+        "suspended"
+      ], {
+        status: "completed",
+        output: {
+          total: 2
+        }
+      })).toBe(false);
+      current = await store.getRun("r1");
+      expect3(current?.status).toBe("cancelled");
+      expect3(current?.error).toEqual({
+        message: "cancelled"
+      });
+      expect3(current?.output).toBeUndefined();
+      expect3(await store.updateRunIf("missing", [
+        "running"
+      ], {
+        status: "completed"
+      })).toBe(false);
+      expect3(await store.getRun("missing")).toBeNull();
+    });
+    t("updateRunIf settling a run terminal drops its singleton admission like updateRun", async () => {
+      expect3(store.updateRunIf).toBeDefined();
+      if (!store.updateRunIf) return;
+      await store.createRun(run({
+        tags: [
+          "singleton:k",
+          SINGLETON_ADMITTED_TAG
+        ]
+      }));
+      expect3(await store.updateRunIf("r1", [
+        "running"
+      ], {
+        status: "completed",
+        output: {
+          ok: true
+        }
+      })).toBe(true);
+      const settled = await store.getRun("r1");
+      expect3(settled?.status).toBe("completed");
+      expect3(settled?.output).toEqual({
+        ok: true
+      });
+      expect3(settled?.tags).toEqual([
+        "singleton:k"
+      ]);
+    });
     t("saveCheckpointIfPending writes over a pending row only", async () => {
       expect3(store.saveCheckpointIfPending).toBeDefined();
       if (!store.saveCheckpointIfPending) return;