@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/tests/RunnerUnitTest.res

@@ -0,0 +1,219 @@
+// Runner-side self-tests. Constructs synthetic `Outcome` values and feeds
+// them through `RenderRescript`, `Diff`, and `FormatterJson` / `FormatterTap`
+// to assert the rendered shapes. This is the unit-test layer — CLI-level
+// integration is covered by running `node bin/reventless-gwt.mjs run tests/`
+// against the DSL worked-example suites.
+
+open JestGlobals
+
+let encodeString = (s: string): JSON.t => JSON.Encode.string(s)
+
+let makeTaggedEvent = (~tag: string, ~payload: JSON.t): JSON.t => {
+  let d = Dict.make()
+  d->Dict.set("TAG", JSON.Encode.string(tag))
+  d->Dict.set("_0", payload)
+  JSON.Encode.object(d)
+}
+
+describe("RenderRescript", () => {
+  testPromise("renders tagged variants with BuckleScript representation", async () => {
+    let payload = Dict.make()
+    payload->Dict.set("name", encodeString("Electronics"))
+    let ev = makeTaggedEvent(~tag="CategoryAdded", ~payload=JSON.Encode.object(payload))
+    let rendered = RenderRescript.render(ev)
+    expect(rendered)->toEqual(`CategoryAdded({name: "Electronics"})`)
+  })
+
+  testPromise("renders payload-less variants as bare strings", async () => {
+    let ev = JSON.Encode.string("CategoryArchived")
+    expect(RenderRescript.render(ev))->toEqual(`"CategoryArchived"`)
+  })
+
+  testPromise("renders plain records in field order", async () => {
+    let d = Dict.make()
+    d->Dict.set("id", encodeString("c1"))
+    d->Dict.set("count", JSON.Encode.int(3))
+    let rendered = RenderRescript.render(JSON.Encode.object(d))
+    expect(rendered)->toEqual(`{id: "c1", count: 3}`)
+  })
+
+  testPromise("renderMany splits large arrays across lines", async () => {
+    let a = makeTaggedEvent(~tag="A", ~payload=JSON.Encode.object(Dict.make()))
+    let b = makeTaggedEvent(~tag="B", ~payload=JSON.Encode.object(Dict.make()))
+    let rendered = RenderRescript.renderMany([a, b])
+    expect(rendered->String.includes("A({})"))->toEqual(true)
+    expect(rendered->String.includes("B({})"))->toEqual(true)
+  })
+
+  // Inline-record variants (`Name({...})`) are flattened by ReScript: the record
+  // fields sit beside TAG, not under `_0`. Regression for the dropped-payload bug
+  // where `ProductsNotAvailable({missing: [...]})` rendered as bare
+  // `ProductsNotAvailable`, making error diffs read `X != X`.
+  testPromise("renders inline-record variants with their flattened payload", async () => {
+    let d = Dict.make()
+    d->Dict.set("TAG", encodeString("ProductsNotAvailable"))
+    d->Dict.set("missing", JSON.Encode.array([encodeString("p1x")]))
+    let rendered = RenderRescript.render(JSON.Encode.object(d))
+    expect(rendered)->toEqual(`ProductsNotAvailable({missing: ["p1x"]})`)
+  })
+
+  testPromise("renders multi-field inline-record variants", async () => {
+    let d = Dict.make()
+    d->Dict.set("TAG", encodeString("Conflict"))
+    d->Dict.set("expected", JSON.Encode.int(1))
+    d->Dict.set("got", JSON.Encode.int(2))
+    let rendered = RenderRescript.render(JSON.Encode.object(d))
+    expect(rendered)->toEqual(`Conflict({expected: 1, got: 2})`)
+  })
+})
+
+describe("Diff", () => {
+  testPromise("emits one entry per differing leaf", async () => {
+    let d1 = Dict.make()
+    d1->Dict.set("name", encodeString("A"))
+    d1->Dict.set("count", JSON.Encode.int(1))
+    let d2 = Dict.make()
+    d2->Dict.set("name", encodeString("B"))
+    d2->Dict.set("count", JSON.Encode.int(1))
+    let diff = Diff.diff(JSON.Encode.object(d1), JSON.Encode.object(d2))
+    expect(diff->Array.length)->toEqual(1)
+    let first = diff->Array.getUnsafe(0)
+    expect(first.path)->toEqual("name")
+  })
+
+  testPromise("emits zero entries when values are identical", async () => {
+    let d = Dict.make()
+    d->Dict.set("a", JSON.Encode.int(1))
+    let left = JSON.Encode.object(d)
+    let d2 = Dict.make()
+    d2->Dict.set("a", JSON.Encode.int(1))
+    let right = JSON.Encode.object(d2)
+    expect(Diff.diff(left, right)->Array.length)->toEqual(0)
+  })
+})
+
+describe("FormatterJson.mismatchJson", () => {
+  testPromise("ErrorMismatch carries dual-rendered expected + actualEvents", async () => {
+    // Payload-less variants encode to a bare JSON string — matches sury's
+    // default representation.
+    let expectedError = JSON.Encode.string("CategoryAlreadyExists")
+    let actualEvent = {
+      let p = Dict.make()
+      p->Dict.set("categoryId", encodeString("c1"))
+      p->Dict.set("name", encodeString("X"))
+      makeTaggedEvent(~tag="CategoryAdded", ~payload=JSON.Encode.object(p))
+    }
+    let m = Outcome.ErrorMismatch({
+      expected: expectedError,
+      actual: None,
+      actualEvents: [actualEvent],
+    })
+    let j = FormatterJson.mismatchJson(m, Some("AddCategory"))
+    let str = JSON.stringify(j)
+    expect(str->String.includes(`"kind":"ErrorMismatch"`))->toEqual(true)
+    // Payload-less variant's `type` field carries the constructor name.
+    expect(str->String.includes(`"type":"CategoryAlreadyExists"`))->toEqual(true)
+    expect(
+      str->String.includes(`CategoryAdded({categoryId: \\\"c1\\\", name: \\\"X\\\"})`),
+    )->toEqual(true)
+    expect(str->String.includes(`"locus":"AddCategory.decide"`))->toEqual(true)
+  })
+
+  testPromise("EventsMismatch includes a fieldDiff derived from payloads", async () => {
+    let expected = {
+      let p = Dict.make()
+      p->Dict.set("name", encodeString("Electronics"))
+      [makeTaggedEvent(~tag="Added", ~payload=JSON.Encode.object(p))]
+    }
+    let actual = {
+      let p = Dict.make()
+      p->Dict.set("name", encodeString("Books"))
+      [makeTaggedEvent(~tag="Added", ~payload=JSON.Encode.object(p))]
+    }
+    let m = Outcome.EventsMismatch({expected, actual})
+    let j = FormatterJson.mismatchJson(m, None)
+    let str = JSON.stringify(j)
+    expect(str->String.includes(`"fieldDiff"`))->toEqual(true)
+    expect(str->String.includes(`"path":"0._0.name"`))->toEqual(true)
+  })
+})
+
+describe("Cli.parseArgv", () => {
+  testPromise("parses run subcommand with --format=json --filter=Foo", async () => {
+    let argv = [
+      "/bin/node",
+      "/path/to/bin",
+      "run",
+      "--format=json",
+      "--filter=Foo",
+      "tests/",
+    ]
+    switch Cli.parseArgv(argv) {
+    | Ok(opts) => {
+        expect(opts.subcommand == Run)->toEqual(true)
+        expect(opts.format == Json)->toEqual(true)
+        expect(opts.filters)->toEqual(["Foo"])
+        expect(opts.roots)->toEqual(["tests/"])
+      }
+    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
+    }
+  })
+
+  testPromise("discover subcommand defaults to vscode format", async () => {
+    let argv = ["/bin/node", "/path/to/bin", "discover"]
+    switch Cli.parseArgv(argv) {
+    | Ok(opts) => {
+        expect(opts.subcommand == Discover)->toEqual(true)
+        expect(opts.format == VsCode)->toEqual(true)
+      }
+    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
+    }
+  })
+
+  testPromise("unknown flag reports an error", async () => {
+    let argv = ["/bin/node", "/path/to/bin", "run", "--nonsense"]
+    switch Cli.parseArgv(argv) {
+    | Ok(_) => JsError.throwWithMessage("expected Error")
+    | Error(msg) => expect(msg->String.includes("Unknown flag"))->toEqual(true)
+    }
+  })
+
+  testPromise("no path argument defaults to the cwd subtree (auto-discovery)", async () => {
+    let argv = ["/bin/node", "/path/to/bin", "watch", "--format=vscode"]
+    switch Cli.parseArgv(argv) {
+    | Ok(opts) => {
+        expect(opts.subcommand == Watch)->toEqual(true)
+        expect(opts.roots)->toEqual(["."])
+      }
+    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
+    }
+  })
+
+  testPromise("platform backend defaults to memory; --backend overrides", async () => {
+    switch Cli.parseArgv(["/bin/node", "/path/to/bin", "platform", "--format=vscode"]) {
+    | Ok(opts) => {
+        expect(opts.subcommand == Platform)->toEqual(true)
+        expect(opts.backend)->toEqual("memory")
+      }
+    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
+    }
+    switch Cli.parseArgv(["/bin/node", "/path/to/bin", "platform", "--backend=sqlite:./db?reset"]) {
+    | Ok(opts) => expect(opts.backend)->toEqual("sqlite:./db?reset")
+    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
+    }
+  })
+
+  testPromise("platform --ui-ports defaults false; flag sets it true", async () => {
+    switch Cli.parseArgv(["/bin/node", "/path/to/bin", "platform", "--format=vscode"]) {
+    | Ok(opts) => expect(opts.uiPorts)->toEqual(false)
+    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
+    }
+    switch Cli.parseArgv(["/bin/node", "/path/to/bin", "platform", "--ui-ports"]) {
+    | Ok(opts) => {
+        expect(opts.subcommand == Platform)->toEqual(true)
+        expect(opts.uiPorts)->toEqual(true)
+      }
+    | Error(msg) => JsError.throwWithMessage("expected Ok, got: " ++ msg)
+    }
+  })
+})

