@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/SplitApiTest.res

@@ -0,0 +1,102 @@
+// Integration tests for split API mode.
+// Verifies that admin and plugin schemas register into separate server instances
+// with no cross-contamination.
+//
+// Tests the split routing pattern used by Platform.makePlatform(splitApi=true):
+// - Admin schema → GraphQL_ServerInstance (dedicated admin server)
+// - Plugin schema → GraphQL_Server singleton (default plugin server)
+//
+// MCP split is structurally identical (MCP_ServerInstance mirrors
+// GraphQL_ServerInstance) but is not tested here due to Jest ESM
+// compatibility issues with the MCP SDK dependency chain.
+
+open JestGlobals
+
+// Force side-effect import (creates admin instance + registers schemas)
+let adminGraphQL = SplitApiFixtures.adminGraphQL
+
+// Derive field names from schema entries — single source of truth.
+let adminQueryFields = SplitApiFixtures.adminQueryFieldNames
+let adminMutationFields = SplitApiFixtures.adminMutationFieldNames
+
+// Plugin field names
+let pluginMutationPrefix = "SplitTestPlugin_SplitTestItem_"
+let pluginQueryPrefix = "SplitTestPlugin_SplitTestItem"
+
+describe("Split API Mode — Schema Separation", () => {
+  describe("Plugin GraphQL singleton", () => {
+    testPromise("contains plugin mutation fields", async () => {
+      let d = GraphQL_Server.diagnostics()
+      let hasPluginMutation =
+        d.registeredMutationFields->Array.some(f => f->String.startsWith(pluginMutationPrefix))
+      expect(hasPluginMutation)->toBe(true)
+    })
+
+    testPromise("contains plugin query fields", async () => {
+      let d = GraphQL_Server.diagnostics()
+      let hasPluginQuery =
+        d.registeredQueryFields->Array.some(f => f->String.startsWith(pluginQueryPrefix))
+      expect(hasPluginQuery)->toBe(true)
+    })
+
+    testPromise("does NOT contain admin mutation fields", async () => {
+      let d = GraphQL_Server.diagnostics()
+      let hasAdminField =
+        d.registeredMutationFields->Array.some(f =>
+          adminMutationFields->Array.includes(f)
+        )
+      expect(hasAdminField)->toBe(false)
+    })
+
+    testPromise("does NOT contain admin query fields", async () => {
+      let d = GraphQL_Server.diagnostics()
+      let hasAdminQuery =
+        d.registeredQueryFields->Array.some(f =>
+          adminQueryFields->Array.includes(f)
+        )
+      expect(hasAdminQuery)->toBe(false)
+    })
+  })
+
+  describe("Admin GraphQL instance", () => {
+    testPromise("contains admin mutation fields", async () => {
+      let d = adminGraphQL.diagnostics()
+      adminMutationFields->Array.forEach(field => {
+        let hasField = d.registeredMutationFields->Array.includes(field)
+        expect(hasField)->toBe(true)
+      })
+    })
+
+    testPromise("contains admin query fields", async () => {
+      let d = adminGraphQL.diagnostics()
+      adminQueryFields->Array.forEach(field => {
+        let hasField = d.registeredQueryFields->Array.includes(field)
+        expect(hasField)->toBe(true)
+      })
+    })
+
+    testPromise("does NOT contain plugin mutation fields", async () => {
+      let d = adminGraphQL.diagnostics()
+      let hasPluginMutation =
+        d.registeredMutationFields->Array.some(f => f->String.startsWith(pluginMutationPrefix))
+      expect(hasPluginMutation)->toBe(false)
+    })
+
+    testPromise("does NOT contain plugin query fields", async () => {
+      let d = adminGraphQL.diagnostics()
+      let hasPluginQuery =
+        d.registeredQueryFields->Array.some(f => f->String.startsWith(pluginQueryPrefix))
+      expect(hasPluginQuery)->toBe(false)
+    })
+
+    testPromise("has admin type definitions registered", async () => {
+      let d = adminGraphQL.diagnostics()
+      expect(d.typeCount > 0)->toBe(true)
+    })
+
+    testPromise("has no SDL mismatches", async () => {
+      let d = adminGraphQL.diagnostics()
+      expect(d.mismatches->Array.length)->toBe(0)
+    })
+  })
+})

