@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/adapter/LocalAuthUserStoreTest.res.mjs

@@ -0,0 +1,208 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodeos from "node:os";
+import * as Nodepath from "node:path";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as LocalAuth$ReventlessLocal from "../../src/adapter/Auth/LocalAuth.res.mjs";
+import * as UserStore$ReventlessLocal from "../../src/adapter/Auth/UserStore.res.mjs";
+
+function resetAll() {
+  LocalAuth$ReventlessLocal.resetUsers();
+  LocalAuth$ReventlessLocal.Login.resetStore();
+  UserStore$ReventlessLocal.resetResolution();
+}
+
+function _writeYamlFile(contents) {
+  let dir = Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), "reventless-userstore-"));
+  let path = Nodepath.join(dir, "users.yaml");
+  Nodefs.writeFileSync(path, contents, "utf8");
+  return path;
+}
+
+globalThis.test("parseString decodes a well-formed YAML document", async () => {
+  let entries = UserStore$ReventlessLocal.parseString(`
+- username: alice
+  password: alice-pw
+  groups: [Editor]
+- username: bob
+  password: bob-pw
+  groups: []
+`);
+  if (entries.TAG !== "Ok") {
+    return Stdlib_JsError.throwWithMessage("parseString failed: " + entries._0);
+  }
+  let entries$1 = entries._0;
+  globalThis.expect(entries$1.length).toEqual(2);
+  let first = entries$1[0];
+  globalThis.expect(first.username).toEqual("alice");
+  globalThis.expect(first.password).toEqual("alice-pw");
+  globalThis.expect(first.groups).toEqual(["Editor"]);
+});
+
+globalThis.test("parseString rejects malformed YAML", async () => {
+  let match = UserStore$ReventlessLocal.parseString("not: valid: yaml: at all: ::");
+  if (match.TAG === "Ok") {
+    return Stdlib_JsError.throwWithMessage("expected Error for malformed YAML");
+  }
+});
+
+globalThis.test("parseString rejects entries missing required fields", async () => {
+  let match = UserStore$ReventlessLocal.parseString(`
+- username: alice
+  groups: [Editor]
+`);
+  if (match.TAG === "Ok") {
+    return Stdlib_JsError.throwWithMessage("expected Error for missing password");
+  }
+});
+
+globalThis.test("load(~users) registers credentials and returns InlineUsers", async () => {
+  resetAll();
+  let entries = [
+    {
+      username: "alice",
+      password: "alice-pw",
+      groups: ["Editor"]
+    },
+    {
+      username: "bob",
+      password: "bob-pw",
+      groups: [],
+      userId: "u-bob"
+    }
+  ];
+  let msg = UserStore$ReventlessLocal.load(entries, undefined, undefined);
+  if (msg.TAG === "Ok") {
+    let tmp = msg._0;
+    if (typeof tmp === "object" || tmp !== "InlineUsers") {
+      Stdlib_JsError.throwWithMessage("expected InlineUsers");
+    }
+  } else {
+    Stdlib_JsError.throwWithMessage("load failed: " + msg._0);
+  }
+  let result = await LocalAuth$ReventlessLocal.Login.issue("alice", "alice-pw");
+  if (result.TAG !== "Ok") {
+    Stdlib_JsError.throwWithMessage("issue rejected loaded credentials: " + result._0);
+  }
+  let identity = LocalAuth$ReventlessLocal.lookupUser("bob");
+  if (identity !== undefined) {
+    globalThis.expect(identity.userId).toEqual("u-bob");
+    return;
+  } else {
+    return Stdlib_JsError.throwWithMessage("bob not in user registry");
+  }
+});
+
+globalThis.test("load(~usersFile) reads a YAML file from disk", async () => {
+  resetAll();
+  let path = _writeYamlFile(`
+- username: carol
+  password: carol-pw
+  groups: [Admin]
+`);
+  let msg = UserStore$ReventlessLocal.load(undefined, path, undefined);
+  if (msg.TAG === "Ok") {
+    let p = msg._0;
+    if (typeof p !== "object" || p.TAG !== "UsersFile") {
+      Stdlib_JsError.throwWithMessage("expected UsersFile resolution");
+    } else {
+      globalThis.expect(p._0).toEqual(path);
+    }
+  } else {
+    Stdlib_JsError.throwWithMessage("load failed: " + msg._0);
+  }
+  let result = await LocalAuth$ReventlessLocal.Login.issue("carol", "carol-pw");
+  if (result.TAG !== "Ok") {
+    Stdlib_JsError.throwWithMessage("issue rejected file-loaded credentials: " + result._0);
+  }
+  Nodefs.rmSync(path, {
+    force: true
+  });
+});
+
+globalThis.test("load(~usersFile) returns Error when the file is missing", async () => {
+  resetAll();
+  let match = UserStore$ReventlessLocal.load(undefined, "/tmp/does-not-exist-reventless.yaml", undefined);
+  if (match.TAG === "Ok") {
+    return Stdlib_JsError.throwWithMessage("expected Error for missing file");
+  }
+});
+
+globalThis.test("load() with no args + no default file returns Empty", async () => {
+  resetAll();
+  let msg = UserStore$ReventlessLocal.load(undefined, undefined, undefined);
+  if (msg.TAG !== "Ok") {
+    return Stdlib_JsError.throwWithMessage("load failed: " + msg._0);
+  }
+  let tmp = msg._0;
+  if (typeof tmp !== "object") {
+    if (tmp === "InlineUsers") {
+      return Stdlib_JsError.throwWithMessage("expected Empty or DefaultFile");
+    } else {
+      return;
+    }
+  } else if (tmp.TAG === "UsersFile") {
+    return Stdlib_JsError.throwWithMessage("expected Empty or DefaultFile");
+  } else {
+    return;
+  }
+});
+
+globalThis.test("inline users win over a file path", async () => {
+  resetAll();
+  let path = _writeYamlFile(`
+- username: file-user
+  password: file-pw
+  groups: []
+`);
+  let inline = [{
+      username: "inline-user",
+      password: "inline-pw",
+      groups: []
+    }];
+  let msg = UserStore$ReventlessLocal.load(inline, path, undefined);
+  if (msg.TAG === "Ok") {
+    let tmp = msg._0;
+    if (typeof tmp === "object" || tmp !== "InlineUsers") {
+      Stdlib_JsError.throwWithMessage("expected InlineUsers (inline should win)");
+    }
+  } else {
+    Stdlib_JsError.throwWithMessage("load failed: " + msg._0);
+  }
+  let match = LocalAuth$ReventlessLocal.lookupUser("file-user");
+  if (match !== undefined) {
+    Stdlib_JsError.throwWithMessage("file-user leaked into registry despite inline override");
+  }
+  let match$1 = LocalAuth$ReventlessLocal.lookupUser("inline-user");
+  if (match$1 !== undefined) {
+    
+  } else {
+    Stdlib_JsError.throwWithMessage("inline-user missing from registry");
+  }
+  Nodefs.rmSync(path, {
+    force: true
+  });
+});
+
+globalThis.test("autoLoadOnce is a no-op after an explicit load", async () => {
+  resetAll();
+  UserStore$ReventlessLocal.load([{
+      username: "x",
+      password: "x",
+      groups: []
+    }], undefined, undefined);
+  UserStore$ReventlessLocal.autoLoadOnce();
+  let match = LocalAuth$ReventlessLocal.lookupUser("x");
+  if (match !== undefined) {
+    return;
+  } else {
+    return Stdlib_JsError.throwWithMessage("autoLoadOnce wiped explicit registration");
+  }
+});
+
+export {
+  resetAll,
+  _writeYamlFile,
+}
+/*  Not a pure module */

