@reventlessdev/reventless-local 3.0.0-alpha.317 → 3.0.0-alpha.319

package/tests/adapter/LocalPlatformObserveTest.res

@@ -0,0 +1,165 @@
+// What the platform API and the platform MCP server offer a watching tool: the
+// MCP resources for recent logs and all events answer and filter, and the API
+// fields are refused to a caller without the admin group.
+
+@@warning("-44")
+
+open JestGlobals
+
+module Logger = ReventlessCore.Logger
+
+let _ = TestRunner.setup()
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+let identity = (~groups): Reventless.Identity.t => {
+  userId: "u-1",
+  username: "u",
+  groups,
+  provider: InMemory,
+}
+
+let context = (~groups): JSON.t => Obj.magic({"identity": identity(~groups), "authenticated": true})
+
+let admin = () => context(~groups=[Reventless.Role.adminGroup()])
+
+let textOf = (r: McpSdk.readResourceResult): JSON.t =>
+  (r.contents->Array.getUnsafe(0)).text->JSON.parseOrThrow
+
+let field = (json: JSON.t, key: string): JSON.t =>
+  json->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))->Option.getOr(JSON.Encode.null)
+
+let strings = (items: JSON.t, key: string): array<string> =>
+  items
+  ->JSON.Decode.array
+  ->Option.getOr([])
+  ->Array.filterMap(i => i->field(key)->JSON.Decode.string)
+
+describe("MCP resource platform/logs/recent", () => {
+  afterEach(() => LocalLogFeed.resetForTests())
+
+  testPromise("answers with the recent records, filtered by its query", async () => {
+    LocalLogFeed.install(~env=Dict.make())
+    Logger.emit(~level=Warn, ~comp="Projection", ~plugin="Ordering", "warned")
+    Logger.emit(~level=Info, ~comp="Projection", ~plugin="Ordering", "informed")
+    Logger.emit(~level=Error, ~comp="Projection", ~plugin="Catalog", "failed")
+    let all = await LocalPlatformObserve.recentLogs("platform/logs/recent")
+    expect(all->textOf->field("records")->strings("message"))->toEqual([
+      "warned",
+      "informed",
+      "failed",
+    ])
+    let narrowed = await LocalPlatformObserve.recentLogs(
+      "platform/logs/recent?plugins=Ordering&level=warn",
+    )
+    expect(narrowed->textOf->field("records")->strings("message"))->toEqual(["warned"])
+    let last = await LocalPlatformObserve.recentLogs("platform/logs/recent?limit=1")
+    expect(last->textOf->field("records")->strings("message"))->toEqual(["failed"])
+  })
+})
+
+describe("MCP resource platform/events", () => {
+  testPromise("answers with every log's events newest first, filtered by its query", async () => {
+    BackendState.setMemory()
+    LocalEventLogRead.resetForTests()
+    module Bus = LocalBus.MakeSilent()
+    module Dcb = LocalDcbEventLogStorage.Make(Bus)
+    let catalog = await Dcb.make(
+      ~name="CatalogDcbEventLog",
+      ~indexes=[],
+      ~partitionTag=Reventless.DcbTag.Simple({key: "productId"}),
+      ~opts,
+    ).operations->TestRunner.resolve
+    LocalEventLogRead.notePlugin(~log="CatalogDcbEventLog", ~plugin="Catalog")
+    let add = async (productId, correlationId) => {
+      let _ = await catalog.append([
+        {
+          eventType: "Added",
+          data: JSON.Encode.null,
+          tags: [{key: "productId", value: productId}],
+          meta: ReventlessCore.Message.generateMeta(~service="test", ~correlationId),
+        },
+      ])
+    }
+    await add("p-1", "flow-a")
+    await add("p-2", "flow-b")
+    await add("p-3", "flow-a")
+    let all = await LocalPlatformObserve.events("platform/events")
+    let tagValues = page =>
+      page
+      ->textOf
+      ->field("edges")
+      ->JSON.Decode.array
+      ->Option.getOr([])
+      ->Array.map(edge => edge->field("node")->field("tags")->strings("value")->Array.join(","))
+    expect(all->tagValues)->toEqual(["p-3", "p-2", "p-1"])
+    let flow = await LocalPlatformObserve.events("platform/events?correlationId=flow-a&first=1")
+    expect(flow->tagValues)->toEqual(["p-3"])
+    let cursor = flow->textOf->field("pageInfo")->field("endCursor")->JSON.Decode.string
+    let next = await LocalPlatformObserve.events(
+      `platform/events?correlationId=flow-a&first=1&after=${cursor->Option.getOr("")}`,
+    )
+    expect(next->tagValues)->toEqual(["p-1"])
+    let none = await LocalPlatformObserve.events("platform/events?plugins=Ordering")
+    expect(none->tagValues)->toEqual([])
+  })
+})
+
+describe("the platform API's watching fields", () => {
+  afterEach(() => Logger.clearLevels())
+
+  let server = () => {
+    let s = ReventlessGraphqlServer.GraphQL_ServerInstance.make(~label="Test")
+    LocalPlatformObserve.registerGraphQL(s)
+    s
+  }
+
+  testPromise("are refused to a caller without the admin group", async () => {
+    let s = server()
+    let refused = async (resolver: option<GraphqlYoga.resolverFn>) => {
+      let run = resolver->Option.getOrThrow
+      switch await run(JSON.Encode.null, JSON.Encode.null, context(~groups=["Customer"])) {
+      | _ => false
+      | exception _ => true
+      }
+    }
+    expect(await refused(s.getQueryResolver(LocalPlatformObserve.eventLogField)))->toBe(true)
+    expect(await refused(s.getQueryResolver(LocalPlatformObserve.logLevelsField)))->toBe(true)
+    expect(await refused(s.getMutationResolver(LocalPlatformObserve.setLogLevelField)))->toBe(true)
+  })
+
+  testPromise("set and list the log levels for an admin", async () => {
+    let s = server()
+    let set = s.getMutationResolver(LocalPlatformObserve.setLogLevelField)->Option.getOrThrow
+    let args = JSON.parseOrThrow(`{"plugin":"Ordering","comp":"Projection","level":"DEBUG"}`)
+    let answer = await set(JSON.Encode.null, args, admin())
+    expect(answer->field("settings"))->toEqual(
+      JSON.parseOrThrow(`[{"level":"DEBUG","plugin":"Ordering","comp":"Projection"}]`),
+    )
+    expect(Logger.minLevelFor(~plugin="Ordering", ~comp="Projection", ()))->toEqual(
+      Some(Logger.Debug),
+    )
+    let cleared = await set(
+      JSON.Encode.null,
+      JSON.parseOrThrow(`{"plugin":"Ordering","comp":"Projection","level":null}`),
+      admin(),
+    )
+    expect(cleared->field("settings"))->toEqual(JSON.parseOrThrow(`[]`))
+  })
+
+  testPromise("the event log answers an admin with a connection", async () => {
+    BackendState.setMemory()
+    LocalEventLogRead.resetForTests()
+    let s = server()
+    let read = s.getQueryResolver(LocalPlatformObserve.eventLogField)->Option.getOrThrow
+    let answer = await read(JSON.Encode.null, JSON.parseOrThrow(`{"first":5}`), admin())
+    expect(answer->field("edges"))->toEqual(JSON.Encode.array([]))
+    expect(answer->field("pageInfo")->field("hasNextPage"))->toEqual(JSON.Encode.bool(false))
+  })
+
+  testSync("the SDL builds into a schema", () => {
+    let s = server()
+    let sdl = s.buildSdl()
+    expect(sdl->String.includes("Platform_EventLog(filter: Platform_EventLogFilter"))->toBe(true)
+    let _ = GraphqlYoga.createSchema({"typeDefs": sdl, "resolvers": Dict.make()})
+  })
+})