package/tests/RunnerUnitTest.res.mjs

@@ -0,0 +1,244 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Cli$ReventlessGwt from "../src/Cli.res.mjs";
+import * as Diff$ReventlessGwt from "../src/Diff.res.mjs";
+import * as FormatterJson$ReventlessGwt from "../src/FormatterJson.res.mjs";
+import * as RenderRescript$ReventlessGwt from "../src/RenderRescript.res.mjs";
+
+function encodeString(s) {
+  return s;
+}
+
+function makeTaggedEvent(tag, payload) {
+  let d = {};
+  d["TAG"] = tag;
+  d["_0"] = payload;
+  return d;
+}
+
+globalThis.describe("RenderRescript", () => {
+  globalThis.test("renders tagged variants with BuckleScript representation", async () => {
+    let payload = {};
+    payload["name"] = "Electronics";
+    let ev = makeTaggedEvent("CategoryAdded", payload);
+    let rendered = RenderRescript$ReventlessGwt.render(undefined, ev);
+    globalThis.expect(rendered).toEqual(`CategoryAdded({name: "Electronics"})`);
+  });
+  globalThis.test("renders payload-less variants as bare strings", async () => {
+    globalThis.expect(RenderRescript$ReventlessGwt.render(undefined, "CategoryArchived")).toEqual(`"CategoryArchived"`);
+  });
+  globalThis.test("renders plain records in field order", async () => {
+    let d = {};
+    d["id"] = "c1";
+    d["count"] = 3;
+    let rendered = RenderRescript$ReventlessGwt.render(undefined, d);
+    globalThis.expect(rendered).toEqual(`{id: "c1", count: 3}`);
+  });
+  globalThis.test("renderMany splits large arrays across lines", async () => {
+    let a = makeTaggedEvent("A", {});
+    let b = makeTaggedEvent("B", {});
+    let rendered = RenderRescript$ReventlessGwt.renderMany([
+      a,
+      b
+    ]);
+    globalThis.expect(rendered.includes("A({})")).toEqual(true);
+    globalThis.expect(rendered.includes("B({})")).toEqual(true);
+  });
+  globalThis.test("renders inline-record variants with their flattened payload", async () => {
+    let d = {};
+    d["TAG"] = "ProductsNotAvailable";
+    d["missing"] = ["p1x"];
+    let rendered = RenderRescript$ReventlessGwt.render(undefined, d);
+    globalThis.expect(rendered).toEqual(`ProductsNotAvailable({missing: ["p1x"]})`);
+  });
+  globalThis.test("renders multi-field inline-record variants", async () => {
+    let d = {};
+    d["TAG"] = "Conflict";
+    d["expected"] = 1;
+    d["got"] = 2;
+    let rendered = RenderRescript$ReventlessGwt.render(undefined, d);
+    globalThis.expect(rendered).toEqual(`Conflict({expected: 1, got: 2})`);
+  });
+});
+
+globalThis.describe("Diff", () => {
+  globalThis.test("emits one entry per differing leaf", async () => {
+    let d1 = {};
+    d1["name"] = "A";
+    d1["count"] = 1;
+    let d2 = {};
+    d2["name"] = "B";
+    d2["count"] = 1;
+    let diff = Diff$ReventlessGwt.diff(d1, d2);
+    globalThis.expect(diff.length).toEqual(1);
+    let first = diff[0];
+    globalThis.expect(first.path).toEqual("name");
+  });
+  globalThis.test("emits zero entries when values are identical", async () => {
+    let d = {};
+    d["a"] = 1;
+    let d2 = {};
+    d2["a"] = 1;
+    globalThis.expect(Diff$ReventlessGwt.diff(d, d2).length).toEqual(0);
+  });
+});
+
+globalThis.describe("FormatterJson.mismatchJson", () => {
+  globalThis.test("ErrorMismatch carries dual-rendered expected + actualEvents", async () => {
+    let p = {};
+    p["categoryId"] = "c1";
+    p["name"] = "X";
+    let actualEvent = makeTaggedEvent("CategoryAdded", p);
+    let m_2 = [actualEvent];
+    let m = {
+      TAG: "ErrorMismatch",
+      expected: "CategoryAlreadyExists",
+      actual: undefined,
+      actualEvents: m_2
+    };
+    let j = FormatterJson$ReventlessGwt.mismatchJson(m, "AddCategory");
+    let str = JSON.stringify(j);
+    globalThis.expect(str.includes(`"kind":"ErrorMismatch"`)).toEqual(true);
+    globalThis.expect(str.includes(`"type":"CategoryAlreadyExists"`)).toEqual(true);
+    globalThis.expect(str.includes(`CategoryAdded({categoryId: \\\"c1\\\", name: \\\"X\\\"})`)).toEqual(true);
+    globalThis.expect(str.includes(`"locus":"AddCategory.decide"`)).toEqual(true);
+  });
+  globalThis.test("EventsMismatch includes a fieldDiff derived from payloads", async () => {
+    let p = {};
+    p["name"] = "Electronics";
+    let expected = [makeTaggedEvent("Added", p)];
+    let p$1 = {};
+    p$1["name"] = "Books";
+    let actual = [makeTaggedEvent("Added", p$1)];
+    let m = {
+      TAG: "EventsMismatch",
+      expected: expected,
+      actual: actual
+    };
+    let j = FormatterJson$ReventlessGwt.mismatchJson(m, undefined);
+    let str = JSON.stringify(j);
+    globalThis.expect(str.includes(`"fieldDiff"`)).toEqual(true);
+    globalThis.expect(str.includes(`"path":"0._0.name"`)).toEqual(true);
+  });
+});
+
+globalThis.describe("Cli.parseArgv", () => {
+  globalThis.test("parses run subcommand with --format=json --filter=Foo", async () => {
+    let argv = [
+      "/bin/node",
+      "/path/to/bin",
+      "run",
+      "--format=json",
+      "--filter=Foo",
+      "tests/"
+    ];
+    let opts = Cli$ReventlessGwt.parseArgv(argv);
+    if (opts.TAG !== "Ok") {
+      return Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts._0);
+    }
+    let opts$1 = opts._0;
+    globalThis.expect(opts$1.subcommand === "Run").toEqual(true);
+    globalThis.expect(opts$1.format === "Json").toEqual(true);
+    globalThis.expect(opts$1.filters).toEqual(["Foo"]);
+    globalThis.expect(opts$1.roots).toEqual(["tests/"]);
+  });
+  globalThis.test("discover subcommand defaults to vscode format", async () => {
+    let argv = [
+      "/bin/node",
+      "/path/to/bin",
+      "discover"
+    ];
+    let opts = Cli$ReventlessGwt.parseArgv(argv);
+    if (opts.TAG !== "Ok") {
+      return Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts._0);
+    }
+    let opts$1 = opts._0;
+    globalThis.expect(opts$1.subcommand === "Discover").toEqual(true);
+    globalThis.expect(opts$1.format === "VsCode").toEqual(true);
+  });
+  globalThis.test("unknown flag reports an error", async () => {
+    let argv = [
+      "/bin/node",
+      "/path/to/bin",
+      "run",
+      "--nonsense"
+    ];
+    let msg = Cli$ReventlessGwt.parseArgv(argv);
+    if (msg.TAG === "Ok") {
+      return Stdlib_JsError.throwWithMessage("expected Error");
+    }
+    globalThis.expect(msg._0.includes("Unknown flag")).toEqual(true);
+  });
+  globalThis.test("no path argument defaults to the cwd subtree (auto-discovery)", async () => {
+    let argv = [
+      "/bin/node",
+      "/path/to/bin",
+      "watch",
+      "--format=vscode"
+    ];
+    let opts = Cli$ReventlessGwt.parseArgv(argv);
+    if (opts.TAG !== "Ok") {
+      return Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts._0);
+    }
+    let opts$1 = opts._0;
+    globalThis.expect(opts$1.subcommand === "Watch").toEqual(true);
+    globalThis.expect(opts$1.roots).toEqual(["."]);
+  });
+  globalThis.test("platform backend defaults to memory; --backend overrides", async () => {
+    let opts = Cli$ReventlessGwt.parseArgv([
+      "/bin/node",
+      "/path/to/bin",
+      "platform",
+      "--format=vscode"
+    ]);
+    if (opts.TAG === "Ok") {
+      let opts$1 = opts._0;
+      globalThis.expect(opts$1.subcommand === "Platform").toEqual(true);
+      globalThis.expect(opts$1.backend).toEqual("memory");
+    } else {
+      Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts._0);
+    }
+    let opts$2 = Cli$ReventlessGwt.parseArgv([
+      "/bin/node",
+      "/path/to/bin",
+      "platform",
+      "--backend=sqlite:./db?reset"
+    ]);
+    if (opts$2.TAG !== "Ok") {
+      return Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts$2._0);
+    }
+    globalThis.expect(opts$2._0.backend).toEqual("sqlite:./db?reset");
+  });
+  globalThis.test("platform --ui-ports defaults false; flag sets it true", async () => {
+    let opts = Cli$ReventlessGwt.parseArgv([
+      "/bin/node",
+      "/path/to/bin",
+      "platform",
+      "--format=vscode"
+    ]);
+    if (opts.TAG === "Ok") {
+      globalThis.expect(opts._0.uiPorts).toEqual(false);
+    } else {
+      Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts._0);
+    }
+    let opts$1 = Cli$ReventlessGwt.parseArgv([
+      "/bin/node",
+      "/path/to/bin",
+      "platform",
+      "--ui-ports"
+    ]);
+    if (opts$1.TAG !== "Ok") {
+      return Stdlib_JsError.throwWithMessage("expected Ok, got: " + opts$1._0);
+    }
+    let opts$2 = opts$1._0;
+    globalThis.expect(opts$2.subcommand === "Platform").toEqual(true);
+    globalThis.expect(opts$2.uiPorts).toEqual(true);
+  });
+});
+
+export {
+  encodeString,
+  makeTaggedEvent,
+}
+/*  Not a pure module */