package/tests/adapter/LocalBusBoundedTest.res

@@ -0,0 +1,157 @@
+// Tests for the bounded PubSub mode of LocalBus (Phase G).
+// Verifies that MakeBounded({let capacity = n}) delivers messages correctly, fans out to all
+// subscribers, and exerts backpressure when subscriber queues are full.
+//
+// Timing note: bounded mode resolves publishEvent in ~3 microtask ticks
+// (1 extra vs unbounded) because PubSub.publish runs inside Effect.runPromise
+// rather than Effect.runSync.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+let defaultMeta: Reventless.Message.meta = {
+  service: "test",
+  time: "",
+  ip: "",
+  user: "test",
+  msgId: "",
+  correlationId: "",
+}
+
+describe("LocalBus bounded PubSub (Phase G)", () => {
+  describe("basic delivery", () => {
+    testPromise("delivers a message to a subscriber in bounded mode", async () => {
+      module TestBus = LocalBus.MakeBounded({let capacity = 10})
+      let delivered = ref(false)
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        delivered := true
+      })
+      let _ = await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      expect(delivered.contents)->toBe(true)
+    })
+
+    testPromise("bounded mode with no subscribers returns immediately", async () => {
+      module TestBus = LocalBus.MakeBounded({let capacity = 5})
+      // No subscribers — should not hang
+      await TestBus.publishEvent("empty-topic", "svc", defaultMeta, JSON.Null)
+    })
+
+    testPromise("passes service, meta, and json to the subscriber handler", async () => {
+      module TestBus = LocalBus.MakeBounded({let capacity = 10})
+      let capturedService = ref("")
+      let capturedJson = ref(JSON.Null)
+      TestBus.subscribeToEvents("T", async (svc, _meta, json) => {
+        capturedService := svc
+        capturedJson := json
+      })
+      let payload = JSON.parseOrThrow("{\"x\":42}")
+      let _ = await TestBus.publishEvent("T", "my-service", defaultMeta, payload)
+      expect(capturedService.contents)->toBe("my-service")
+      expect(capturedJson.contents)->toEqual(payload)
+    })
+  })
+
+  describe("fan-out", () => {
+    testPromise("delivers to all subscribers on the same topic", async () => {
+      module TestBus = LocalBus.MakeBounded({let capacity = 10})
+      let count = ref(0)
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      let _ = await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      expect(count.contents)->toBe(3)
+    })
+
+    testPromise("topic isolation preserved in bounded mode", async () => {
+      module TestBus = LocalBus.MakeBounded({let capacity = 10})
+      let countA = ref(0)
+      let countB = ref(0)
+      TestBus.subscribeToEvents("topic-a", async (_, _, _) => {
+        countA := countA.contents + 1
+      })
+      TestBus.subscribeToEvents("topic-b", async (_, _, _) => {
+        countB := countB.contents + 1
+      })
+      let _ = await TestBus.publishEvent("topic-a", "svc", defaultMeta, JSON.Null)
+      expect(countA.contents)->toBe(1)
+      expect(countB.contents)->toBe(0)
+    })
+  })
+
+  describe("backpressure", () => {
+    testPromise("publisher suspends when subscriber queue is full (capacity=1)", async () => {
+      // capacity=1: subscriber queue can buffer 1 message while the subscriber is processing.
+      // Timeline:
+      //   p1 publish: drain fiber D has a pending Queue.take → msg1 goes to D directly
+      //   p2 publish: no pending take (D is processing msg1, blocked on gate) → msg2 buffered
+      //   p3 publish: queue is full (msg2 there, capacity=1) → F3 SUSPENDS
+      //   After opening gate: msg1 processed → done_1 → D takes msg2 → F3 wakes, delivers msg3
+      module TestBus = LocalBus.MakeBounded({let capacity = 1})
+      let processedCount = ref(0)
+      // Gate Deferred: subscriber blocks until explicitly opened
+      let gate: Deferred.t<unit, unit> = Deferred.make()->Effect.runSync
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        let _ = await Deferred.await_(gate)->Effect.runPromise
+        processedCount := processedCount.contents + 1
+      })
+      // Start 3 publishes without awaiting.
+      // p1: D's pending Queue.take resolves with msg1; D starts processing (blocks on gate)
+      // p2: msg2 buffered in queue (capacity=1, fits since D already took msg1)
+      // p3: queue full → F3 fiber suspends inside PubSub.publish
+      let p1 = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      let p2 = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      let p3 = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      // Tick 1: drain fiber D runs, takes msg1, calls handler → handler blocks on gate
+      let _ = await Promise.resolve()
+      // Gate not open yet — no messages fully processed
+      expect(processedCount.contents)->toBe(0)
+      // Open gate: subscriber can now process all pending messages
+      let _ = Deferred.succeed(gate, ())->Effect.runSync
+      // Await each publish promise; by the time all resolve, all 3 handlers have run
+      let _ = await p1
+      let _ = await p2
+      let _ = await p3
+      expect(processedCount.contents)->toBe(3)
+    })
+  })
+
+  describe("timing", () => {
+    testPromise("bounded mode completes within 3 microtask ticks", async () => {
+      module TestBus = LocalBus.MakeBounded({let capacity = 10})
+      let delivered = ref(false)
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        delivered := true
+      })
+      let pubPromise = TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      // Not delivered synchronously
+      expect(delivered.contents)->toBe(false)
+      let _ = await Promise.resolve() // tick 1
+      let _ = await Promise.resolve() // tick 2
+      let _ = await Promise.resolve() // tick 3 (bounded adds 1 vs unbounded's 2)
+      let _ = await pubPromise
+      expect(delivered.contents)->toBe(true)
+    })
+  })
+
+  describe("reset", () => {
+    testPromise("reset shuts down bounded hubs cleanly", async () => {
+      module TestBus = LocalBus.MakeBounded({let capacity = 5})
+      let count = ref(0)
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      let _ = await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      expect(count.contents)->toBe(1)
+      // reset should not throw or hang
+      TestBus.reset()
+      expect(count.contents)->toBe(1) // count unchanged by reset itself
+    })
+  })
+})

