@rotorsoft/act-tck 1.4.0 → 1.5.0

package/dist/index.js

@@ -1895,6 +1895,153 @@ var runStoreTck = (options) => {
         expect3(calls).toEqual([1, 2]);
       });
     });
+    describe3.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
+      it3("commits and loads pii alongside data", async () => {
+        const s = `pii-roundtrip-${uid()}`;
+        const committed = await store.commit(
+          s,
+          [
+            {
+              name: "Incremented",
+              data: { amount: 1 },
+              pii: { email: "u@example.com", name: "Ursula" }
+            }
+          ],
+          makeMeta({ stream: s })
+        );
+        expect3(committed).toHaveLength(1);
+        expect3(committed[0].pii).toEqual({
+          email: "u@example.com",
+          name: "Ursula"
+        });
+        const seen = [];
+        await store.query(
+          (e) => {
+            seen.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        expect3(seen).toHaveLength(1);
+        expect3(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
+        expect3(seen[0].data).toEqual({ amount: 1 });
+      });
+      it3("passes through events without pii (pii is null or undefined on load)", async () => {
+        const s = `pii-none-${uid()}`;
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const seen = [];
+        await store.query(
+          (e) => {
+            seen.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        expect3(seen).toHaveLength(1);
+        expect3(seen[0].pii == null).toBe(true);
+      });
+      it3("wipes pii for every event on the stream via forget_pii", async () => {
+        const s = `pii-forget-${uid()}`;
+        await store.commit(
+          s,
+          [
+            {
+              name: "Incremented",
+              data: { amount: 1 },
+              pii: { email: "a@example.com" }
+            },
+            {
+              name: "Incremented",
+              data: { amount: 2 },
+              pii: { email: "b@example.com" }
+            }
+          ],
+          makeMeta({ stream: s })
+        );
+        const forget = store.forget_pii;
+        expect3(forget).toBeDefined();
+        const wiped = await forget.call(store, s);
+        expect3(wiped).toBe(2);
+        const seen = [];
+        await store.query(
+          (e) => {
+            seen.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        expect3(seen).toHaveLength(2);
+        for (const e of seen) {
+          expect3(e.pii == null).toBe(true);
+          expect3(e.data).toBeDefined();
+        }
+      });
+      it3("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
+        const s = `pii-forget-idem-${uid()}`;
+        await store.commit(
+          s,
+          [
+            {
+              name: "Incremented",
+              data: { amount: 1 },
+              pii: { email: "u@example.com" }
+            }
+          ],
+          makeMeta({ stream: s })
+        );
+        const forget = store.forget_pii;
+        const first = await forget.call(store, s);
+        expect3(first).toBe(1);
+        const second = await forget.call(store, s);
+        expect3(second).toBe(0);
+      });
+      it3("only wipes the targeted stream \u2014 siblings untouched", async () => {
+        const sA = `pii-iso-a-${uid()}`;
+        const sB = `pii-iso-b-${uid()}`;
+        await store.commit(
+          sA,
+          [
+            {
+              name: "Incremented",
+              data: { amount: 1 },
+              pii: { email: "alice@example.com" }
+            }
+          ],
+          makeMeta({ stream: sA })
+        );
+        await store.commit(
+          sB,
+          [
+            {
+              name: "Incremented",
+              data: { amount: 1 },
+              pii: { email: "bob@example.com" }
+            }
+          ],
+          makeMeta({ stream: sB })
+        );
+        await store.forget_pii.call(store, sA);
+        const a = [];
+        await store.query(
+          (e) => {
+            a.push(e);
+          },
+          { stream: sA, stream_exact: true }
+        );
+        expect3(a[0].pii == null).toBe(true);
+        const b = [];
+        await store.query(
+          (e) => {
+            b.push(e);
+          },
+          { stream: sB, stream_exact: true }
+        );
+        expect3(b[0].pii).toEqual({ email: "bob@example.com" });
+      });
+      it3("forget_pii on a stream with no pii events returns 0", async () => {
+        const s = `pii-forget-empty-${uid()}`;
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const wiped = await store.forget_pii.call(store, s);
+        expect3(wiped).toBe(0);
+      });
+    });
     if (caps.notify) {
       describe3("notify (capability)", () => {
         it3("delivers a notification when a different instance commits", async () => {