@reventlessdev/reventless-core 3.0.0-alpha.213 → 3.0.0-alpha.215

package/tests/adapter/EventLogProvisioningTest.res

@@ -0,0 +1,207 @@
+open JestGlobals
+
+// The registry only forwards `~resources` and `~opts`; it never reads their
+// fields. A structural stand-in keeps @pulumi/pulumi (whose Output.make would
+// build a real resource) out of the Jest run — its ESM entry can't be imported
+// under Jest. Same reason as MonitoringTest's stub.
+let stubResource: ReventlessInfra.Adapter.resource = %raw(`{}`)
+let noOpts: Pulumi.CustomResourceOptions.t = {}
+
+let classicOwner: ResourceAttribution.owner = {kind: ComponentType.Aggregate, name: "Product"}
+let dcbOwner: ResourceAttribution.owner = {kind: ComponentType.Plugin, name: "Catalog"}
+
+describe("EventLogProvisioning", () => {
+  testSync("Noop default: notify is silent and does not throw", () => {
+    // No backend registered — the default Noop backend swallows the call.
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+    expect(true)->toBe(true)
+  })
+
+  testSync("use registers a backend that receives every notify, style and name", () => {
+    let recorded: array<(EventLogProvisioning.logStyle, string)> = []
+    module Recorder: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle,
+        ~name,
+        ~owner as _,
+        ~plugin as _,
+        ~platform as _,
+        ~resources as _,
+        ~opts as _,
+      ) => recorded->Array.push((logStyle, name))
+    }
+    EventLogProvisioning.use(module(Recorder: EventLogProvisioning.Backend))
+
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+    EventLogProvisioning.notify(
+      ~logStyle=Dcb,
+      ~name="CatalogDcbEventLog",
+      ~owner=Some(dcbOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    expect(recorded)->toEqual([
+      (EventLogProvisioning.Classic, "ProductEventLog"),
+      (EventLogProvisioning.Dcb, "CatalogDcbEventLog"),
+    ])
+
+    // Restore the default so registry state doesn't leak to other cases.
+    EventLogProvisioning.reset()
+  })
+
+  testSync("notify forwards the owner and the adapter's resources unchanged", () => {
+    let seen: ref<
+      option<(option<ResourceAttribution.owner>, array<ReventlessInfra.Adapter.resource>)>,
+    > = ref(None)
+    module Capture: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle as _,
+        ~name as _,
+        ~owner,
+        ~plugin as _,
+        ~platform as _,
+        ~resources,
+        ~opts as _,
+      ) => seen := Some((owner, resources))
+    }
+    EventLogProvisioning.use(module(Capture: EventLogProvisioning.Backend))
+
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[stubResource],
+      ~opts=noOpts,
+    )
+    switch seen.contents {
+    | Some((owner, resources)) =>
+      expect(owner)->toEqual(Some(classicOwner))
+      expect(resources)->toHaveLength(1)
+    | None => expect("no notify received")->toBe("a notify")
+    }
+
+    EventLogProvisioning.reset()
+  })
+
+  testSync("a Postgres-style log with no resources still fires — the contract is uniform", () => {
+    // Postgres and in-memory adapters return `resources: []`. Backends that only
+    // implement a DynamoDB arm ignore those; the seam does not filter for them.
+    let styles: array<EventLogProvisioning.logStyle> = []
+    module Recorder: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle,
+        ~name as _,
+        ~owner as _,
+        ~plugin as _,
+        ~platform as _,
+        ~resources,
+        ~opts as _,
+      ) =>
+        if resources->Array.length == 0 {
+          styles->Array.push(logStyle)
+        }
+    }
+    EventLogProvisioning.use(module(Recorder: EventLogProvisioning.Backend))
+
+    EventLogProvisioning.notify(
+      ~logStyle=Dcb,
+      ~name="CatalogDcbEventLog",
+      ~owner=Some(dcbOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    expect(styles)->toEqual([EventLogProvisioning.Dcb])
+    EventLogProvisioning.reset()
+  })
+
+  testSync("notify delivers the ambient plugin/platform inside a construct scope, None outside", () => {
+    let seen: array<(option<string>, option<string>)> = []
+    module OwnerCapture: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle as _,
+        ~name as _,
+        ~owner as _,
+        ~plugin,
+        ~platform,
+        ~resources as _,
+        ~opts as _,
+      ) => seen->Array.push((plugin, platform))
+    }
+    EventLogProvisioning.use(module(OwnerCapture: EventLogProvisioning.Backend))
+
+    // Outside any plugin construct: both None.
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    // Inside a construct scope (what Plugin_Builder.construct establishes): both delivered.
+    let prev = ResourceAttribution.enter(~platform="online-shop", ~plugin="Catalog")
+    EventLogProvisioning.notify(
+      ~logStyle=Dcb,
+      ~name="CatalogDcbEventLog",
+      ~owner=Some(dcbOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+    ResourceAttribution.restore(prev)
+
+    // After restore: back to None.
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="OrderEventLog",
+      ~owner=None,
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    expect(seen)->toEqual([(None, None), (Some("Catalog"), Some("online-shop")), (None, None)])
+
+    EventLogProvisioning.reset()
+  })
+
+  testSync("use is single-slot: a second registration throws rather than silently winning", () => {
+    module First: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle as _,
+        ~name as _,
+        ~owner as _,
+        ~plugin as _,
+        ~platform as _,
+        ~resources as _,
+        ~opts as _,
+      ) => ()
+    }
+    EventLogProvisioning.use(module(First: EventLogProvisioning.Backend))
+
+    let threw = try {
+      EventLogProvisioning.use(module(First: EventLogProvisioning.Backend))
+      false
+    } catch {
+    | _ => true
+    }
+    expect(threw)->toBe(true)
+
+    // reset clears the slot, so a later registration succeeds again.
+    EventLogProvisioning.reset()
+    EventLogProvisioning.use(module(First: EventLogProvisioning.Backend))
+    EventLogProvisioning.reset()
+  })
+})