package/tests/SplitApiTest.res.mjs

@@ -0,0 +1,82 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as GraphQL_Server$ReventlessLocal from "../src/adapter/GraphQL_Server.res.mjs";
+import * as SplitApiFixtures$ReventlessLocal from "./SplitApiFixtures.res.mjs";
+
+let pluginMutationPrefix = "SplitTestPlugin_SplitTestItem_";
+
+let pluginQueryPrefix = "SplitTestPlugin_SplitTestItem";
+
+globalThis.describe("Split API Mode — Schema Separation", () => {
+  globalThis.describe("Plugin GraphQL singleton", () => {
+    globalThis.test("contains plugin mutation fields", async () => {
+      let d = GraphQL_Server$ReventlessLocal.diagnostics();
+      let hasPluginMutation = d.registeredMutationFields.some(f => f.startsWith(pluginMutationPrefix));
+      globalThis.expect(hasPluginMutation).toBe(true);
+    });
+    globalThis.test("contains plugin query fields", async () => {
+      let d = GraphQL_Server$ReventlessLocal.diagnostics();
+      let hasPluginQuery = d.registeredQueryFields.some(f => f.startsWith(pluginQueryPrefix));
+      globalThis.expect(hasPluginQuery).toBe(true);
+    });
+    globalThis.test("does NOT contain admin mutation fields", async () => {
+      let d = GraphQL_Server$ReventlessLocal.diagnostics();
+      let hasAdminField = d.registeredMutationFields.some(f => SplitApiFixtures$ReventlessLocal.adminMutationFieldNames.includes(f));
+      globalThis.expect(hasAdminField).toBe(false);
+    });
+    globalThis.test("does NOT contain admin query fields", async () => {
+      let d = GraphQL_Server$ReventlessLocal.diagnostics();
+      let hasAdminQuery = d.registeredQueryFields.some(f => SplitApiFixtures$ReventlessLocal.adminQueryFieldNames.includes(f));
+      globalThis.expect(hasAdminQuery).toBe(false);
+    });
+  });
+  globalThis.describe("Admin GraphQL instance", () => {
+    globalThis.test("contains admin mutation fields", async () => {
+      let d = SplitApiFixtures$ReventlessLocal.adminGraphQL.diagnostics();
+      SplitApiFixtures$ReventlessLocal.adminMutationFieldNames.forEach(field => {
+        let hasField = d.registeredMutationFields.includes(field);
+        globalThis.expect(hasField).toBe(true);
+      });
+    });
+    globalThis.test("contains admin query fields", async () => {
+      let d = SplitApiFixtures$ReventlessLocal.adminGraphQL.diagnostics();
+      SplitApiFixtures$ReventlessLocal.adminQueryFieldNames.forEach(field => {
+        let hasField = d.registeredQueryFields.includes(field);
+        globalThis.expect(hasField).toBe(true);
+      });
+    });
+    globalThis.test("does NOT contain plugin mutation fields", async () => {
+      let d = SplitApiFixtures$ReventlessLocal.adminGraphQL.diagnostics();
+      let hasPluginMutation = d.registeredMutationFields.some(f => f.startsWith(pluginMutationPrefix));
+      globalThis.expect(hasPluginMutation).toBe(false);
+    });
+    globalThis.test("does NOT contain plugin query fields", async () => {
+      let d = SplitApiFixtures$ReventlessLocal.adminGraphQL.diagnostics();
+      let hasPluginQuery = d.registeredQueryFields.some(f => f.startsWith(pluginQueryPrefix));
+      globalThis.expect(hasPluginQuery).toBe(false);
+    });
+    globalThis.test("has admin type definitions registered", async () => {
+      let d = SplitApiFixtures$ReventlessLocal.adminGraphQL.diagnostics();
+      globalThis.expect(d.typeCount > 0).toBe(true);
+    });
+    globalThis.test("has no SDL mismatches", async () => {
+      let d = SplitApiFixtures$ReventlessLocal.adminGraphQL.diagnostics();
+      globalThis.expect(d.mismatches.length).toBe(0);
+    });
+  });
+});
+
+let adminGraphQL = SplitApiFixtures$ReventlessLocal.adminGraphQL;
+
+let adminQueryFields = SplitApiFixtures$ReventlessLocal.adminQueryFieldNames;
+
+let adminMutationFields = SplitApiFixtures$ReventlessLocal.adminMutationFieldNames;
+
+export {
+  adminGraphQL,
+  adminQueryFields,
+  adminMutationFields,
+  pluginMutationPrefix,
+  pluginQueryPrefix,
+}
+/*  Not a pure module */

