@reventlessdev/reventless-local 3.0.0-alpha.152 → 3.0.0-alpha.154

package/tests/adapter/DomainGraphQL_ServerTest.res

@@ -0,0 +1,161 @@
+// Tests for DomainGraphQL_Server's plugin=subgraph scoped registry (Phase 6
+// of the merged-API composition plan). Mirrors the AWS model locally: each
+// plugin scope's registrations form a standalone subgraph document that is
+// validated in isolation and composed with graphql-tools merge semantics at
+// start()/composeSchema().
+
+open JestGlobals
+
+module Server = DomainGraphQL_Server
+
+// Execute a query directly against a composed schema (no HTTP server needed).
+type executionResult = {data: Nullable.t<JSON.t>, errors: Nullable.t<array<JSON.t>>}
+@module("graphql")
+external graphqlExecute: {"schema": GraphqlYoga.schema, "source": string} => promise<executionResult> =
+  "graphql"
+
+let intResolver = (value: int): Server.resolverFn =>
+  async (_root, _args, _ctx) =>
+    JSON.Encode.object(Dict.fromArray([("x", JSON.Encode.int(value))]))
+
+let resolversOf = (entries: array<(string, Server.resolverFn)>) => Dict.fromArray(entries)
+
+let sharedTypeSdl = `type SharedThing {\n  x: Int\n}`
+
+let dataField = (result: executionResult, ~field: string): option<int> =>
+  result.data
+  ->Nullable.toOption
+  ->Option.flatMap(JSON.Decode.object)
+  ->Option.flatMap(d => d->Dict.get(field))
+  ->Option.flatMap(JSON.Decode.object)
+  ->Option.flatMap(d => d->Dict.get("x"))
+  ->Option.flatMap(JSON.Decode.float)
+  ->Option.map(Float.toInt)
+
+let exnMessage = (err: JsExn.t): string => JsExn.message(err)->Option.getOr("")
+
+beforeEach(() => Server.reset())
+afterAll(() => Server.reset())
+
+// ── (a) identical shared-type copies compose; both plugins' fields resolve ──
+
+test("two scopes with identical shared-type copies compose and both fields resolve", async () => {
+  Server.setScope("PluginA")
+  Server.registerTypes(~sdlTypes=[sharedTypeSdl])
+  Server.registerQueries(
+    ~sdlFields=["  aItem: SharedThing"],
+    ~resolvers=resolversOf([("aItem", intResolver(1))]),
+  )
+  Server.setScope("PluginB")
+  Server.registerTypes(~sdlTypes=[sharedTypeSdl])
+  Server.registerQueries(
+    ~sdlFields=["  bItem: SharedThing"],
+    ~resolvers=resolversOf([("bItem", intResolver(2))]),
+  )
+  Server.resetScope()
+
+  // Cross-bucket resolver lookup (MCP_Server path) sees both scopes.
+  expect(Server.getQueryResolver("aItem")->Option.isSome)->toBe(true)
+  expect(Server.getQueryResolver("bItem")->Option.isSome)->toBe(true)
+
+  let schema = Server.composeSchema()
+  let result = await graphqlExecute({"schema": schema, "source": "{ aItem { x } bItem { x } }"})
+  expect(result.errors->Nullable.toOption->Option.isNone)->toBe(true)
+  expect(dataField(result, ~field="aItem"))->toEqual(Some(1))
+  expect(dataField(result, ~field="bItem"))->toEqual(Some(2))
+})
+
+// ── (b) standalone-invalid scope fails with plugin-name attribution ─────────
+
+testSync("scope referencing an undefined type fails standalone validation naming the plugin", () => {
+  // Register under a construction token, then relabel to the plugin name —
+  // exercising the Platform.res flow (name only known after construction).
+  Server.setScope("plugin-token-1")
+  Server.registerQueries(
+    ~sdlFields=["  broken: MissingType"],
+    ~resolvers=resolversOf([("broken", intResolver(0))]),
+  )
+  Server.relabelScope(~from="plugin-token-1", ~to_="BrokenPlugin")
+  Server.resetScope()
+
+  switch Server.composeSchema() {
+  | _ => Runner.fail("expected composeSchema to throw")
+  | exception JsExn(err) => {
+      expect(exnMessage(err))->toContain(
+        `Plugin "BrokenPlugin" subgraph document is not valid standalone`,
+      )
+      expect(exnMessage(err))->toContain("MissingType")
+    }
+  }
+})
+
+// ── (c) conflicting same-named type across scopes fails the merge ────────────
+
+testSync("two scopes defining the same type name with conflicting fields fail composition", () => {
+  Server.setScope("PluginA")
+  Server.registerTypes(~sdlTypes=[`type SharedThing {\n  x: Int\n}`])
+  Server.registerQueries(
+    ~sdlFields=["  aItem: SharedThing"],
+    ~resolvers=resolversOf([("aItem", intResolver(1))]),
+  )
+  Server.setScope("PluginB")
+  Server.registerTypes(~sdlTypes=[`type SharedThing {\n  x: String\n}`])
+  Server.registerQueries(
+    ~sdlFields=["  bItem: SharedThing"],
+    ~resolvers=resolversOf([("bItem", intResolver(2))]),
+  )
+  Server.resetScope()
+
+  switch Server.composeSchema() {
+  | _ => Runner.fail("expected composeSchema to throw")
+  | exception JsExn(err) =>
+    expect(exnMessage(err))->toContain("Cross-plugin schema merge failed (mirrors AWS MERGE_FAILED)")
+  }
+})
+
+// ── (d) reset clears buckets and restores the platform scope ────────────────
+
+testSync("reset clears all scope buckets and restores the platform scope", () => {
+  Server.setScope("PluginA")
+  Server.registerTypes(~sdlTypes=[sharedTypeSdl])
+  Server.registerQueries(
+    ~sdlFields=["  aItem: SharedThing"],
+    ~resolvers=resolversOf([("aItem", intResolver(1))]),
+  )
+
+  Server.reset()
+
+  expect(Server.currentScope.contents)->toBe("platform")
+  expect(Server.getQueryResolver("aItem")->Option.isNone)->toBe(true)
+  let d = Server.diagnostics()
+  expect(d.typeCount)->toBe(0)
+  expect(d.sdlQueryCount)->toBe(0)
+  expect(d.resolverQueryCount)->toBe(0)
+  // Post-reset registrations land in the platform bucket again.
+  Server.registerQueries(
+    ~sdlFields=["  pItem: String"],
+    ~resolvers=resolversOf([("pItem", intResolver(0))]),
+  )
+  expect(Server.buildSdl()->String.includes("pItem"))->toBe(true)
+})
+
+// ── per-scope shared types keep plugin subgraphs standalone-valid ────────────
+
+test("scope missing its own shared-type copy fails standalone even when platform defines it", async () => {
+  // The platform bucket defines SharedThing; the plugin bucket references it
+  // without carrying its own copy — standalone-invalid, mirroring an AWS
+  // source API that leans on another API's types.
+  Server.registerTypes(~sdlTypes=[sharedTypeSdl]) // platform scope
+  Server.setScope("Leaner")
+  Server.registerQueries(
+    ~sdlFields=["  leanItem: SharedThing"],
+    ~resolvers=resolversOf([("leanItem", intResolver(3))]),
+  )
+  Server.resetScope()
+
+  switch Server.composeSchema() {
+  | _ => Runner.fail("expected composeSchema to throw")
+  | exception JsExn(err) =>
+    expect(exnMessage(err))->toContain(`Plugin "Leaner" subgraph document is not valid standalone`)
+  }
+})