package/tests/SideEffect/FakeOrderNotification.res

@@ -0,0 +1,23 @@
+// Fixture: a minimal `SideEffect.T` that calls `MockEmail` on `Placed`.
+// Mirrors the aggregate example pattern (`Order_EmailNotification` calling
+// `EmailService.sendOrderConfirmation`) but in-package so the framework's own
+// test suite can exercise it without depending on the example plugin.
+
+module Source = {
+  let name = "FakeOrder"
+  module Id = Reventless.Id.String
+
+  @schema
+  type event =
+    | Placed({email: string})
+    | Shipped
+}
+
+let moduleUrl = "test://FakeOrderNotification"
+
+let execute = async (id, _meta, event, _queryEngine) =>
+  switch event {
+  | Source.Placed({email}) =>
+    MockEmail.recordSend(~email, ~orderId=Source.Id.toString(id))
+  | Source.Shipped => ()
+  }

package/tests/SideEffect/FakeOrderNotification.res.mjs

@@ -0,0 +1,36 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as MockEmail$ReventlessGwt from "./MockEmail.res.mjs";
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "Placed",
+    email: s.m(S.string)
+  })),
+  S.literal("Shipped")
+]);
+
+let Source = {
+  name: "FakeOrder",
+  Id: undefined,
+  eventSchema: eventSchema
+};
+
+async function execute(id, _meta, event, _queryEngine) {
+  if (typeof event !== "object") {
+    return;
+  } else {
+    return MockEmail$ReventlessGwt.recordSend(event.email, Id$Reventless.$$String.toString(id));
+  }
+}
+
+let moduleUrl = "test://FakeOrderNotification";
+
+export {
+  Source,
+  moduleUrl,
+  execute,
+}
+/* eventSchema Not a pure module */