package/tests/adapter/LocalBusBoundedTest.res.mjs

@@ -0,0 +1,168 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Deferred from "effect/Deferred";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let defaultMeta = {
+  service: "test",
+  time: "",
+  ip: "",
+  user: "test",
+  msgId: "",
+  correlationId: ""
+};
+
+globalThis.describe("LocalBus bounded PubSub (Phase G)", () => {
+  globalThis.describe("basic delivery", () => {
+    globalThis.test("delivers a message to a subscriber in bounded mode", async () => {
+      let TestBus = LocalBus$ReventlessLocal.MakeBounded({
+        capacity: 10
+      });
+      let delivered = {
+        contents: false
+      };
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        delivered.contents = true;
+      });
+      await TestBus.publishEvent("T", "svc", defaultMeta, null);
+      globalThis.expect(delivered.contents).toBe(true);
+    });
+    globalThis.test("bounded mode with no subscribers returns immediately", async () => {
+      let TestBus = LocalBus$ReventlessLocal.MakeBounded({
+        capacity: 5
+      });
+      return await TestBus.publishEvent("empty-topic", "svc", defaultMeta, null);
+    });
+    globalThis.test("passes service, meta, and json to the subscriber handler", async () => {
+      let TestBus = LocalBus$ReventlessLocal.MakeBounded({
+        capacity: 10
+      });
+      let capturedService = {
+        contents: ""
+      };
+      let capturedJson = {
+        contents: null
+      };
+      TestBus.subscribeToEvents("T", async (svc, _meta, json) => {
+        capturedService.contents = svc;
+        capturedJson.contents = json;
+      });
+      let payload = JSON.parse("{\"x\":42}");
+      await TestBus.publishEvent("T", "my-service", defaultMeta, payload);
+      globalThis.expect(capturedService.contents).toBe("my-service");
+      globalThis.expect(capturedJson.contents).toEqual(payload);
+    });
+  });
+  globalThis.describe("fan-out", () => {
+    globalThis.test("delivers to all subscribers on the same topic", async () => {
+      let TestBus = LocalBus$ReventlessLocal.MakeBounded({
+        capacity: 10
+      });
+      let count = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      await TestBus.publishEvent("T", "svc", defaultMeta, null);
+      globalThis.expect(count.contents).toBe(3);
+    });
+    globalThis.test("topic isolation preserved in bounded mode", async () => {
+      let TestBus = LocalBus$ReventlessLocal.MakeBounded({
+        capacity: 10
+      });
+      let countA = {
+        contents: 0
+      };
+      let countB = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("topic-a", async (param, param$1, param$2) => {
+        countA.contents = countA.contents + 1 | 0;
+      });
+      TestBus.subscribeToEvents("topic-b", async (param, param$1, param$2) => {
+        countB.contents = countB.contents + 1 | 0;
+      });
+      await TestBus.publishEvent("topic-a", "svc", defaultMeta, null);
+      globalThis.expect(countA.contents).toBe(1);
+      globalThis.expect(countB.contents).toBe(0);
+    });
+  });
+  globalThis.describe("backpressure", () => {
+    globalThis.test("publisher suspends when subscriber queue is full (capacity=1)", async () => {
+      let TestBus = LocalBus$ReventlessLocal.MakeBounded({
+        capacity: 1
+      });
+      let processedCount = {
+        contents: 0
+      };
+      let gate = Effect.runSync(Deferred.make());
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        await Effect.runPromise(Deferred.await(gate));
+        processedCount.contents = processedCount.contents + 1 | 0;
+      });
+      let p1 = TestBus.publishEvent("T", "svc", defaultMeta, null);
+      let p2 = TestBus.publishEvent("T", "svc", defaultMeta, null);
+      let p3 = TestBus.publishEvent("T", "svc", defaultMeta, null);
+      await Promise.resolve();
+      globalThis.expect(processedCount.contents).toBe(0);
+      Effect.runSync(Deferred.succeed(gate, undefined));
+      await p1;
+      await p2;
+      await p3;
+      globalThis.expect(processedCount.contents).toBe(3);
+    });
+  });
+  globalThis.describe("timing", () => {
+    globalThis.test("bounded mode completes within 3 microtask ticks", async () => {
+      let TestBus = LocalBus$ReventlessLocal.MakeBounded({
+        capacity: 10
+      });
+      let delivered = {
+        contents: false
+      };
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        delivered.contents = true;
+      });
+      let pubPromise = TestBus.publishEvent("T", "svc", defaultMeta, null);
+      globalThis.expect(delivered.contents).toBe(false);
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+      await pubPromise;
+      globalThis.expect(delivered.contents).toBe(true);
+    });
+  });
+  globalThis.describe("reset", () => {
+    globalThis.test("reset shuts down bounded hubs cleanly", async () => {
+      let TestBus = LocalBus$ReventlessLocal.MakeBounded({
+        capacity: 5
+      });
+      let count = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      await TestBus.publishEvent("T", "svc", defaultMeta, null);
+      globalThis.expect(count.contents).toBe(1);
+      TestBus.reset();
+      globalThis.expect(count.contents).toBe(1);
+    });
+  });
+});
+
+export {
+  defaultMeta,
+}
+/*  Not a pure module */