package/tests/TestFixtures.res

@@ -0,0 +1,54 @@
+// Shared test infrastructure for all component integration tests.
+
+// ─────────────────────────────────────────────────────────────
+// Test metadata
+// ─────────────────────────────────────────────────────────────
+
+let testMeta: Reventless.Message.meta = {
+  service: "test",
+  time: "2024-01-01T00:00:00.000Z",
+  ip: "127.0.0.1",
+  user: "testuser",
+  msgId: "msg-001",
+  correlationId: "corr-001",
+}
+
+// For tests where meta.service must match a specific source name for routing.
+let makeTestMeta = (~service): Reventless.Message.meta => {...testMeta, service}
+
+// ─────────────────────────────────────────────────────────────
+// Mock infrastructure
+// ─────────────────────────────────────────────────────────────
+
+let mockQueryEngine: Reventless.QueryEngine.operations = {
+  scan: async (~readModelName as _, ~filterConfigs as _, ~limit as _) => [],
+  query: async (
+    ~readModelName as _,
+    ~key as _=?,
+    ~id as _,
+    ~subIdConfig as _=?,
+    ~filterConfigs as _=?,
+    ~ascending as _=?,
+    ~limit as _=?,
+  ) => [],
+}
+
+let mockScheduler: ReventlessInfra.Scheduler.operations = {
+  createSchedule: async (_, _) => (),
+  deleteSchedule: async (_, _) => (),
+}
+
+let mockResourceNaming: ReventlessInfra.ResourceNaming.operations = {
+  validateName: n => n,
+  urnName: n => n,
+}
+
+// ─────────────────────────────────────────────────────────────
+// Jest fake timer bindings
+// ─────────────────────────────────────────────────────────────
+
+type jestObj
+@module("@jest/globals") external jest: jestObj = "jest"
+@send external useFakeTimers: jestObj => unit = "useFakeTimers"
+@send external useRealTimers: jestObj => unit = "useRealTimers"
+@send external advanceTimersByTime: (jestObj, int) => unit = "advanceTimersByTime"

package/tests/TestFixtures.res.mjs

@@ -0,0 +1,65 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let testMeta = {
+  service: "test",
+  time: "2024-01-01T00:00:00.000Z",
+  ip: "127.0.0.1",
+  user: "testuser",
+  msgId: "msg-001",
+  correlationId: "corr-001"
+};
+
+function makeTestMeta(service) {
+  let newrecord = {...testMeta};
+  newrecord.service = service;
+  return newrecord;
+}
+
+async function mockQueryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function mockQueryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let mockQueryEngine = {
+  scan: mockQueryEngine_scan,
+  query: mockQueryEngine_query
+};
+
+async function mockScheduler_createSchedule(param, param$1) {
+  
+}
+
+async function mockScheduler_deleteSchedule(param, param$1) {
+  
+}
+
+let mockScheduler = {
+  createSchedule: mockScheduler_createSchedule,
+  deleteSchedule: mockScheduler_deleteSchedule
+};
+
+function mockResourceNaming_validateName(n) {
+  return n;
+}
+
+function mockResourceNaming_urnName(n) {
+  return n;
+}
+
+let mockResourceNaming = {
+  validateName: mockResourceNaming_validateName,
+  urnName: mockResourceNaming_urnName
+};
+
+export {
+  testMeta,
+  makeTestMeta,
+  mockQueryEngine,
+  mockScheduler,
+  mockResourceNaming,
+}
+/* No side effect */

package/tests/adapter/BackendParityTest.res

