@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/components/extensionpoint/ExtensionPointFixtures.res.mjs

@@ -0,0 +1,188 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as TestFixtures$ReventlessLocal from "../../TestFixtures.res.mjs";
+import * as ExtensionPointMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionPointMapping.res.mjs";
+import * as ExtensionPoint_Builder$ReventlessLocal from "../../../src/components/ExtensionPoint_Builder.res.mjs";
+
+S.enableJson();
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+TestRunner$ReventlessLocal.setup();
+
+let name = "TestEP";
+
+let commandSchema = S.schema(s => ({
+  TAG: "Forward",
+  targetId: s.m(S.string)
+}));
+
+let eventSchema = S.literal("TEPNoEvent");
+
+let directiveSchema = S.literal("TEPNoDirective");
+
+let moduleUrl = import.meta.url;
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let TestEPSpec = {
+  name: name,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  directiveSchema: directiveSchema,
+  moduleUrl: moduleUrl,
+  commandAuthorization: commandAuthorization
+};
+
+let name$1 = "TargetAgg";
+
+let commandSchema$1 = S.schema(s => ({
+  TAG: "Execute",
+  targetId: s.m(S.string)
+}));
+
+let eventSchema$1 = S.schema(s => ({
+  TAG: "Executed",
+  targetId: s.m(S.string)
+}));
+
+let errorSchema = S.literal("TEAggNoError");
+
+let moduleUrl$1 = import.meta.url;
+
+function commandAuthorization$1(param) {
+  return "AllowAuthenticated";
+}
+
+let DelegateAggSpec = {
+  Id: undefined,
+  name: name$1,
+  commandSchema: commandSchema$1,
+  eventSchema: eventSchema$1,
+  errorSchema: errorSchema,
+  moduleUrl: moduleUrl$1,
+  commandAuthorization: commandAuthorization$1
+};
+
+let moduleUrl$2 = "test:ExtensionPointFixtures:ForwardMapping";
+
+function mapIncomingCommand(_id, cmd, _meta) {
+  let targetId = cmd.targetId;
+  let execCmd = {
+    TAG: "Execute",
+    targetId: targetId
+  };
+  return [{
+      TAG: "PublishCommand",
+      _0: targetId,
+      _1: execCmd
+    }];
+}
+
+let ForwardMapping = {
+  ExtensionPoint: undefined,
+  Delegate: undefined,
+  moduleUrl: moduleUrl$2,
+  mapIncomingCommand: mapIncomingCommand,
+  mapOutgoingEvent: undefined
+};
+
+let TestEPMapping1 = ExtensionPointMapping$ReventlessInfra.Make({
+  ExtensionPoint: {
+    name: name,
+    moduleUrl: moduleUrl,
+    commandSchema: commandSchema,
+    eventSchema: eventSchema,
+    directiveSchema: directiveSchema
+  },
+  Delegate: {
+    Id: {
+      schema: Id$Reventless.StringPure.schema,
+      make: prim => prim,
+      makeFromString: prim => prim,
+      toString: prim => prim,
+      cmp: Id$Reventless.StringPure.cmp
+    },
+    name: name$1,
+    eventSchema: eventSchema$1,
+    errorSchema: errorSchema,
+    commandSchema: commandSchema$1,
+    moduleUrl: moduleUrl$1,
+    commandAuthorization: commandAuthorization$1
+  },
+  moduleUrl: moduleUrl$2,
+  mapIncomingCommand: mapIncomingCommand,
+  mapOutgoingEvent: undefined
+});
+
+let name$2 = "TestEPMappings";
+
+let moduleUrl$3 = import.meta.url;
+
+let mappings = [TestEPMapping1];
+
+let TestEPMappings = {
+  Spec: undefined,
+  name: name$2,
+  moduleUrl: moduleUrl$3,
+  mappings: mappings
+};
+
+let EPBuilderWithBus = ExtensionPoint_Builder$ReventlessLocal.Make(Bus);
+
+let TestEP = EPBuilderWithBus.Make({
+  name: name,
+  moduleUrl: moduleUrl,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  directiveSchema: directiveSchema
+})({
+  name: name$2,
+  moduleUrl: moduleUrl$3,
+  mappings: mappings
+});
+
+let capturedCmds = {
+  contents: []
+};
+
+async function mockPublishFn(cmds) {
+  capturedCmds.contents = capturedCmds.contents.concat(cmds);
+}
+
+let ep = TestEP.make(Object.fromEntries([[
+    "TargetAgg",
+    []
+  ]]), Object.fromEntries([[
+    "TargetAgg",
+    mockPublishFn
+  ]]), TestFixtures$ReventlessLocal.mockScheduler, TestFixtures$ReventlessLocal.mockQueryEngine, TestFixtures$ReventlessLocal.mockResourceNaming, undefined);
+
+let testMeta = TestFixtures$ReventlessLocal.makeTestMeta("TestEP");
+
+function resetMocks() {
+  capturedCmds.contents = [];
+}
+
+export {
+  Bus,
+  TestEPSpec,
+  DelegateAggSpec,
+  ForwardMapping,
+  TestEPMapping1,
+  TestEPMappings,
+  EPBuilderWithBus,
+  TestEP,
+  capturedCmds,
+  mockPublishFn,
+  ep,
+  testMeta,
+  resetMocks,
+}
+/*  Not a pure module */