package/tests/adapter/DomainGraphQL_ServerTest.res.mjs

@@ -0,0 +1,192 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Graphql from "graphql";
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as DomainGraphQL_Server$ReventlessLocal from "../../src/adapter/DomainGraphQL_Server.res.mjs";
+
+function intResolver(value) {
+  return async (_root, _args, _ctx) => Object.fromEntries([[
+      "x",
+      value
+    ]]);
+}
+
+function resolversOf(entries) {
+  return Object.fromEntries(entries);
+}
+
+let sharedTypeSdl = `type SharedThing {\n  x: Int\n}`;
+
+function dataField(result, field) {
+  return Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Primitive_option.fromNullable(result.data), Stdlib_JSON.Decode.object), d => d[field]), Stdlib_JSON.Decode.object), d => d["x"]), Stdlib_JSON.Decode.float), prim => prim | 0);
+}
+
+function exnMessage(err) {
+  return Stdlib_Option.getOr(Stdlib_JsExn.message(err), "");
+}
+
+globalThis.beforeEach(() => DomainGraphQL_Server$ReventlessLocal.reset());
+
+globalThis.afterAll(() => DomainGraphQL_Server$ReventlessLocal.reset());
+
+globalThis.test("two scopes with identical shared-type copies compose and both fields resolve", async () => {
+  DomainGraphQL_Server$ReventlessLocal.setScope("PluginA");
+  DomainGraphQL_Server$ReventlessLocal.registerTypes([sharedTypeSdl]);
+  DomainGraphQL_Server$ReventlessLocal.registerQueries(["  aItem: SharedThing"], Object.fromEntries([[
+      "aItem",
+      async (_root, _args, _ctx) => Object.fromEntries([[
+          "x",
+          1
+        ]])
+    ]]));
+  DomainGraphQL_Server$ReventlessLocal.setScope("PluginB");
+  DomainGraphQL_Server$ReventlessLocal.registerTypes([sharedTypeSdl]);
+  DomainGraphQL_Server$ReventlessLocal.registerQueries(["  bItem: SharedThing"], Object.fromEntries([[
+      "bItem",
+      async (_root, _args, _ctx) => Object.fromEntries([[
+          "x",
+          2
+        ]])
+    ]]));
+  DomainGraphQL_Server$ReventlessLocal.resetScope();
+  globalThis.expect(Stdlib_Option.isSome(DomainGraphQL_Server$ReventlessLocal.getQueryResolver("aItem"))).toBe(true);
+  globalThis.expect(Stdlib_Option.isSome(DomainGraphQL_Server$ReventlessLocal.getQueryResolver("bItem"))).toBe(true);
+  let schema = DomainGraphQL_Server$ReventlessLocal.composeSchema();
+  let result = await Graphql.graphql({
+    schema: schema,
+    source: "{ aItem { x } bItem { x } }"
+  });
+  globalThis.expect(Stdlib_Option.isNone(Primitive_option.fromNullable(result.errors))).toBe(true);
+  globalThis.expect(dataField(result, "aItem")).toEqual(1);
+  globalThis.expect(dataField(result, "bItem")).toEqual(2);
+});
+
+globalThis.test("scope referencing an undefined type fails standalone validation naming the plugin", () => {
+  DomainGraphQL_Server$ReventlessLocal.setScope("plugin-token-1");
+  DomainGraphQL_Server$ReventlessLocal.registerQueries(["  broken: MissingType"], Object.fromEntries([[
+      "broken",
+      async (_root, _args, _ctx) => Object.fromEntries([[
+          "x",
+          0
+        ]])
+    ]]));
+  DomainGraphQL_Server$ReventlessLocal.relabelScope("plugin-token-1", "BrokenPlugin");
+  DomainGraphQL_Server$ReventlessLocal.resetScope();
+  let val;
+  try {
+    val = DomainGraphQL_Server$ReventlessLocal.composeSchema();
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID === "JsExn") {
+      let err$1 = err._1;
+      globalThis.expect(Stdlib_Option.getOr(Stdlib_JsExn.message(err$1), "")).toContain(`Plugin "BrokenPlugin" subgraph document is not valid standalone`);
+      globalThis.expect(Stdlib_Option.getOr(Stdlib_JsExn.message(err$1), "")).toContain("MissingType");
+      return;
+    }
+    throw err;
+  }
+  JestGlobals.Runner.fail("expected composeSchema to throw");
+});
+
+globalThis.test("two scopes defining the same type name with conflicting fields fail composition", () => {
+  DomainGraphQL_Server$ReventlessLocal.setScope("PluginA");
+  DomainGraphQL_Server$ReventlessLocal.registerTypes([`type SharedThing {\n  x: Int\n}`]);
+  DomainGraphQL_Server$ReventlessLocal.registerQueries(["  aItem: SharedThing"], Object.fromEntries([[
+      "aItem",
+      async (_root, _args, _ctx) => Object.fromEntries([[
+          "x",
+          1
+        ]])
+    ]]));
+  DomainGraphQL_Server$ReventlessLocal.setScope("PluginB");
+  DomainGraphQL_Server$ReventlessLocal.registerTypes([`type SharedThing {\n  x: String\n}`]);
+  DomainGraphQL_Server$ReventlessLocal.registerQueries(["  bItem: SharedThing"], Object.fromEntries([[
+      "bItem",
+      async (_root, _args, _ctx) => Object.fromEntries([[
+          "x",
+          2
+        ]])
+    ]]));
+  DomainGraphQL_Server$ReventlessLocal.resetScope();
+  let val;
+  try {
+    val = DomainGraphQL_Server$ReventlessLocal.composeSchema();
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID === "JsExn") {
+      globalThis.expect(Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "")).toContain("Cross-plugin schema merge failed (mirrors AWS MERGE_FAILED)");
+      return;
+    }
+    throw err;
+  }
+  JestGlobals.Runner.fail("expected composeSchema to throw");
+});
+
+globalThis.test("reset clears all scope buckets and restores the platform scope", () => {
+  DomainGraphQL_Server$ReventlessLocal.setScope("PluginA");
+  DomainGraphQL_Server$ReventlessLocal.registerTypes([sharedTypeSdl]);
+  DomainGraphQL_Server$ReventlessLocal.registerQueries(["  aItem: SharedThing"], Object.fromEntries([[
+      "aItem",
+      async (_root, _args, _ctx) => Object.fromEntries([[
+          "x",
+          1
+        ]])
+    ]]));
+  DomainGraphQL_Server$ReventlessLocal.reset();
+  globalThis.expect(DomainGraphQL_Server$ReventlessLocal.currentScope.contents).toBe("platform");
+  globalThis.expect(Stdlib_Option.isNone(DomainGraphQL_Server$ReventlessLocal.getQueryResolver("aItem"))).toBe(true);
+  let d = DomainGraphQL_Server$ReventlessLocal.diagnostics();
+  globalThis.expect(d.typeCount).toBe(0);
+  globalThis.expect(d.sdlQueryCount).toBe(0);
+  globalThis.expect(d.resolverQueryCount).toBe(0);
+  DomainGraphQL_Server$ReventlessLocal.registerQueries(["  pItem: String"], Object.fromEntries([[
+      "pItem",
+      async (_root, _args, _ctx) => Object.fromEntries([[
+          "x",
+          0
+        ]])
+    ]]));
+  globalThis.expect(DomainGraphQL_Server$ReventlessLocal.buildSdl().includes("pItem")).toBe(true);
+});
+
+globalThis.test("scope missing its own shared-type copy fails standalone even when platform defines it", async () => {
+  DomainGraphQL_Server$ReventlessLocal.registerTypes([sharedTypeSdl]);
+  DomainGraphQL_Server$ReventlessLocal.setScope("Leaner");
+  DomainGraphQL_Server$ReventlessLocal.registerQueries(["  leanItem: SharedThing"], Object.fromEntries([[
+      "leanItem",
+      async (_root, _args, _ctx) => Object.fromEntries([[
+          "x",
+          3
+        ]])
+    ]]));
+  DomainGraphQL_Server$ReventlessLocal.resetScope();
+  let val;
+  try {
+    val = DomainGraphQL_Server$ReventlessLocal.composeSchema();
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID === "JsExn") {
+      globalThis.expect(Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "")).toContain(`Plugin "Leaner" subgraph document is not valid standalone`);
+      return;
+    }
+    throw err;
+  }
+  return JestGlobals.Runner.fail("expected composeSchema to throw");
+});
+
+let Server;
+
+export {
+  Server,
+  intResolver,
+  resolversOf,
+  sharedTypeSdl,
+  dataField,
+  exnMessage,
+}
+/*  Not a pure module */

