@rotorsoft/act-tck 1.1.0 → 1.3.0

package/dist/index.js

@@ -189,7 +189,13 @@ var runLoggerTck = (options) => {
 };
 
 // src/store-tck.ts
-import { ConcurrencyError, SNAP_EVENT, TOMBSTONE_EVENT } from "@rotorsoft/act";
+import {
+  act,
+  ConcurrencyError,
+  InMemoryCache,
+  SNAP_EVENT,
+  TOMBSTONE_EVENT
+} from "@rotorsoft/act";
 import { afterAll, beforeAll, describe as describe3, expect as expect3, it as it3 } from "vitest";
 var runStoreTck = (options) => {
   describe3(`TCK / Store / ${options.name}`, () => {
@@ -1509,10 +1515,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,
@@ -1521,11 +1537,20 @@ var runStoreTck = (options) => {
         created,
         meta: { correlation: "restore-tck", causation: {} }
       });
+      const restore = async (source, opts = {}) => {
+        const cache = new InMemoryCache();
+        const app = act().build({ scoped: { store, cache } });
+        try {
+          return await app.restore(source, opts);
+        } finally {
+          await source.dispose();
+          await cache.dispose();
+        }
+      };
       it3("returns kept=0 on an empty source", async () => {
-        const result = await store.restore(asSource([]));
+        const result = await restore(asSource([]));
         expect3(result.kept).toBe(0);
         expect3(result.duration_ms).toBeGreaterThanOrEqual(0);
-        expect3(result.dry_run).toBe(false);
         expect3(result.dropped).toEqual({
           closed_streams: 0,
           snapshots: 0,
@@ -1539,12 +1564,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));
         expect3(result.kept).toBe(3);
         const back = [];
         await store.query(
@@ -1590,13 +1615,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));
         expect3(result.kept).toBe(4);
         const aBack = [];
         const bBack = [];
@@ -1615,10 +1640,10 @@ var runStoreTck = (options) => {
         expect3(aBack.map((e) => e.version)).toEqual([0, 1]);
         expect3(bBack.map((e) => e.version)).toEqual([0, 1]);
       });
-      it3("accepts ISO string `created` and parses to Date", async () => {
+      it3("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,
@@ -1626,7 +1651,7 @@ var runStoreTck = (options) => {
               version: 0,
               name: "Incremented",
               data: { amount: 1 },
-              created: iso,
+              created: new Date(iso),
               meta: { correlation: "restore-tck", causation: {} }
             }
           ])
@@ -1650,8 +1675,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,
@@ -1676,14 +1701,14 @@ var runStoreTck = (options) => {
         };
         const before = await collectStreams();
         expect3(before.includes(sub)).toBe(true);
-        await store.restore(asSource([]));
+        await restore(asSource([]));
         const after = await collectStreams();
         expect3(after.includes(sub)).toBe(false);
       });
       it3("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,
@@ -1707,7 +1732,7 @@ var runStoreTck = (options) => {
       it3("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,
@@ -1746,7 +1771,7 @@ var runStoreTck = (options) => {
             }
           }
         ];
-        await store.restore(asSource(rows));
+        await restore(asSource(events));
         const back = [];
         await store.query(
           (e) => {
@@ -1762,7 +1787,7 @@ var runStoreTck = (options) => {
       it3("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,
@@ -1796,18 +1821,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 expect3(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 expect3(restore(explosive)).rejects.toThrow("boom");
         const back = [];
         await store.query(
           (e) => {
@@ -1818,6 +1851,50 @@ var runStoreTck = (options) => {
         expect3(back).toHaveLength(3);
         expect3(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
       });
+      it3("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: SNAP_EVENT,
+              data: { count: 1 },
+              created: t,
+              meta: { correlation: "snap", causation: {} }
+            },
+            event(3, s, 2, "Incremented", t, { amount: 2 })
+          ]),
+          { drop_snapshots: true }
+        );
+        expect3(result.kept).toBe(2);
+        expect3(result.dropped.snapshots).toBe(1);
+        const back = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          with_snaps: true
+        });
+        expect3(back).toHaveLength(2);
+        expect3(
+          back.every((e) => e.name !== SNAP_EVENT)
+        ).toBe(true);
+      });
+      it3("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) }
+        );
+        expect3(calls).toEqual([1, 2]);
+      });
     });
     if (caps.notify) {
       describe3("notify (capability)", () => {