package/tests/adapter/LocalBusPubSubTest.res

@@ -0,0 +1,81 @@
+// Tests for the PubSub-based LocalBus implementation (Phase F).
+// Verifies the 2-tick timing guarantee and multi-subscriber fan-out.
+//
+// These tests lock in two invariants of the PubSub refactor:
+//   1. publishEvent still resolves in exactly 2 microtask ticks (unbounded mode).
+//   2. A single publishEvent call reaches all subscribers on the same topic.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+let defaultMeta: Reventless.Message.meta = {
+  service: "test",
+  time: "",
+  ip: "",
+  user: "test",
+  msgId: "",
+  correlationId: "",
+}
+
+describe("LocalBus PubSub (Phase F)", () => {
+  describe("publishEvent timing", () => {
+    testPromise("resolves after exactly 2 microtask ticks", async () => {
+      module TestBus = LocalBus.Make()
+      let delivered = ref(false)
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        delivered := true
+      })
+      // Start publishEvent without awaiting — drive manually tick by tick.
+      let pubPromise = TestBus.publishEvent("T", "svc", defaultMeta, JSON.parseOrThrow("{}"))
+      // Tick 0: publish is synchronous; drain fiber hasn't run yet.
+      expect(delivered.contents)->toBe(false)
+      // Tick 1: Effect scheduler runs drain fiber; handler sets delivered.
+      let _ = await Promise.resolve()
+      // Tick 2: allDone Deferred resolves; pubPromise completes.
+      let _ = await Promise.resolve()
+      let _ = await pubPromise
+      expect(delivered.contents)->toBe(true)
+    })
+
+    testPromise("publishEvent with no subscribers returns immediately", async () => {
+      module TestBus = LocalBus.Make()
+      // No subscribers registered — should not hang.
+      await TestBus.publishEvent("empty-topic", "svc", defaultMeta, JSON.Null)
+      // If we reach here the test passes (no timeout/hang).
+    })
+  })
+
+  describe("fan-out", () => {
+    testPromise("delivers to all subscribers on the same topic", async () => {
+      module TestBus = LocalBus.Make()
+      let count = ref(0)
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      let _ = await TestBus.publishEvent("T", "svc", defaultMeta, JSON.parseOrThrow("{}"))
+      expect(count.contents)->toBe(3)
+    })
+
+    testPromise("publishing to topic-a does not reach topic-b subscribers", async () => {
+      module TestBus = LocalBus.Make()
+      let countA = ref(0)
+      let countB = ref(0)
+      TestBus.subscribeToEvents("topic-a", async (_, _, _) => {
+        countA := countA.contents + 1
+      })
+      TestBus.subscribeToEvents("topic-b", async (_, _, _) => {
+        countB := countB.contents + 1
+      })
+      let _ = await TestBus.publishEvent("topic-a", "svc", defaultMeta, JSON.Null)
+      expect(countA.contents)->toBe(1)
+      expect(countB.contents)->toBe(0)
+    })
+  })
+})