package/tests/components/extensionpoint/ExtensionPointTest.res

@@ -0,0 +1,62 @@
+// Integration tests for ExtensionPoint builder (in-memory).
+// Dispatches a command to the EP channel and verifies that publishToAggregates is called.
+
+open JestGlobals
+open ExtensionPointFixtures
+
+// ─────────────────────────────────────────────────────────────
+// Resolve Output chain before tests run.
+//
+// Two resolves are needed:
+//   1. commandTopic resolve — triggers commandTopicResources->flatMap which calls
+//      forCommandTopic → RuntimeEnvironment.make (starts handler chain) → connect
+//      (registers Bus command handler).
+//   2. eventTopic resolve — drains additional microtask ticks so the inner
+//      handler->Output.apply(setHandlerRef) completes before any test dispatches.
+// ─────────────────────────────────────────────────────────────
+
+let _ = beforeAllAsync(async () => {
+  let epOutputs = ep->TestEP.outputs
+  let _ = await epOutputs.commandTopic->TestRunner.resolve
+  let _ = await epOutputs.eventTopic->TestRunner.resolve
+})
+
+describe("ExtensionPoint (in-memory)", () => {
+  let _ = beforeEach(() => resetMocks())
+
+  testPromise(
+    "dispatching Forward command calls publishToAggregates with Execute command",
+    async () => {
+      // Build the full command body: {id, meta, command}
+      let forwardCmdJson =
+        TestEPSpec.Forward({targetId: "target-1"})
+        ->S.reverseConvertToJsonOrThrow(TestEPSpec.commandSchema)
+      let body = JSON.Encode.object(
+        Dict.fromArray([
+          ("id", JSON.Encode.string("ep-id-1")),
+          ("meta", testMeta->S.reverseConvertToJsonOrThrow(Reventless.Message.metaSchema)),
+          ("command", forwardCmdJson),
+        ]),
+      )
+      // Dispatch to the EP's CommandTopic channel: Spec.name + "ExtPoint" + "CmdTopic"
+      await Bus.dispatchCommand("TestEPExtPointCmdTopic", body)
+
+      // publishToAggregates["TargetAgg"] should have been called once
+      expect(capturedCmds.contents->Array.length)->toBe(1)
+
+      let cmd = capturedCmds.contents->Array.getUnsafe(0)
+      // The aggregate command id comes from PublishCommand(targetId, ...) = "target-1"
+      expect(cmd.id)->toBe("target-1")
+
+      // commandJson should decode to Execute({targetId: "target-1"})
+      let decoded = cmd.commandJson->S.parseJsonOrThrow(DelegateAggSpec.commandSchema)
+      expect(decoded)->toEqual(DelegateAggSpec.Execute({targetId: "target-1"}))
+    },
+  )
+
+  testPromise("unknown channel dispatch does not throw or call publishToAggregates", async () => {
+    let body = JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string("x"))]))
+    await Bus.dispatchCommand("UnknownChannel", body)
+    expect(capturedCmds.contents->Array.length)->toBe(0)
+  })
+})

