@rotorsoft/act-tck 1.1.0 → 1.3.0

package/dist/index.cjs

@@ -1550,10 +1550,20 @@ var runStoreTck = (options) => {
         await store.drop();
         await store.seed();
       });
-      const asSource = (rows) => (async function* () {
-        for (const r of rows) yield r;
-      })();
-      const row = (originalId, stream, version, name, created, data = {}) => ({
+      const asSource = (events) => ({
+        async query(callback) {
+          for (const e of events)
+            await Promise.resolve(
+              callback(
+                e
+              )
+            );
+          return events.length;
+        },
+        async dispose() {
+        }
+      });
+      const event = (originalId, stream, version, name, created, data = {}) => ({
         id: originalId,
         name,
         data,
@@ -1562,11 +1572,20 @@ var runStoreTck = (options) => {
         created,
         meta: { correlation: "restore-tck", causation: {} }
       });
+      const restore = async (source, opts = {}) => {
+        const cache = new import_act.InMemoryCache();
+        const app = (0, import_act.act)().build({ scoped: { store, cache } });
+        try {
+          return await app.restore(source, opts);
+        } finally {
+          await source.dispose();
+          await cache.dispose();
+        }
+      };
       (0, import_vitest3.it)("returns kept=0 on an empty source", async () => {
-        const result = await store.restore(asSource([]));
+        const result = await restore(asSource([]));
         (0, import_vitest3.expect)(result.kept).toBe(0);
         (0, import_vitest3.expect)(result.duration_ms).toBeGreaterThanOrEqual(0);
-        (0, import_vitest3.expect)(result.dry_run).toBe(false);
         (0, import_vitest3.expect)(result.dropped).toEqual({
           closed_streams: 0,
           snapshots: 0,
@@ -1580,12 +1599,12 @@ var runStoreTck = (options) => {
         const t0 = /* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z");
         const t1 = /* @__PURE__ */ new Date("2020-01-02T00:00:00.000Z");
         const t2 = /* @__PURE__ */ new Date("2020-01-03T00:00:00.000Z");
-        const rows = [
-          row(1, s, 0, "Incremented", t0, { amount: 1 }),
-          row(2, s, 1, "Incremented", t1, { amount: 2 }),
-          row(3, s, 2, "Decremented", t2, { amount: 1 })
+        const events = [
+          event(1, s, 0, "Incremented", t0, { amount: 1 }),
+          event(2, s, 1, "Incremented", t1, { amount: 2 }),
+          event(3, s, 2, "Decremented", t2, { amount: 1 })
         ];
-        const result = await store.restore(asSource(rows));
+        const result = await restore(asSource(events));
         (0, import_vitest3.expect)(result.kept).toBe(3);
         const back = [];
         await store.query(
@@ -1631,13 +1650,13 @@ var runStoreTck = (options) => {
         const a = `restore-multi-a-${uid()}`;
         const b = `restore-multi-b-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-06-01T00:00:00.000Z");
-        const rows = [
-          row(1, a, 0, "Incremented", t, { amount: 10 }),
-          row(2, b, 0, "Incremented", t, { amount: 20 }),
-          row(3, a, 1, "Decremented", t, { amount: 5 }),
-          row(4, b, 1, "Incremented", t, { amount: 30 })
+        const events = [
+          event(1, a, 0, "Incremented", t, { amount: 10 }),
+          event(2, b, 0, "Incremented", t, { amount: 20 }),
+          event(3, a, 1, "Decremented", t, { amount: 5 }),
+          event(4, b, 1, "Incremented", t, { amount: 30 })
         ];
-        const result = await store.restore(asSource(rows));
+        const result = await restore(asSource(events));
         (0, import_vitest3.expect)(result.kept).toBe(4);
         const aBack = [];
         const bBack = [];
@@ -1656,10 +1675,10 @@ var runStoreTck = (options) => {
         (0, import_vitest3.expect)(aBack.map((e) => e.version)).toEqual([0, 1]);
         (0, import_vitest3.expect)(bBack.map((e) => e.version)).toEqual([0, 1]);
       });
-      (0, import_vitest3.it)("accepts ISO string `created` and parses to Date", async () => {
+      (0, import_vitest3.it)("preserves Date `created` verbatim", async () => {
         const s = `restore-isoc-${uid()}`;
         const iso = "2021-07-15T12:34:56.789Z";
-        await store.restore(
+        await restore(
           asSource([
             {
               id: 1,
@@ -1667,7 +1686,7 @@ var runStoreTck = (options) => {
               version: 0,
               name: "Incremented",
               data: { amount: 1 },
-              created: iso,
+              created: new Date(iso),
               meta: { correlation: "restore-tck", causation: {} }
             }
           ])
@@ -1691,8 +1710,8 @@ var runStoreTck = (options) => {
         );
         const fresh = `restore-fresh-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z");
-        await store.restore(
-          asSource([row(1, fresh, 0, "Incremented", t, { amount: 99 })])
+        await restore(
+          asSource([event(1, fresh, 0, "Incremented", t, { amount: 99 })])
         );
         const oldBack = await collect(store, {
           stream: old,
@@ -1717,14 +1736,14 @@ var runStoreTck = (options) => {
         };
         const before = await collectStreams();
         (0, import_vitest3.expect)(before.includes(sub)).toBe(true);
-        await store.restore(asSource([]));
+        await restore(asSource([]));
         const after = await collectStreams();
         (0, import_vitest3.expect)(after.includes(sub)).toBe(false);
       });
       (0, import_vitest3.it)("preserves snapshot events through restore", async () => {
         const s = `restore-snap-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-04-01T00:00:00.000Z");
-        await store.restore(
+        await restore(
           asSource([
             {
               id: 1,
@@ -1748,7 +1767,7 @@ var runStoreTck = (options) => {
       (0, import_vitest3.it)("rewrites causation refs through the old\u2192new id map", async () => {
         const s = `restore-caus-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-08-01T00:00:00.000Z");
-        const rows = [
+        const events = [
           {
             id: 5,
             stream: s,
@@ -1787,7 +1806,7 @@ var runStoreTck = (options) => {
             }
           }
         ];
-        await store.restore(asSource(rows));
+        await restore(asSource(events));
         const back = [];
         await store.query(
           (e) => {
@@ -1803,7 +1822,7 @@ var runStoreTck = (options) => {
       (0, import_vitest3.it)("leaves causation refs unmapped when the target isn't in the source", async () => {
         const s = `restore-orphan-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-09-01T00:00:00.000Z");
-        await store.restore(
+        await restore(
           asSource([
             {
               id: 1,
@@ -1837,18 +1856,26 @@ var runStoreTck = (options) => {
           [inc(1), inc(2), inc(3)],
           makeMeta({ stream: original })
         );
-        const explosive = (async function* () {
-          yield row(
-            1,
-            `restore-explode-${uid()}`,
-            0,
-            "Incremented",
-            /* @__PURE__ */ new Date(),
-            { amount: 1 }
-          );
-          throw new Error("boom");
-        })();
-        await (0, import_vitest3.expect)(store.restore(explosive)).rejects.toThrow("boom");
+        const explosive = {
+          async query(callback) {
+            await Promise.resolve(
+              callback(
+                event(
+                  1,
+                  `restore-explode-${uid()}`,
+                  0,
+                  "Incremented",
+                  /* @__PURE__ */ new Date(),
+                  { amount: 1 }
+                )
+              )
+            );
+            throw new Error("boom");
+          },
+          async dispose() {
+          }
+        };
+        await (0, import_vitest3.expect)(restore(explosive)).rejects.toThrow("boom");
         const back = [];
         await store.query(
           (e) => {
@@ -1859,6 +1886,50 @@ var runStoreTck = (options) => {
         (0, import_vitest3.expect)(back).toHaveLength(3);
         (0, import_vitest3.expect)(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
       });
+      (0, import_vitest3.it)("drop_snapshots: skips SNAP_EVENT rows and counts them", async () => {
+        const s = `restore-drop-snap-${uid()}`;
+        const t = /* @__PURE__ */ new Date("2020-10-01T00:00:00.000Z");
+        const result = await restore(
+          asSource([
+            event(1, s, 0, "Incremented", t, { amount: 1 }),
+            {
+              id: 2,
+              stream: s,
+              version: 1,
+              name: import_act.SNAP_EVENT,
+              data: { count: 1 },
+              created: t,
+              meta: { correlation: "snap", causation: {} }
+            },
+            event(3, s, 2, "Incremented", t, { amount: 2 })
+          ]),
+          { drop_snapshots: true }
+        );
+        (0, import_vitest3.expect)(result.kept).toBe(2);
+        (0, import_vitest3.expect)(result.dropped.snapshots).toBe(1);
+        const back = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          with_snaps: true
+        });
+        (0, import_vitest3.expect)(back).toHaveLength(2);
+        (0, import_vitest3.expect)(
+          back.every((e) => e.name !== import_act.SNAP_EVENT)
+        ).toBe(true);
+      });
+      (0, import_vitest3.it)("on_progress fires once per event (caller throttles)", async () => {
+        const calls = [];
+        const s = `restore-progress-${uid()}`;
+        const t = /* @__PURE__ */ new Date("2021-02-01T00:00:00.000Z");
+        await restore(
+          asSource([
+            event(1, s, 0, "Incremented", t, { amount: 1 }),
+            event(2, s, 1, "Incremented", t, { amount: 2 })
+          ]),
+          { on_progress: (p) => calls.push(p.processed) }
+        );
+        (0, import_vitest3.expect)(calls).toEqual([1, 2]);
+      });
     });
     if (caps.notify) {
       (0, import_vitest3.describe)("notify (capability)", () => {