package/tests/adapter/EventLogProvisioningTest.res.mjs

@@ -0,0 +1,150 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ResourceAttribution$ReventlessCore from "../../src/ResourceAttribution.res.mjs";
+import * as EventLogProvisioning$ReventlessCore from "../../src/adapter/EventLogProvisioning/EventLogProvisioning.res.mjs";
+
+let stubResource = {};
+
+let noOpts = {};
+
+let classicOwner = {
+  kind: "Aggregate",
+  name: "Product"
+};
+
+let dcbOwner = {
+  kind: "Plugin",
+  name: "Catalog"
+};
+
+globalThis.describe("EventLogProvisioning", () => {
+  globalThis.test("Noop default: notify is silent and does not throw", () => {
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [], noOpts);
+    globalThis.expect(true).toBe(true);
+  });
+  globalThis.test("use registers a backend that receives every notify, style and name", () => {
+    let recorded = [];
+    let onProvisioned = (logStyle, name, param, param$1, param$2, param$3, param$4) => {
+      recorded.push([
+        logStyle,
+        name
+      ]);
+    };
+    let Recorder = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(Recorder);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [], noOpts);
+    EventLogProvisioning$ReventlessCore.notify("Dcb", "CatalogDcbEventLog", dcbOwner, [], noOpts);
+    globalThis.expect(recorded).toEqual([
+      [
+        "Classic",
+        "ProductEventLog"
+      ],
+      [
+        "Dcb",
+        "CatalogDcbEventLog"
+      ]
+    ]);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("notify forwards the owner and the adapter's resources unchanged", () => {
+    let seen = {
+      contents: undefined
+    };
+    let onProvisioned = (param, param$1, owner, param$2, param$3, resources, param$4) => {
+      seen.contents = [
+        owner,
+        resources
+      ];
+    };
+    let Capture = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(Capture);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [stubResource], noOpts);
+    let match = seen.contents;
+    if (match !== undefined) {
+      globalThis.expect(match[0]).toEqual(classicOwner);
+      globalThis.expect(match[1]).toHaveLength(1);
+    } else {
+      globalThis.expect("no notify received").toBe("a notify");
+    }
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("a Postgres-style log with no resources still fires — the contract is uniform", () => {
+    let styles = [];
+    let onProvisioned = (logStyle, param, param$1, param$2, param$3, resources, param$4) => {
+      if (resources.length === 0) {
+        styles.push(logStyle);
+        return;
+      }
+    };
+    let Recorder = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(Recorder);
+    EventLogProvisioning$ReventlessCore.notify("Dcb", "CatalogDcbEventLog", dcbOwner, [], noOpts);
+    globalThis.expect(styles).toEqual(["Dcb"]);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("notify delivers the ambient plugin/platform inside a construct scope, None outside", () => {
+    let seen = [];
+    let onProvisioned = (param, param$1, param$2, plugin, platform, param$3, param$4) => {
+      seen.push([
+        plugin,
+        platform
+      ]);
+    };
+    let OwnerCapture = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(OwnerCapture);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [], noOpts);
+    let prev = ResourceAttribution$ReventlessCore.enter("online-shop", "Catalog");
+    EventLogProvisioning$ReventlessCore.notify("Dcb", "CatalogDcbEventLog", dcbOwner, [], noOpts);
+    ResourceAttribution$ReventlessCore.restore(prev);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "OrderEventLog", undefined, [], noOpts);
+    globalThis.expect(seen).toEqual([
+      [
+        undefined,
+        undefined
+      ],
+      [
+        "Catalog",
+        "online-shop"
+      ],
+      [
+        undefined,
+        undefined
+      ]
+    ]);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("use is single-slot: a second registration throws rather than silently winning", () => {
+    let onProvisioned = (param, param$1, param$2, param$3, param$4, param$5, param$6) => {};
+    let First = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(First);
+    let threw;
+    try {
+      EventLogProvisioning$ReventlessCore.use(First);
+      threw = false;
+    } catch (exn) {
+      threw = true;
+    }
+    globalThis.expect(threw).toBe(true);
+    EventLogProvisioning$ReventlessCore.reset();
+    EventLogProvisioning$ReventlessCore.use(First);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+});
+
+export {
+  stubResource,
+  noOpts,
+  classicOwner,
+  dcbOwner,
+}
+/*  Not a pure module */

package/tests/adapter/RuntimeExtensionHookReachTest.res

@@ -0,0 +1,84 @@
+open JestGlobals
+
+S.enableJson()
+
+// The point of the seam, end to end at the hook level: an extension that only
+// ever gets `onColdStart` can reach the framework's runtime callback hooks from
+// there, and they take effect on the requests that follow.
+//
+// `CommandGenerator_Callback.registerCommandInterceptor` stands in for all four
+// registrars — they share the shape (a module-level ref consulted on the hot
+// path), so what makes one reachable makes the others reachable too. What is
+// being proved is the ordering: registration happens inside the cold-start hook,
+// the command runs after it, and the interceptor is consulted.
+
+@schema
+type command = Add({@partitionTag productId: string, name: string})
+
+let published: ref<array<Message.commandJson>> = ref([])
+let publishJsons: CommandGenerator.publishJsons = async cmds =>
+  published := published.contents->Array.concat(cmds)
+
+let generateCommand = CommandGenerator_Callback.makeGenerateCommand(
+  ~publishJsons,
+  ~serviceName="Product",
+  ~commandSchema=commandSchema->S.castToUnknown,
+  ~componentKind=CommandGenerator_Callback.StateChangeSlice,
+  ~stripIdFromParams=false,
+)
+
+let addChair = (): CommandGenerator.payload =>
+  Obj.magic({
+    "command": "Add",
+    "arguments": {"productId": "p1", "name": "Chair"},
+    "meta": {"ip": ["127.0.0.1"], "user": "test-user", "info": ""},
+  })
+
+let runAdd = async () => await generateCommand(addChair())->Effect.runPromise
+
+describe("RuntimeExtension reaches the runtime callback hooks", () => {
+  beforeEach(() => {
+    RuntimeExtension.reset()
+    CommandGenerator_Callback.clearCommandInterceptor()
+    published := []
+  })
+
+  testPromise("an interceptor registered at cold start denies a later command", async () => {
+    let seenAtColdStart: array<string> = []
+    module Gatekeeper: RuntimeExtension.Extension = {
+      let moduleUrl = "file:///pkg/gatekeeper.res.mjs"
+      let onColdStart = (~runtimeKind as _, ~component, ~plugin as _, ~platform as _) => {
+        seenAtColdStart->Array.push(component)
+        CommandGenerator_Callback.registerCommandInterceptor(async (
+          ~identity as _,
+          ~componentName,
+          ~componentKind as _,
+          ~tag,
+          ~args as _,
+        ) => CommandGenerator_Callback.Deny(`${componentName}.${tag} refused`))
+      }
+    }
+    RuntimeExtension.use(module(Gatekeeper: RuntimeExtension.Extension))
+
+    RuntimeExtension.notifyColdStart(
+      ~runtimeKind=ComponentType.StateChangeSlice,
+      ~component="CatalogStateChanges",
+      ~plugin=Some("Catalog"),
+      ~platform=Some("Shop"),
+    )
+    expect(seenAtColdStart)->toEqual(["CatalogStateChanges"])
+
+    let denied = switch await runAdd() {
+    | _ => None
+    | exception exn => exn->JsExn.fromException->Option.flatMap(JsExn.message)
+    }
+
+    expect(denied)->toEqual(Some("Product.Add refused"))
+    expect(published.contents->Array.length)->toBe(0)
+  })
+
+  testPromise("with nothing registered the same command publishes untouched", async () => {
+    let _ = await runAdd()
+    expect(published.contents->Array.length)->toBe(1)
+  })
+})

package/tests/adapter/RuntimeExtensionHookReachTest.res.mjs

@@ -0,0 +1,95 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as RuntimeExtension$ReventlessCore from "../../src/adapter/RuntimeExtension/RuntimeExtension.res.mjs";
+import * as CommandGenerator_Callback$ReventlessCore from "../../src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
+
+S.enableJson();
+
+let commandSchema = S.schema(s => ({
+  TAG: "Add",
+  productId: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+let published = {
+  contents: []
+};
+
+async function publishJsons(cmds) {
+  published.contents = published.contents.concat(cmds);
+}
+
+let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "Product", commandSchema, "StateChangeSlice", false);
+
+function addChair() {
+  return {
+    command: "Add",
+    arguments: {
+      productId: "p1",
+      name: "Chair"
+    },
+    meta: {
+      ip: ["127.0.0.1"],
+      user: "test-user",
+      info: ""
+    }
+  };
+}
+
+async function runAdd() {
+  return await Effect.runPromise(generateCommand(addChair()));
+}
+
+globalThis.describe("RuntimeExtension reaches the runtime callback hooks", () => {
+  globalThis.beforeEach(() => {
+    RuntimeExtension$ReventlessCore.reset();
+    CommandGenerator_Callback$ReventlessCore.clearCommandInterceptor();
+    published.contents = [];
+  });
+  globalThis.test("an interceptor registered at cold start denies a later command", async () => {
+    let seenAtColdStart = [];
+    let onColdStart = (param, component, param$1, param$2) => {
+      seenAtColdStart.push(component);
+      CommandGenerator_Callback$ReventlessCore.registerCommandInterceptor(async (param, componentName, param$1, tag, param$2) => ({
+        TAG: "Deny",
+        _0: componentName + `.` + tag + ` refused`
+      }));
+    };
+    let Gatekeeper = {
+      moduleUrl: "file:///pkg/gatekeeper.res.mjs",
+      onColdStart: onColdStart
+    };
+    RuntimeExtension$ReventlessCore.use(Gatekeeper);
+    RuntimeExtension$ReventlessCore.notifyColdStart("StateChangeSlice", "CatalogStateChanges", "Catalog", "Shop");
+    globalThis.expect(seenAtColdStart).toEqual(["CatalogStateChanges"]);
+    let denied;
+    try {
+      await runAdd();
+      denied = undefined;
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      denied = Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message);
+    }
+    globalThis.expect(denied).toEqual("Product.Add refused");
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+  globalThis.test("with nothing registered the same command publishes untouched", async () => {
+    await runAdd();
+    globalThis.expect(published.contents.length).toBe(1);
+  });
+});
+
+export {
+  commandSchema,
+  published,
+  publishJsons,
+  generateCommand,
+  addChair,
+  runAdd,
+}
+/*  Not a pure module */

package/tests/adapter/RuntimeExtensionTest.res

@@ -0,0 +1,127 @@
+open JestGlobals
+
+type call = {
+  runtimeKind: ComponentType.t,
+  component: string,
+  plugin: option<string>,
+  platform: option<string>,
+}
+
+let recorderNamed = (label: string, into: array<(string, call)>): module(
+  RuntimeExtension.Extension
+) => {
+  module R = {
+    let moduleUrl = `file:///pkg/${label}.res.mjs`
+    let onColdStart = (~runtimeKind, ~component, ~plugin, ~platform) =>
+      into->Array.push((label, {runtimeKind, component, plugin, platform}))
+  }
+  module(R: RuntimeExtension.Extension)
+}
+
+let fireAggregate = () =>
+  RuntimeExtension.notifyColdStart(
+    ~runtimeKind=ComponentType.Aggregate,
+    ~component="AllAggregatesCmdHandler",
+    ~plugin=Some("Catalog"),
+    ~platform=Some("Shop"),
+  )
+
+describe("RuntimeExtension", () => {
+  beforeEach(() => RuntimeExtension.reset())
+
+  testSync("empty registry is the default and notifyColdStart is silent", () => {
+    expect(RuntimeExtension.isEmpty())->toBe(true)
+    expect(RuntimeExtension.moduleUrls())->toEqual([])
+    fireAggregate()
+    expect(true)->toBe(true)
+  })
+
+  testSync("a registered extension receives the runtime's full identity", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+
+    fireAggregate()
+
+    expect(calls)->toEqual([
+      (
+        "tracing",
+        {
+          runtimeKind: ComponentType.Aggregate,
+          component: "AllAggregatesCmdHandler",
+          plugin: Some("Catalog"),
+          platform: Some("Shop"),
+        },
+      ),
+    ])
+  })
+
+  testSync("several extensions compose, in registration order", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+    RuntimeExtension.use(recorderNamed("accounting", calls))
+
+    fireAggregate()
+
+    expect(calls->Array.map(((label, _)) => label))->toEqual(["tracing", "accounting"])
+  })
+
+  testSync("moduleUrls reports every registration, in order", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+    RuntimeExtension.use(recorderNamed("accounting", calls))
+
+    expect(RuntimeExtension.isEmpty())->toBe(false)
+    expect(RuntimeExtension.moduleUrls())->toEqual([
+      "file:///pkg/tracing.res.mjs",
+      "file:///pkg/accounting.res.mjs",
+    ])
+  })
+
+  testSync("a throwing extension is skipped; the runtime and its siblings survive", () => {
+    let calls: array<(string, call)> = []
+    module Broken: RuntimeExtension.Extension = {
+      let moduleUrl = "file:///pkg/broken.res.mjs"
+      let onColdStart = (~runtimeKind as _, ~component as _, ~plugin as _, ~platform as _) =>
+        JsError.throwWithMessage("extension blew up")
+    }
+    RuntimeExtension.use(module(Broken: RuntimeExtension.Extension))
+    RuntimeExtension.use(recorderNamed("accounting", calls))
+
+    // Fails the test if the seam propagates: the acceptance criterion is that a
+    // broken extension does not take the runtime down.
+    fireAggregate()
+
+    expect(calls->Array.map(((label, _)) => label))->toEqual(["accounting"])
+  })
+
+  testSync("notifyColdStartHooks fires loose hooks — the deployed runtime's path", () => {
+    // A deployed entry point holds hooks lifted off dynamically imported
+    // modules, not first-class modules, so it never populates this process's
+    // registry. Same isolation and ordering apply.
+    let seen: array<string> = []
+    let hook = (label): RuntimeExtension.coldStartHook =>
+      (~runtimeKind as _, ~component, ~plugin as _, ~platform as _) =>
+        seen->Array.push(`${label}:${component}`)
+
+    RuntimeExtension.notifyColdStartHooks(
+      ~hooks=[hook("a"), hook("b")],
+      ~runtimeKind=ComponentType.ReadModel,
+      ~component="AllReadModels",
+      ~plugin=None,
+      ~platform=None,
+    )
+
+    expect(seen)->toEqual(["a:AllReadModels", "b:AllReadModels"])
+  })
+
+  testSync("reset clears the registry", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+    RuntimeExtension.reset()
+
+    fireAggregate()
+
+    expect(RuntimeExtension.isEmpty())->toBe(true)
+    expect(calls)->toEqual([])
+  })
+})