package/tests/adapter/LocalPlatformObserveTest.res.mjs

@@ -0,0 +1,183 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as GraphqlYoga from "graphql-yoga";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Role$Reventless from "@reventlessdev/reventless-spec/src/types/Role.res.mjs";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as BackendState$ReventlessLocal from "../../src/adapter/BackendState.res.mjs";
+import * as LocalLogFeed$ReventlessLocal from "../../src/adapter/LocalLogFeed.res.mjs";
+import * as LocalEventLogRead$ReventlessLocal from "../../src/adapter/LocalEventLogRead.res.mjs";
+import * as LocalPlatformObserve$ReventlessLocal from "../../src/adapter/LocalPlatformObserve.res.mjs";
+import * as LocalDcbEventLogStorage$ReventlessLocal from "../../src/adapter/DcbEventLog/LocalDcbEventLogStorage.res.mjs";
+import * as GraphQL_ServerInstance$ReventlessGraphqlServer from "@reventlessdev/reventless-graphql-server/src/GraphQL_ServerInstance.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+function identity(groups) {
+  return {
+    userId: "u-1",
+    username: "u",
+    groups: groups,
+    provider: "InMemory"
+  };
+}
+
+function context(groups) {
+  return {
+    identity: identity(groups),
+    authenticated: true
+  };
+}
+
+function admin() {
+  return context([Role$Reventless.adminGroup()]);
+}
+
+function textOf(r) {
+  return JSON.parse(r.contents[0].text);
+}
+
+function field(json, key) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d[key]), null);
+}
+
+function strings(items, key) {
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_JSON.Decode.array(items), []), i => Stdlib_JSON.Decode.string(field(i, key)));
+}
+
+globalThis.describe("MCP resource platform/logs/recent", () => {
+  globalThis.afterEach(() => LocalLogFeed$ReventlessLocal.resetForTests());
+  globalThis.test("answers with the recent records, filtered by its query", async () => {
+    LocalLogFeed$ReventlessLocal.install({});
+    Logger$ReventlessCore.emit("Warn", "Projection", "Ordering", undefined, undefined, "warned");
+    Logger$ReventlessCore.emit("Info", "Projection", "Ordering", undefined, undefined, "informed");
+    Logger$ReventlessCore.emit("Error", "Projection", "Catalog", undefined, undefined, "failed");
+    let all = await LocalPlatformObserve$ReventlessLocal.recentLogs("platform/logs/recent");
+    globalThis.expect(strings(field(textOf(all), "records"), "message")).toEqual([
+      "warned",
+      "informed",
+      "failed"
+    ]);
+    let narrowed = await LocalPlatformObserve$ReventlessLocal.recentLogs("platform/logs/recent?plugins=Ordering&level=warn");
+    globalThis.expect(strings(field(textOf(narrowed), "records"), "message")).toEqual(["warned"]);
+    let last = await LocalPlatformObserve$ReventlessLocal.recentLogs("platform/logs/recent?limit=1");
+    globalThis.expect(strings(field(textOf(last), "records"), "message")).toEqual(["failed"]);
+  });
+});
+
+globalThis.describe("MCP resource platform/events", () => {
+  globalThis.test("answers with every log's events newest first, filtered by its query", async () => {
+    BackendState$ReventlessLocal.setMemory();
+    LocalEventLogRead$ReventlessLocal.resetForTests();
+    let Bus = LocalBus$ReventlessLocal.MakeSilent({});
+    let Dcb = LocalDcbEventLogStorage$ReventlessLocal.Make(Bus);
+    let catalog = await TestRunner$ReventlessLocal.resolve(Dcb.make("CatalogDcbEventLog", [], {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined, opts).operations);
+    LocalEventLogRead$ReventlessLocal.notePlugin("CatalogDcbEventLog", "Catalog");
+    let add = async (productId, correlationId) => {
+      await catalog.append([{
+          eventType: "Added",
+          data: null,
+          tags: [{
+              key: "productId",
+              value: productId
+            }],
+          meta: Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, correlationId, undefined, undefined)
+        }], undefined);
+    };
+    await add("p-1", "flow-a");
+    await add("p-2", "flow-b");
+    await add("p-3", "flow-a");
+    let all = await LocalPlatformObserve$ReventlessLocal.events("platform/events");
+    let tagValues = page => Stdlib_Option.getOr(Stdlib_JSON.Decode.array(field(textOf(page), "edges")), []).map(edge => strings(field(field(edge, "node"), "tags"), "value").join(","));
+    globalThis.expect(tagValues(all)).toEqual([
+      "p-3",
+      "p-2",
+      "p-1"
+    ]);
+    let flow = await LocalPlatformObserve$ReventlessLocal.events("platform/events?correlationId=flow-a&first=1");
+    globalThis.expect(tagValues(flow)).toEqual(["p-3"]);
+    let cursor = Stdlib_JSON.Decode.string(field(field(textOf(flow), "pageInfo"), "endCursor"));
+    let next = await LocalPlatformObserve$ReventlessLocal.events(`platform/events?correlationId=flow-a&first=1&after=` + Stdlib_Option.getOr(cursor, ""));
+    globalThis.expect(tagValues(next)).toEqual(["p-1"]);
+    let none = await LocalPlatformObserve$ReventlessLocal.events("platform/events?plugins=Ordering");
+    globalThis.expect(tagValues(none)).toEqual([]);
+  });
+});
+
+globalThis.describe("the platform API's watching fields", () => {
+  globalThis.afterEach(() => Logger$ReventlessCore.clearLevels());
+  let server = () => {
+    let s = GraphQL_ServerInstance$ReventlessGraphqlServer.make("Test");
+    LocalPlatformObserve$ReventlessLocal.registerGraphQL(s);
+    return s;
+  };
+  globalThis.test("are refused to a caller without the admin group", async () => {
+    let s = server();
+    let refused = async resolver => {
+      let run = Stdlib_Option.getOrThrow(resolver, undefined);
+      try {
+        await run(null, null, context(["Customer"]));
+        return false;
+      } catch (exn) {
+        return true;
+      }
+    };
+    globalThis.expect(await refused(s.getQueryResolver(LocalPlatformObserve$ReventlessLocal.eventLogField))).toBe(true);
+    globalThis.expect(await refused(s.getQueryResolver(LocalPlatformObserve$ReventlessLocal.logLevelsField))).toBe(true);
+    globalThis.expect(await refused(s.getMutationResolver(LocalPlatformObserve$ReventlessLocal.setLogLevelField))).toBe(true);
+  });
+  globalThis.test("set and list the log levels for an admin", async () => {
+    let s = server();
+    let set = Stdlib_Option.getOrThrow(s.getMutationResolver(LocalPlatformObserve$ReventlessLocal.setLogLevelField), undefined);
+    let args = JSON.parse(`{"plugin":"Ordering","comp":"Projection","level":"DEBUG"}`);
+    let answer = await set(null, args, context([Role$Reventless.adminGroup()]));
+    globalThis.expect(field(answer, "settings")).toEqual(JSON.parse(`[{"level":"DEBUG","plugin":"Ordering","comp":"Projection"}]`));
+    globalThis.expect(Logger$ReventlessCore.minLevelFor("Ordering", "Projection", undefined)).toEqual("Debug");
+    let cleared = await set(null, JSON.parse(`{"plugin":"Ordering","comp":"Projection","level":null}`), context([Role$Reventless.adminGroup()]));
+    globalThis.expect(field(cleared, "settings")).toEqual(JSON.parse(`[]`));
+  });
+  globalThis.test("the event log answers an admin with a connection", async () => {
+    BackendState$ReventlessLocal.setMemory();
+    LocalEventLogRead$ReventlessLocal.resetForTests();
+    let s = server();
+    let read = Stdlib_Option.getOrThrow(s.getQueryResolver(LocalPlatformObserve$ReventlessLocal.eventLogField), undefined);
+    let answer = await read(null, JSON.parse(`{"first":5}`), context([Role$Reventless.adminGroup()]));
+    globalThis.expect(field(answer, "edges")).toEqual([]);
+    globalThis.expect(field(field(answer, "pageInfo"), "hasNextPage")).toEqual(false);
+  });
+  globalThis.test("the SDL builds into a schema", () => {
+    let s = server();
+    let sdl = s.buildSdl();
+    globalThis.expect(sdl.includes("Platform_EventLog(filter: Platform_EventLogFilter")).toBe(true);
+    GraphqlYoga.createSchema({
+      typeDefs: sdl,
+      resolvers: {}
+    });
+  });
+});
+
+let Logger;
+
+export {
+  Logger,
+  opts,
+  identity,
+  context,
+  admin,
+  textOf,
+  field,
+  strings,
+}
+/*  Not a pure module */