package/tests/components/extensionpoint/ExtensionPointTest.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as ExtensionPointFixtures$ReventlessLocal from "./ExtensionPointFixtures.res.mjs";
+
+globalThis.beforeAll(async () => {
+  let epOutputs = ExtensionPointFixtures$ReventlessLocal.TestEP.outputs(ExtensionPointFixtures$ReventlessLocal.ep);
+  await TestRunner$ReventlessLocal.resolve(epOutputs.commandTopic);
+  await TestRunner$ReventlessLocal.resolve(epOutputs.eventTopic);
+});
+
+globalThis.describe("ExtensionPoint (in-memory)", () => {
+  globalThis.beforeEach(() => ExtensionPointFixtures$ReventlessLocal.resetMocks());
+  globalThis.test("dispatching Forward command calls publishToAggregates with Execute command", async () => {
+    let forwardCmdJson = S.reverseConvertToJsonOrThrow({
+      TAG: "Forward",
+      targetId: "target-1"
+    }, ExtensionPointFixtures$ReventlessLocal.TestEPSpec.commandSchema);
+    let body = Object.fromEntries([
+      [
+        "id",
+        "ep-id-1"
+      ],
+      [
+        "meta",
+        S.reverseConvertToJsonOrThrow(ExtensionPointFixtures$ReventlessLocal.testMeta, Message$Reventless.metaSchema)
+      ],
+      [
+        "command",
+        forwardCmdJson
+      ]
+    ]);
+    await ExtensionPointFixtures$ReventlessLocal.Bus.dispatchCommand("TestEPExtPointCmdTopic", body);
+    globalThis.expect(ExtensionPointFixtures$ReventlessLocal.capturedCmds.contents.length).toBe(1);
+    let cmd = ExtensionPointFixtures$ReventlessLocal.capturedCmds.contents[0];
+    globalThis.expect(cmd.id).toBe("target-1");
+    let decoded = S.parseJsonOrThrow(cmd.commandJson, ExtensionPointFixtures$ReventlessLocal.DelegateAggSpec.commandSchema);
+    globalThis.expect(decoded).toEqual({
+      TAG: "Execute",
+      targetId: "target-1"
+    });
+  });
+  globalThis.test("unknown channel dispatch does not throw or call publishToAggregates", async () => {
+    let body = Object.fromEntries([[
+        "id",
+        "x"
+      ]]);
+    await ExtensionPointFixtures$ReventlessLocal.Bus.dispatchCommand("UnknownChannel", body);
+    globalThis.expect(ExtensionPointFixtures$ReventlessLocal.capturedCmds.contents.length).toBe(0);
+  });
+});
+
+/*  Not a pure module */

package/tests/components/heartbeat/HeartbeatFixtures.res

@@ -0,0 +1,48 @@
+// Fixtures for Heartbeat component integration tests.
+// Uses LocalHeartbeatRunner and fake timers to verify the handler fires on schedule.
+
+open TestFixtures
+open JestGlobals
+
+// Activate Pulumi mock mode (must be called before any Component.make)
+let _ = TestRunner.setup()
+
+// ─────────────────────────────────────────────────────────────
+// Build the Heartbeat component maker
+// ─────────────────────────────────────────────────────────────
+
+module HeartbeatMaker = ReventlessCore.Heartbeat_Builder.Make(LocalHeartbeatRunner)
+
+let _ = beforeAll(() => {
+  jest->useFakeTimers
+})
+
+let _ = afterAll(() => {
+  LocalHeartbeatRunner.reset()
+  jest->useRealTimers
+})
+
+// ─────────────────────────────────────────────────────────────
+// Shared state — reset in beforeEach inside describe
+// ─────────────────────────────────────────────────────────────
+
+let capturedCount: ref<int> = ref(0)
+
+let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+  capturedCount := capturedCount.contents + cmds->Array.length
+}
+
+// resolvedHandler populated in beforeAllAsync before tests run.
+// makeHandler returns eventHandler<unit, 'ctx, unit> = (unit, ctx) => promise<unit>.
+// The runtime handlerRef expects (JSON.t, unit) => promise<unit> — same in JS, safe to cast.
+let resolvedHandler: ref<option<(unit, unit) => promise<unit>>> = ref(None)
+
+let _ = beforeAllAsync(async () => {
+  let h =
+    await HeartbeatMaker.makeHandler(
+      ~id="hb-id-1",
+      ~timeout=1,
+      ~publishToPluginExtensionPoint=mockPublish,
+    )->TestRunner.resolve
+  resolvedHandler := Some(h)
+})