package/tests/adapter/LocalBusPubSubTest.res.mjs

@@ -0,0 +1,81 @@
+// 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 defaultMeta = {
+  service: "test",
+  time: "",
+  ip: "",
+  user: "test",
+  msgId: "",
+  correlationId: ""
+};
+
+globalThis.describe("LocalBus PubSub (Phase F)", () => {
+  globalThis.describe("publishEvent timing", () => {
+    globalThis.test("resolves after exactly 2 microtask ticks", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let delivered = {
+        contents: false
+      };
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        delivered.contents = true;
+      });
+      let pubPromise = TestBus.publishEvent("T", "svc", defaultMeta, JSON.parse("{}"));
+      globalThis.expect(delivered.contents).toBe(false);
+      await Promise.resolve();
+      await Promise.resolve();
+      await pubPromise;
+      globalThis.expect(delivered.contents).toBe(true);
+    });
+    globalThis.test("publishEvent with no subscribers returns immediately", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      return await TestBus.publishEvent("empty-topic", "svc", defaultMeta, null);
+    });
+  });
+  globalThis.describe("fan-out", () => {
+    globalThis.test("delivers to all subscribers on the same topic", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let count = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      await TestBus.publishEvent("T", "svc", defaultMeta, JSON.parse("{}"));
+      globalThis.expect(count.contents).toBe(3);
+    });
+    globalThis.test("publishing to topic-a does not reach topic-b subscribers", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let countA = {
+        contents: 0
+      };
+      let countB = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("topic-a", async (param, param$1, param$2) => {
+        countA.contents = countA.contents + 1 | 0;
+      });
+      TestBus.subscribeToEvents("topic-b", async (param, param$1, param$2) => {
+        countB.contents = countB.contents + 1 | 0;
+      });
+      await TestBus.publishEvent("topic-a", "svc", defaultMeta, null);
+      globalThis.expect(countA.contents).toBe(1);
+      globalThis.expect(countB.contents).toBe(0);
+    });
+  });
+});
+
+export {
+  defaultMeta,
+}
+/*  Not a pure module */