package/tests/SideEffect/FakeOrderNotificationGwtTest.res

@@ -0,0 +1,35 @@
+// Smoke test for SideEffect_GWT. Folder `SideEffect/` triggers the PPX kind
+// inference; filename `FakeOrderNotification_GWT.res` resolves the SE under
+// test to the sibling `FakeOrderNotification.res` (a `SideEffect.T`).
+
+@@reventless.gwt
+
+describe("FakeOrderNotification SideEffect", () => {
+  JestGlobals.beforeEach(MockEmail.reset)
+
+  test("Placed records a confirmation send", () =>
+    givenEventForId(
+      Source.Id.makeFromString("o1"),
+      Source.Placed({email: "alice@example.com"}),
+    )
+    ->whenExecuted(MockEmail.mock)
+    ->thenExternalCalls([
+      MockEmail.SendConfirmation({email: "alice@example.com", orderId: "o1"}),
+    ])
+  )
+
+  test("Shipped is a no-op", () =>
+    givenEvent(Source.Shipped)
+    ->whenExecuted(MockEmail.mock)
+    ->thenNoExternalCalls
+  )
+
+  test("Two distinct Placed events record two calls", async () => {
+    let _ =
+      await givenEventForId(Source.Id.makeFromString("o1"), Source.Placed({email: "a@a"}))
+      ->whenExecuted(MockEmail.mock)
+    await givenEventForId(Source.Id.makeFromString("o2"), Source.Placed({email: "b@b"}))
+    ->whenExecuted(MockEmail.mock)
+    ->thenExternalCallCount(2)
+  })
+})