package/tests/components/heartbeat/HeartbeatFixtures.res.mjs

@@ -0,0 +1,46 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Globals from "@jest/globals";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as Heartbeat_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/Heartbeat/Heartbeat_Builder.res.mjs";
+import * as LocalHeartbeatRunner$ReventlessLocal from "../../../src/adapter/Heartbeat/LocalHeartbeatRunner.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let HeartbeatMaker = Heartbeat_Builder$ReventlessCore.Make({
+  make: LocalHeartbeatRunner$ReventlessLocal.make
+});
+
+globalThis.beforeAll(() => {
+  Globals.jest.useFakeTimers();
+});
+
+globalThis.afterAll(() => {
+  LocalHeartbeatRunner$ReventlessLocal.reset();
+  Globals.jest.useRealTimers();
+});
+
+let capturedCount = {
+  contents: 0
+};
+
+async function mockPublish(cmds) {
+  capturedCount.contents = capturedCount.contents + cmds.length | 0;
+}
+
+let resolvedHandler = {
+  contents: undefined
+};
+
+globalThis.beforeAll(async () => {
+  let h = await TestRunner$ReventlessLocal.resolve(HeartbeatMaker.makeHandler("hb-id-1", 1, mockPublish));
+  resolvedHandler.contents = h;
+});
+
+export {
+  HeartbeatMaker,
+  capturedCount,
+  mockPublish,
+  resolvedHandler,
+}
+/*  Not a pure module */

package/tests/components/heartbeat/HeartbeatTest.res

@@ -0,0 +1,67 @@
+// Integration tests for Heartbeat_Builder (in-memory).
+// Verifies that makeHandler returns a callable handler and connect wires the interval.
+// Adapter-level timer tests are in adapter/HeartbeatRunnerTest.res.
+
+open TestFixtures
+open JestGlobals
+open HeartbeatFixtures
+
+describe("Heartbeat_Builder.Make:", () => {
+  let _ = beforeEach(() => {
+    capturedCount := 0
+  })
+
+  describe("makeHandler + connect:", () => {
+    testPromise("handler fires once after 1-minute interval", async () => {
+      let handler = resolvedHandler.contents->Option.getUnsafe
+      let heartbeat = HeartbeatMaker.make(~name="hb-test-1")
+      let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
+        Deferred.make()->Effect.runSync
+      Deferred.succeed(handlerDeferred, Obj.magic(handler))->Effect.runSync->ignore
+      let runtime: ReventlessCore.Runtime.environment<LocalHeartbeatRunner.runtimeParts> = {
+        parts: {
+          handlerDeferred,
+          subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
+        },
+        resources: [],
+      }
+      HeartbeatMaker.connect(~runtime, ~remoteChannel=Obj.magic(()), ~timeout=1, heartbeat)
+      jest->advanceTimersByTime(1 * 60 * 1000)
+      // Give the Effect.runPromise microtask one tick to complete
+      let _ = await Promise.resolve()
+      expect(capturedCount.contents)->toBe(1)
+      LocalHeartbeatRunner.reset()
+    })
+
+    testPromise("handler fires twice after two interval advances", async () => {
+      let handler = resolvedHandler.contents->Option.getUnsafe
+      let heartbeat = HeartbeatMaker.make(~name="hb-test-2")
+      let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
+        Deferred.make()->Effect.runSync
+      Deferred.succeed(handlerDeferred, Obj.magic(handler))->Effect.runSync->ignore
+      let runtime: ReventlessCore.Runtime.environment<LocalHeartbeatRunner.runtimeParts> = {
+        parts: {
+          handlerDeferred,
+          subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
+        },
+        resources: [],
+      }
+      HeartbeatMaker.connect(~runtime, ~remoteChannel=Obj.magic(()), ~timeout=1, heartbeat)
+      jest->advanceTimersByTime(1 * 60 * 1000)
+      let _ = await Promise.resolve()
+      jest->advanceTimersByTime(1 * 60 * 1000)
+      let _ = await Promise.resolve()
+      expect(capturedCount.contents)->toBe(2)
+      LocalHeartbeatRunner.reset()
+    })
+  })
+
+  describe("make:", () => {
+    testPromise("creates a heartbeat component without throwing", async () => {
+      let heartbeat = HeartbeatMaker.make(~name="hb-make-smoke")
+      // Just verify component creation succeeds
+      let _ = heartbeat
+      expect(true)->toBe(true)
+    })
+  })
+})