@@ -0,0 +1,94 @@
+// Behavioural parity between Memory and Sqlite backends at the adapter layer.
+// Each test runs the same scenario against both BackendState settings.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+let runUnderMemory = async fn => {
+  BackendState.setMemory()
+  await fn()
+}
+
+let runUnderSqlite = async fn => {
+  let db = SqliteDriver.openDb(~path=":memory:")
+  BackendState.setSqlite(~db, ~path=":memory:")
+  await fn()
+  BackendState.setMemory()
+  db->SqliteDriver.close
+}
+
+describe("Backend parity (Memory vs Sqlite)", () => {
+  testPromise("EventLog: append + replay returns the same events under both", async () => {
+    let scenario = async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = EventLogStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="parity-events", ~opts)
+      let ops = await s.operations->TestRunner.resolve
+
+      let e1 = JSON.Encode.object(Dict.fromArray([("t", JSON.Encode.string("A"))]))
+      let e2 = JSON.Encode.object(Dict.fromArray([("t", JSON.Encode.string("B"))]))
+
+      let _ = await ops.append(0, "id-x", [e1])
+      let _ = await ops.append(1, "id-x", [e2])
+
+      let replayed = await ops.replay("id-x")
+      expect(replayed->Array.length)->toBe(2)
+      expect(replayed->Array.getUnsafe(0))->toEqual(e1)
+      expect(replayed->Array.getUnsafe(1))->toEqual(e2)
+    }
+
+    await runUnderMemory(scenario)
+    await runUnderSqlite(scenario)
+  })
+
+  testPromise("QueryDb: save + loadStream returns the same item under both", async () => {
+    let scenario = async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="parity-qdb", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+
+      let _ = await ops.save(
+        "k",
+        JSON.Encode.string("val"),
+        ReventlessCore.QueryDb.Any,
+        None,
+      )
+
+      let items =
+        await ops.loadStream("k")
+        ->Stream.runCollect
+        ->Effect.catchAll(_ => Effect.succeed([]))
+        ->Effect.runPromise
+      expect(items->Array.length)->toBe(1)
+      expect(items->Array.getUnsafe(0))->toEqual(JSON.Encode.string("val"))
+    }
+
+    await runUnderMemory(scenario)
+    await runUnderSqlite(scenario)
+  })
+
+  testPromise("EventLog: conflict detection works under both", async () => {
+    let scenario = async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = EventLogStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="parity-conflict", ~opts)
+      let ops = await s.operations->TestRunner.resolve
+
+      let e = JSON.Encode.object(Dict.fromArray([("t", JSON.Encode.string("C"))]))
+      let _ = await ops.append(0, "cid", [e])
+
+      // Reusing seqNr=0 must conflict under both backends.
+      let result = await ops.append(0, "cid", [e])
+      switch result {
+      | Error(_) => expect(true)->toBe(true)
+      | Ok() => expect("expected conflict")->toBe("actual Ok")
+      }
+    }
+
+    await runUnderMemory(scenario)
+    await runUnderSqlite(scenario)
+  })
+})

package/tests/adapter/BackendParityTest.res.mjs

@@ -0,0 +1,96 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Effect from "effect/Effect";
+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 SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as QueryDbStorage_InMemory$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbStorage_InMemory.res.mjs";
+import * as EventLogStorage_InMemory$ReventlessLocal from "../../src/adapter/EventLog/EventLogStorage_InMemory.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+async function runUnderMemory(fn) {
+  BackendState$ReventlessLocal.setMemory();
+  return await fn();
+}
+
+async function runUnderSqlite(fn) {
+  let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+  BackendState$ReventlessLocal.setSqlite(db, ":memory:");
+  await fn();
+  BackendState$ReventlessLocal.setMemory();
+  return SqliteDriver$ReventlessLocal.close(db);
+}
+
+globalThis.describe("Backend parity (Memory vs Sqlite)", () => {
+  globalThis.test("EventLog: append + replay returns the same events under both", async () => {
+    let scenario = async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = EventLogStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("parity-events", opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let e1 = Object.fromEntries([[
+          "t",
+          "A"
+        ]]);
+      let e2 = Object.fromEntries([[
+          "t",
+          "B"
+        ]]);
+      await ops.append(0, "id-x", [e1]);
+      await ops.append(1, "id-x", [e2]);
+      let replayed = await ops.replay("id-x");
+      globalThis.expect(replayed.length).toBe(2);
+      globalThis.expect(replayed[0]).toEqual(e1);
+      globalThis.expect(replayed[1]).toEqual(e2);
+    };
+    await runUnderMemory(scenario);
+    return await runUnderSqlite(scenario);
+  });
+  globalThis.test("QueryDb: save + loadStream returns the same item under both", async () => {
+    let scenario = async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("parity-qdb", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("k", "val", "Any", undefined);
+      let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("k")), param => Effect.succeed([])));
+      globalThis.expect(items.length).toBe(1);
+      globalThis.expect(items[0]).toEqual("val");
+    };
+    await runUnderMemory(scenario);
+    return await runUnderSqlite(scenario);
+  });
+  globalThis.test("EventLog: conflict detection works under both", async () => {
+    let scenario = async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = EventLogStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("parity-conflict", opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let e = Object.fromEntries([[
+          "t",
+          "C"
+        ]]);
+      await ops.append(0, "cid", [e]);
+      let result = await ops.append(0, "cid", [e]);
+      if (result.TAG === "Ok") {
+        globalThis.expect("expected conflict").toBe("actual Ok");
+        return;
+      }
+      globalThis.expect(true).toBe(true);
+    };
+    await runUnderMemory(scenario);
+    return await runUnderSqlite(scenario);
+  });
+});
+
+export {
+  opts,
+  runUnderMemory,
+  runUnderSqlite,
+}
+/*  Not a pure module */