package/tests/SideEffect/FakeOrderNotificationGwtTest.res.mjs

@@ -0,0 +1,73 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as MockEmail$ReventlessGwt from "./MockEmail.res.mjs";
+import * as SideEffect_GWT$ReventlessGwt from "../../src/SideEffect_GWT.res.mjs";
+import * as FakeOrderNotification$ReventlessGwt from "./FakeOrderNotification.res.mjs";
+
+let include = SideEffect_GWT$ReventlessGwt.Make({
+  Source: {
+    name: FakeOrderNotification$ReventlessGwt.Source.name,
+    Id: Id$Reventless.$$String,
+    eventSchema: FakeOrderNotification$ReventlessGwt.Source.eventSchema
+  },
+  moduleUrl: FakeOrderNotification$ReventlessGwt.moduleUrl,
+  execute: FakeOrderNotification$ReventlessGwt.execute
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvent = include.givenEvent;
+
+let givenEventForId = include.givenEventForId;
+
+let whenExecuted = include.whenExecuted;
+
+let thenNoExternalCalls = include.thenNoExternalCalls;
+
+let thenExternalCalls = include.thenExternalCalls;
+
+let thenExternalCallCount = include.thenExternalCallCount;
+
+describe("FakeOrderNotification SideEffect", () => {
+  globalThis.beforeEach(MockEmail$ReventlessGwt.reset);
+  test("Placed records a confirmation send", undefined, () => thenExternalCalls(whenExecuted(givenEventForId(Id$Reventless.$$String.makeFromString("o1"), {
+    TAG: "Placed",
+    email: "alice@example.com"
+  }), MockEmail$ReventlessGwt.mock, undefined), [{
+      TAG: "SendConfirmation",
+      email: "alice@example.com",
+      orderId: "o1"
+    }]));
+  test("Shipped is a no-op", undefined, () => thenNoExternalCalls(whenExecuted(givenEvent("Shipped"), MockEmail$ReventlessGwt.mock, undefined)));
+  test("Two distinct Placed events record two calls", undefined, async () => {
+    await whenExecuted(givenEventForId(Id$Reventless.$$String.makeFromString("o1"), {
+      TAG: "Placed",
+      email: "a@a"
+    }), MockEmail$ReventlessGwt.mock, undefined);
+    return await thenExternalCallCount(whenExecuted(givenEventForId(Id$Reventless.$$String.makeFromString("o2"), {
+      TAG: "Placed",
+      email: "b@b"
+    }), MockEmail$ReventlessGwt.mock, undefined), 2);
+  });
+});
+
+let SE = include.SE;
+
+let givenMeta = include.givenMeta;
+
+export {
+  SE,
+  describe,
+  test,
+  givenEvent,
+  givenEventForId,
+  givenMeta,
+  whenExecuted,
+  thenNoExternalCalls,
+  thenExternalCalls,
+  thenExternalCallCount,
+}
+/* include Not a pure module */

package/tests/SideEffect/MockEmail.res

@@ -0,0 +1,18 @@
+// Fixture: a mock email service that records every call into a ref. The
+// SideEffect_GWT test reads the recorded calls back via `mock.snapshot()`
+// and asserts against them.
+
+@schema
+type call = SendConfirmation({email: string, orderId: string})
+
+let calls: ref<array<call>> = ref([])
+
+let reset = () => calls := []
+
+let recordSend = (~email, ~orderId) =>
+  calls := calls.contents->Array.concat([SendConfirmation({email, orderId})])
+
+let mock: SideEffect_GWT.mock<call> = {
+  snapshot: () => calls.contents,
+  encode: c => c->S.reverseConvertToJsonOrThrow(callSchema),
+}