package/tests/components/heartbeat/HeartbeatTest.res.mjs

@@ -0,0 +1,65 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Globals from "@jest/globals";
+import * as Effect from "effect/Effect";
+import * as Deferred from "effect/Deferred";
+import * as HeartbeatFixtures$ReventlessLocal from "./HeartbeatFixtures.res.mjs";
+import * as LocalHeartbeatRunner$ReventlessLocal from "../../../src/adapter/Heartbeat/LocalHeartbeatRunner.res.mjs";
+
+globalThis.describe("Heartbeat_Builder.Make:", () => {
+  globalThis.beforeEach(() => {
+    HeartbeatFixtures$ReventlessLocal.capturedCount.contents = 0;
+  });
+  globalThis.describe("makeHandler + connect:", () => {
+    globalThis.test("handler fires once after 1-minute interval", async () => {
+      let handler = HeartbeatFixtures$ReventlessLocal.resolvedHandler.contents;
+      let heartbeat = HeartbeatFixtures$ReventlessLocal.HeartbeatMaker.make("hb-test-1", undefined);
+      let handlerDeferred = Effect.runSync(Deferred.make());
+      Effect.runSync(Deferred.succeed(handlerDeferred, handler));
+      let runtime_parts = {
+        handlerDeferred: handlerDeferred,
+        subscriptionLatch: Effect.runSync(Effect.makeLatch(false))
+      };
+      let runtime_resources = [];
+      let runtime = {
+        parts: runtime_parts,
+        resources: runtime_resources
+      };
+      HeartbeatFixtures$ReventlessLocal.HeartbeatMaker.connect(runtime, undefined, 1, heartbeat);
+      Globals.jest.advanceTimersByTime(60000);
+      await Promise.resolve();
+      globalThis.expect(HeartbeatFixtures$ReventlessLocal.capturedCount.contents).toBe(1);
+      return LocalHeartbeatRunner$ReventlessLocal.reset();
+    });
+    globalThis.test("handler fires twice after two interval advances", async () => {
+      let handler = HeartbeatFixtures$ReventlessLocal.resolvedHandler.contents;
+      let heartbeat = HeartbeatFixtures$ReventlessLocal.HeartbeatMaker.make("hb-test-2", undefined);
+      let handlerDeferred = Effect.runSync(Deferred.make());
+      Effect.runSync(Deferred.succeed(handlerDeferred, handler));
+      let runtime_parts = {
+        handlerDeferred: handlerDeferred,
+        subscriptionLatch: Effect.runSync(Effect.makeLatch(false))
+      };
+      let runtime_resources = [];
+      let runtime = {
+        parts: runtime_parts,
+        resources: runtime_resources
+      };
+      HeartbeatFixtures$ReventlessLocal.HeartbeatMaker.connect(runtime, undefined, 1, heartbeat);
+      Globals.jest.advanceTimersByTime(60000);
+      await Promise.resolve();
+      Globals.jest.advanceTimersByTime(60000);
+      await Promise.resolve();
+      globalThis.expect(HeartbeatFixtures$ReventlessLocal.capturedCount.contents).toBe(2);
+      return LocalHeartbeatRunner$ReventlessLocal.reset();
+    });
+  });
+  globalThis.describe("make:", () => {
+    globalThis.test("creates a heartbeat component without throwing", async () => {
+      HeartbeatFixtures$ReventlessLocal.HeartbeatMaker.make("hb-make-smoke", undefined);
+      globalThis.expect(true).toBe(true);
+    });
+  });
+});
+
+/*  Not a pure module */