package/tests/adapter/CollectNEventsTest.res

@@ -0,0 +1,82 @@
+// Tests for TestRunner.collectNEvents utility (Phase J of stream-handler-implementation plan).
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+let meta: Reventless.Message.meta = {
+  service: "svc",
+  time: "",
+  ip: "",
+  user: "u",
+  msgId: "",
+  correlationId: "",
+}
+
+describe("TestRunner.collectNEvents", () => {
+  testPromise("resolves after exactly n events", async () => {
+    module Bus = LocalBus.Make()
+    let collecting = TestRunner.collectNEvents(Bus.subscribeToEvents, "T", 3)
+    let json = JSON.parseOrThrow("{}")
+    await Bus.publishEvent("T", "svc", meta, json)
+    await Bus.publishEvent("T", "svc", meta, json)
+    await Bus.publishEvent("T", "svc", meta, json)
+    let events = await collecting
+    expect(events->Array.length)->toBe(3)
+  })
+
+  testPromise("captures service, meta, and json from each event", async () => {
+    module Bus = LocalBus.Make()
+    let collecting = TestRunner.collectNEvents(Bus.subscribeToEvents, "T", 2)
+    let j1 = JSON.parseOrThrow(`{"id":1}`)
+    let j2 = JSON.parseOrThrow(`{"id":2}`)
+    await Bus.publishEvent("T", "svc", meta, j1)
+    await Bus.publishEvent("T", "svc", meta, j2)
+    let events = await collecting
+    let e0 = events->Array.getUnsafe(0)
+    let e1 = events->Array.getUnsafe(1)
+    expect(e0.json)->toEqual(j1)
+    expect(e1.json)->toEqual(j2)
+  })
+
+  testPromise("resolves immediately for n = 0", async () => {
+    module Bus = LocalBus.Make()
+    let events = await TestRunner.collectNEvents(Bus.subscribeToEvents, "T", 0)
+    expect(events->Array.length)->toBe(0)
+  })
+
+  testPromise("does not resolve before n events arrive", async () => {
+    module Bus = LocalBus.Make()
+    let collecting = TestRunner.collectNEvents(Bus.subscribeToEvents, "T", 3)
+    let json = JSON.parseOrThrow("{}")
+    let resolved = ref(false)
+    let _ = collecting->Promise.then(events => {
+      resolved := true
+      Promise.resolve(events)
+    })
+    await Bus.publishEvent("T", "svc", meta, json)
+    await Bus.publishEvent("T", "svc", meta, json)
+    // Only 2 events so far — promise should not yet be resolved.
+    // One extra tick to let any spurious resolution propagate.
+    let _ = await Promise.resolve()
+    expect(resolved.contents)->toBe(false)
+    // Third event resolves it.
+    await Bus.publishEvent("T", "svc", meta, json)
+    let _ = await collecting
+    expect(resolved.contents)->toBe(true)
+  })
+
+  testPromise("works with multiple independent topics", async () => {
+    module Bus = LocalBus.Make()
+    let collectingA = TestRunner.collectNEvents(Bus.subscribeToEvents, "A", 1)
+    let collectingB = TestRunner.collectNEvents(Bus.subscribeToEvents, "B", 2)
+    let json = JSON.parseOrThrow("{}")
+    await Bus.publishEvent("A", "svc", meta, json)
+    await Bus.publishEvent("B", "svc", meta, json)
+    await Bus.publishEvent("B", "svc", meta, json)
+    let eventsA = await collectingA
+    let eventsB = await collectingB
+    expect(eventsA->Array.length)->toBe(1)
+    expect(eventsB->Array.length)->toBe(2)
+  })
+})