package/tests/plugin/ApiFragmentRegistryBehavior_GWT.res

@@ -1,131 +0,0 @@
-// Behavior GWT for the ApiFragmentRegistry SINGLETON AGGREGATE (the platform API-schema
-// fragment registry — event-sourced-fragment-registries plan). Unlike the retired slice, the
-// aggregate emits a SECOND event ApiSchemaComputed{snapshot} alongside each ApiFragment* fact,
-// carrying the whole consistent per-plugin fragment set after the change (the reactive
-// SideEffect's trigger). RecordApiFragmentPush changes no fragments, so it emits NO snapshot.
-open ReventlessCore
-module P = Reventless.Plugin // P.Domain / P.Platform — avoid shadowing apiSchemaFragment's labels
-
-module Test = ReventlessGwt.Behavior_GWT.MakeFromAggregate(ApiFragmentRegistrySpec, ApiFragmentRegistryBehavior)
-open Test
-open ApiFragmentRegistrySpec
-
-let fragment1: Reventless.Plugin.apiSchemaFragment = {
-  encoded: `{"types":["type Catalog_Product { id: ID! }"],"mutations":[],"queries":[],"subscriptions":[],"subscriptionSources":[]}`,
-  protocol: "graphql",
-}
-
-let fragment2: Reventless.Plugin.apiSchemaFragment = {
-  encoded: `{"types":["type Catalog_Product { id: ID!\\n  name: String! }"],"mutations":[],"queries":[],"subscriptions":[],"subscriptionSources":[]}`,
-  protocol: "graphql",
-}
-
-// A snapshot entry mirrors the behaviour's `snapshotOf` fold (pluginId + the fragment's
-// encoded/protocol + its target).
-let entry = (~pluginId, ~fragment: Reventless.Plugin.apiSchemaFragment, ~apiTarget): fragmentSnapshotEntry => {
-  pluginId,
-  encoded: fragment.encoded,
-  protocol: fragment.protocol,
-  apiTarget,
-}
-
-describe("ApiFragmentRegistry aggregate", () => {
-  test("register on empty state emits ApiFragmentRegistered + ApiSchemaComputed", () =>
-    givenEvents([])
-    ->whenCmd(RegisterApiFragment({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"}))
-    ->thenEvents([
-      ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"}),
-      ApiSchemaComputed({snapshot: [entry(~pluginId="p1", ~fragment=fragment1, ~apiTarget=P.Domain)]}),
-    ])
-  )
-
-  test("re-registering an identical fragment + target is idempotent (no event)", () =>
-    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"})])
-    ->whenCmd(RegisterApiFragment({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t1"}))
-    ->thenNoEvent
-  )
-
-  test("registering a changed fragment emits ApiFragmentUpdated + ApiSchemaComputed", () =>
-    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"})])
-    ->whenCmd(RegisterApiFragment({pluginId: "p1", fragment: fragment2, apiTarget: P.Domain, at: "t1"}))
-    ->thenEvents([
-      ApiFragmentUpdated({
-        pluginId: "p1",
-        previousFragment: fragment1,
-        newFragment: fragment2,
-        apiTarget: P.Domain,
-        at: "t1",
-      }),
-      ApiSchemaComputed({snapshot: [entry(~pluginId="p1", ~fragment=fragment2, ~apiTarget=P.Domain)]}),
-    ])
-  )
-
-  test("retargeting a plugin with an identical fragment emits ApiFragmentUpdated (fields move APIs)", () =>
-    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"})])
-    ->whenCmd(RegisterApiFragment({pluginId: "p1", fragment: fragment1, apiTarget: P.Platform, at: "t1"}))
-    ->thenEvents([
-      ApiFragmentUpdated({
-        pluginId: "p1",
-        previousFragment: fragment1,
-        newFragment: fragment1,
-        apiTarget: P.Platform,
-        at: "t1",
-      }),
-      ApiSchemaComputed({snapshot: [entry(~pluginId="p1", ~fragment=fragment1, ~apiTarget=P.Platform)]}),
-    ])
-  )
-
-  test("registering a second plugin carries BOTH plugins in the snapshot (consistent whole-registry fold)", () =>
-    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"})])
-    ->whenCmd(RegisterApiFragment({pluginId: "p2", fragment: fragment2, apiTarget: P.Platform, at: "t1"}))
-    ->thenEvents([
-      ApiFragmentRegistered({pluginId: "p2", fragment: fragment2, apiTarget: P.Platform, at: "t1"}),
-      ApiSchemaComputed({
-        snapshot: [
-          entry(~pluginId="p1", ~fragment=fragment1, ~apiTarget=P.Domain),
-          entry(~pluginId="p2", ~fragment=fragment2, ~apiTarget=P.Platform),
-        ],
-      }),
-    ])
-  )
-
-  test("deregister emits ApiFragmentDeregistered + an empty-registry ApiSchemaComputed", () =>
-    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"})])
-    ->whenCmd(DeregisterApiFragment({pluginId: "p1"}))
-    ->thenEvents([ApiFragmentDeregistered({pluginId: "p1"}), ApiSchemaComputed({snapshot: []})])
-  )
-
-  test("deregistering an absent fragment is idempotent (no event)", () =>
-    givenEvents([])->whenCmd(DeregisterApiFragment({pluginId: "p1"}))->thenNoEvent
-  )
-
-  test("recording a push outcome emits ONLY ApiFragmentPushRecorded (no snapshot, no recompute loop)", () =>
-    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"})])
-    ->whenCmd(RecordApiFragmentPush({pluginId: "p1", ok: true, message: "", at: "t1"}))
-    ->thenEvent(ApiFragmentPushRecorded({pluginId: "p1", ok: true, message: "", at: "t1"}))
-  )
-
-  test("redelivering an identical push record is idempotent (no event)", () =>
-    givenEvents([
-      ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"}),
-      ApiFragmentPushRecorded({pluginId: "p1", ok: true, message: "", at: "t1"}),
-    ])
-    ->whenCmd(RecordApiFragmentPush({pluginId: "p1", ok: true, message: "", at: "t1"}))
-    ->thenNoEvent
-  )
-
-  test("a later distinct push outcome is recorded again", () =>
-    givenEvents([
-      ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"}),
-      ApiFragmentPushRecorded({pluginId: "p1", ok: true, message: "", at: "t1"}),
-    ])
-    ->whenCmd(RecordApiFragmentPush({pluginId: "p1", ok: false, message: "stitch failed", at: "t2"}))
-    ->thenEvent(ApiFragmentPushRecorded({pluginId: "p1", ok: false, message: "stitch failed", at: "t2"}))
-  )
-
-  test("recording a push for an unregistered plugin is dropped (no event)", () =>
-    givenEvents([])
-    ->whenCmd(RecordApiFragmentPush({pluginId: "p1", ok: true, message: "", at: "t1"}))
-    ->thenNoEvent
-  )
-})