package/tests/adapter/LocalTapLinesTest.res

@@ -0,0 +1,207 @@
+// The event tap's lines besides events: each command's outcome, once, and each
+// row a projection changed, its values redacted; a rejected command is also kept
+// in the problem ring.
+
+open JestGlobals
+
+module Outcome = ReventlessCore.CommandTopic_Helpers
+module ViewChange = ReventlessCore.ViewChange
+
+let sleep = (ms: int): promise<unit> =>
+  Promise.make((resolve, _) => {
+    let _ = setTimeout(() => resolve(), ms)
+  })
+
+let until = async (~ms=2000, cond: unit => bool): bool => {
+  let waited = ref(0)
+  while !cond() && waited.contents < ms {
+    await sleep(5)
+    waited := waited.contents + 5
+  }
+  cond()
+}
+
+type client = {socket: NodeNet.socket, mutable received: string}
+
+let connect = (port: int): promise<client> =>
+  Promise.make((resolve, _) => {
+    let c = ref(None)
+    let socket = NodeNet.connect(port, "127.0.0.1", () =>
+      c.contents->Option.forEach(client => resolve(client))
+    )
+    socket->NodeNet.setEncoding("utf8")
+    socket->NodeNet.onSocketError(_ => ())
+    let client = {socket, received: ""}
+    socket->NodeNet.onSocketData(chunk => client.received = client.received ++ chunk)
+    c := Some(client)
+  })
+
+/** The lines of a kind, as objects, without their time. */
+let linesOf = (c: client, ~kind: string): array<dict<JSON.t>> =>
+  c.received
+  ->String.split("\n")
+  ->Array.filterMap(l =>
+    switch l->JSON.parseOrThrow->JSON.Decode.object {
+    | Some(d) if d->Dict.get("kind") == Some(JSON.String(kind)) =>
+      d->Dict.delete("ts")
+      Some(d)
+    | _ => None
+    | exception _ => None
+    }
+  )
+
+@schema
+type row = {
+  name: string,
+  token: @s.matches(Reventless.Sensitive.string) string,
+}
+
+let connectTap = async () => {
+  LocalEventTap.resetForTests()
+  LocalLogFeed.resetForTests()
+  LocalTapLines.resetForTests()
+  LocalLogFeed.install(~env=Dict.make())
+  LocalTapLines.install()
+  let port = await Promise.make((resolve, _) =>
+    LocalEventTap.start(~env=Dict.make(), ~onBound=resolve, ())
+  )
+  let tap = await connect(port)
+  let _ = await until(() => LocalEventTap.hasReaders())
+  tap
+}
+
+let disconnect = async (tap: client) => {
+  NodeNet.destroySocket(tap.socket)
+  LocalTapLines.resetForTests()
+  await LocalEventTap.stopForTests()
+  LocalLogFeed.resetForTests()
+}
+
+describe("LocalTapLines", () => {
+  test("an accepted and a rejected command each appear once on the tap", async () => {
+    let tap = await connectTap()
+
+    Outcome.reportAccepted(
+      ~component="Order",
+      ~correlationId="flow-1",
+      "m-1",
+      {entityId: "o-1", eventCount: 2},
+    )
+    Outcome.reportRejected(
+      ~component="Order",
+      ~cause=DomainRejection,
+      ~correlationId="flow-1",
+      "m-2",
+      {errorCode: "AlreadyExists", errorDetail: `{"name":"Widget"}`},
+    )
+    let _ = await until(() => tap->linesOf(~kind="commandOutcome")->Array.length >= 2)
+    await sleep(20)
+
+    expect(tap->linesOf(~kind="commandOutcome"))->toEqual([
+      Dict.fromArray([
+        ("kind", JSON.String("commandOutcome")),
+        ("component", JSON.String("Order")),
+        ("msgId", JSON.String("m-1")),
+        ("correlationId", JSON.String("flow-1")),
+        ("outcome", JSON.String("accepted")),
+        ("entityId", JSON.String("o-1")),
+        ("eventCount", JSON.Number(2.)),
+      ]),
+      Dict.fromArray([
+        ("kind", JSON.String("commandOutcome")),
+        ("component", JSON.String("Order")),
+        ("msgId", JSON.String("m-2")),
+        ("correlationId", JSON.String("flow-1")),
+        ("outcome", JSON.String("rejected")),
+        ("errorCode", JSON.String("AlreadyExists")),
+        ("cause", JSON.String("DOMAIN")),
+      ]),
+    ])
+    // Not an event line: no sentinel prefix.
+    expect(tap.received->String.includes("@@RVLESS_EVT@@"))->toBe(false)
+
+    // The rejection, and only it, is kept as a warning in the problem ring.
+    let kept =
+      LocalLogFeed.recentRecords(~filter={level: Warn})->Array.filter(
+        r => r.message == "command rejected",
+      )
+    expect(kept->Array.map(r => (r.comp, r.annotations->Dict.get("msgId"))))->toEqual([
+      (Some("CommandTopic(Order)"), Some("m-2")),
+    ])
+    expect(
+      (kept->Array.getUnsafe(0)).detail->Option.map(j => j->JSON.stringify)->Option.getOr(""),
+    )->toBe(`{"component":"Order","errorCode":"AlreadyExists","cause":"DOMAIN","errorDetail":{"name":"Widget"}}`)
+
+    await disconnect(tap)
+  })
+
+  test("an infrastructure failure is kept as an error", async () => {
+    let tap = await connectTap()
+    Outcome.reportRejected(
+      ~component="Order",
+      ~cause=InfrastructureFailure,
+      "m-3",
+      {errorCode: "AppendFailed", errorDetail: "store down"},
+    )
+    let kept =
+      LocalLogFeed.recentRecords(~filter={level: Error})->Array.filter(
+        r => r.message == "command rejected",
+      )
+    expect(kept->Array.length)->toBe(1)
+    await disconnect(tap)
+  })
+
+  test("a view change is sent with its values redacted", async () => {
+    let tap = await connectTap()
+    let onChange = ViewChange.reporter(
+      ~comp="ReadModel(Accounts)",
+      ~view="Accounts",
+      ~stateToJson=r => r->Reventless.Util_Sury.toJson(rowSchema),
+    )
+    onChange({
+      key: "a-1",
+      kind: Changed,
+      before: {name: "Ada", token: "old-secret"},
+      after: {name: "Ada L.", token: "new-secret"},
+      sources: [{msgId: "m-1", correlationId: "flow-1", entityId: "a-1", entityType: "Account"}],
+    })
+    let _ = await until(() => tap->linesOf(~kind="viewChange")->Array.length >= 1)
+
+    let lines = tap->linesOf(~kind="viewChange")
+    expect(lines->Array.length)->toBe(1)
+    let line = lines->Array.getUnsafe(0)->JSON.Encode.object->JSON.stringify
+    expect(line->String.includes("secret"))->toBe(false)
+    expect(line->String.includes(Reventless.LogRedaction.placeholder))->toBe(true)
+    expect(line->String.includes(`"name":"Ada L."`))->toBe(true)
+    expect(
+      line->String.startsWith(`{"kind":"viewChange","view":"Accounts","key":"a-1","change":"changed","fields":["name","token"],"sources":[{"msgId":"m-1","correlationId":"flow-1","entityId":"a-1","entityType":"Account"}],"correlationId":"flow-1","before":`),
+    )->toBe(true)
+
+    await disconnect(tap)
+  })
+})
+
+describe("the outcome line names its cause", () => {
+  testSync("a command an automation sent says which event it acted on", () => {
+    let line = LocalTapLines.outcomeLine({
+      component: "Notice",
+      reference: "cmd-2",
+      correlationId: "flow-1",
+      causationId: "evt-7",
+      outcome: OutcomeAccepted({entityId: Some("n-1"), eventCount: 1}),
+    })
+    let d = line->JSON.parseOrThrow->JSON.Decode.object->Option.getOrThrow
+    expect(d->Dict.get("causationId"))->toEqual(Some(JSON.String("evt-7")))
+    expect(d->Dict.get("msgId"))->toEqual(Some(JSON.String("cmd-2")))
+  })
+
+  testSync("a command sent from outside has none", () => {
+    let line = LocalTapLines.outcomeLine({
+      component: "Order",
+      reference: "cmd-1",
+      outcome: OutcomeAccepted({entityId: None, eventCount: 1}),
+    })
+    let d = line->JSON.parseOrThrow->JSON.Decode.object->Option.getOrThrow
+    expect(d->Dict.get("causationId"))->toEqual(None)
+  })
+})