package/tests/adapter/CollectNEventsTest.res.mjs

@@ -0,0 +1,83 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let meta = {
+  service: "svc",
+  time: "",
+  ip: "",
+  user: "u",
+  msgId: "",
+  correlationId: ""
+};
+
+globalThis.describe("TestRunner.collectNEvents", () => {
+  globalThis.test("resolves after exactly n events", async () => {
+    let Bus = LocalBus$ReventlessLocal.Make({});
+    let collecting = TestRunner$ReventlessLocal.collectNEvents(Bus.subscribeToEvents, "T", 3);
+    let json = JSON.parse("{}");
+    await Bus.publishEvent("T", "svc", meta, json);
+    await Bus.publishEvent("T", "svc", meta, json);
+    await Bus.publishEvent("T", "svc", meta, json);
+    let events = await collecting;
+    globalThis.expect(events.length).toBe(3);
+  });
+  globalThis.test("captures service, meta, and json from each event", async () => {
+    let Bus = LocalBus$ReventlessLocal.Make({});
+    let collecting = TestRunner$ReventlessLocal.collectNEvents(Bus.subscribeToEvents, "T", 2);
+    let j1 = JSON.parse(`{"id":1}`);
+    let j2 = JSON.parse(`{"id":2}`);
+    await Bus.publishEvent("T", "svc", meta, j1);
+    await Bus.publishEvent("T", "svc", meta, j2);
+    let events = await collecting;
+    let e0 = events[0];
+    let e1 = events[1];
+    globalThis.expect(e0.json).toEqual(j1);
+    globalThis.expect(e1.json).toEqual(j2);
+  });
+  globalThis.test("resolves immediately for n = 0", async () => {
+    let Bus = LocalBus$ReventlessLocal.Make({});
+    let events = await TestRunner$ReventlessLocal.collectNEvents(Bus.subscribeToEvents, "T", 0);
+    globalThis.expect(events.length).toBe(0);
+  });
+  globalThis.test("does not resolve before n events arrive", async () => {
+    let Bus = LocalBus$ReventlessLocal.Make({});
+    let collecting = TestRunner$ReventlessLocal.collectNEvents(Bus.subscribeToEvents, "T", 3);
+    let json = JSON.parse("{}");
+    let resolved = {
+      contents: false
+    };
+    collecting.then(events => {
+      resolved.contents = true;
+      return Promise.resolve(events);
+    });
+    await Bus.publishEvent("T", "svc", meta, json);
+    await Bus.publishEvent("T", "svc", meta, json);
+    await Promise.resolve();
+    globalThis.expect(resolved.contents).toBe(false);
+    await Bus.publishEvent("T", "svc", meta, json);
+    await collecting;
+    globalThis.expect(resolved.contents).toBe(true);
+  });
+  globalThis.test("works with multiple independent topics", async () => {
+    let Bus = LocalBus$ReventlessLocal.Make({});
+    let collectingA = TestRunner$ReventlessLocal.collectNEvents(Bus.subscribeToEvents, "A", 1);
+    let collectingB = TestRunner$ReventlessLocal.collectNEvents(Bus.subscribeToEvents, "B", 2);
+    let json = JSON.parse("{}");
+    await Bus.publishEvent("A", "svc", meta, json);
+    await Bus.publishEvent("B", "svc", meta, json);
+    await Bus.publishEvent("B", "svc", meta, json);
+    let eventsA = await collectingA;
+    let eventsB = await collectingB;
+    globalThis.expect(eventsA.length).toBe(1);
+    globalThis.expect(eventsB.length).toBe(2);
+  });
+});
+
+export {
+  meta,
+}
+/*  Not a pure module */