@reventlessdev/reventless-local 3.0.0-alpha.249 → 3.0.0-alpha.251

package/tests/adapter/CommandTopicChannelTest.res

@@ -16,159 +16,183 @@ let testMeta: Reventless.Message.meta = {
 
 describe("LocalCommandTopicChannel", () => {
   describe("encodeCommandJson", () => {
-    testPromise("produces {id, meta, command} JSON shape", async () => {
-      let cmdJson: Reventless.Message.commandJson = {
-        id: "agg-1",
-        meta: testMeta,
-        commandJson: JSON.Encode.string("DoSomething"),
-      }
-      let encoded = ReventlessCore.CommandTopic.encodeCommandJson(cmdJson)
-      let dict = switch encoded {
-      | JSON.Object(d) => d
-      | _ => Dict.make()
-      }
-      expect(dict->Dict.get("id"))->toEqual(Some(JSON.Encode.string("agg-1")))
-      expect(dict->Dict.get("command"))->toEqual(Some(JSON.Encode.string("DoSomething")))
-      expect(dict->Dict.get("meta")->Option.isSome)->toBe(true)
-    })
+    testPromise(
+      "produces {id, meta, command} JSON shape",
+      async () => {
+        let cmdJson: Reventless.Message.commandJson = {
+          id: "agg-1",
+          meta: testMeta,
+          commandJson: JSON.Encode.string("DoSomething"),
+        }
+        let encoded = ReventlessCore.CommandTopic.encodeCommandJson(cmdJson)
+        let dict = switch encoded {
+        | JSON.Object(d) => d
+        | _ => Dict.make()
+        }
+        expect(dict->Dict.get("id"))->toEqual(Some(JSON.Encode.string("agg-1")))
+        expect(dict->Dict.get("command"))->toEqual(Some(JSON.Encode.string("DoSomething")))
+        expect(dict->Dict.get("meta")->Option.isSome)->toBe(true)
+      },
+    )
   })
 
   describe("decodeId", () => {
-    testPromise("extracts id string from encoded message body", async () => {
-      module TestBus = LocalBus.Make()
-      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
-      let body = JSON.Encode.object(
-        Dict.fromArray([("id", JSON.Encode.string("agg-42"))]),
-      )
-      expect(TestChannel.decodeId(body))->toBe("agg-42")
-    })
+    testPromise(
+      "extracts id string from encoded message body",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+        let body = JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string("agg-42"))]))
+        expect(TestChannel.decodeId(body))->toBe("agg-42")
+      },
+    )
 
-    testPromise("returns empty string for non-object input", async () => {
-      module TestBus = LocalBus.Make()
-      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
-      expect(TestChannel.decodeId(JSON.Encode.string("not-an-object")))->toBe("")
-    })
+    testPromise(
+      "returns empty string for non-object input",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+        expect(TestChannel.decodeId(JSON.Encode.string("not-an-object")))->toBe("")
+      },
+    )
 
-    testPromise("returns empty string when id field is missing", async () => {
-      module TestBus = LocalBus.Make()
-      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
-      let body = JSON.Encode.object(Dict.fromArray([("other", JSON.Encode.int(1))]))
-      expect(TestChannel.decodeId(body))->toBe("")
-    })
+    testPromise(
+      "returns empty string when id field is missing",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+        let body = JSON.Encode.object(Dict.fromArray([("other", JSON.Encode.int(1))]))
+        expect(TestChannel.decodeId(body))->toBe("")
+      },
+    )
 
-    testPromise("returns empty string when id field is not a string", async () => {
-      module TestBus = LocalBus.Make()
-      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
-      let body = JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.int(99))]))
-      expect(TestChannel.decodeId(body))->toBe("")
-    })
+    testPromise(
+      "returns empty string when id field is not a string",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+        let body = JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.int(99))]))
+        expect(TestChannel.decodeId(body))->toBe("")
+      },
+    )
   })
 
   describe("publishJsons", () => {
-    testPromise("dispatches each command to the bus with full {id, meta, command} body", async () => {
-      module TestBus = LocalBus.Make()
-      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
-      let received: ref<option<JSON.t>> = ref(None)
-      TestBus.registerCommandHandler("myCmd", async (json, _) => {
-        received := Some(json)
-      })
-      let ch = TestChannel.make(~name="myCmd", ~owner=None)
-      let publishFn = await ch.publishJsons->TestRunner.resolve
-      await publishFn([
-        {
-          Reventless.Message.id: "item-1",
-          meta: testMeta,
-          commandJson: JSON.Encode.string("CreateItem"),
-        },
-      ])
-      let receivedJson = received.contents->Option.getOr(JSON.Null)
-      let receivedDict = switch receivedJson {
-      | JSON.Object(d) => d
-      | _ => Dict.make()
-      }
-      expect(receivedDict->Dict.get("id"))->toEqual(Some(JSON.Encode.string("item-1")))
-    })
+    testPromise(
+      "dispatches each command to the bus with full {id, meta, command} body",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+        let received: ref<option<JSON.t>> = ref(None)
+        TestBus.registerCommandHandler(
+          "myCmd",
+          async (json, _) => {
+            received := Some(json)
+          },
+        )
+        let ch = TestChannel.make(~name="myCmd", ~owner=None)
+        let publishFn = await ch.publishJsons->TestRunner.resolve
+        await publishFn([
+          {
+            Reventless.Message.id: "item-1",
+            meta: testMeta,
+            commandJson: JSON.Encode.string("CreateItem"),
+          },
+        ])
+        let receivedJson = received.contents->Option.getOr(JSON.Null)
+        let receivedDict = switch receivedJson {
+        | JSON.Object(d) => d
+        | _ => Dict.make()
+        }
+        expect(receivedDict->Dict.get("id"))->toEqual(Some(JSON.Encode.string("item-1")))
+      },
+    )
 
-    testPromise("dispatches multiple commands in order", async () => {
-      module TestBus = LocalBus.Make()
-      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
-      let count: ref<int> = ref(0)
-      TestBus.registerCommandHandler("multiCmd", async (_, _) => {
-        count := count.contents + 1
-      })
-      let ch = TestChannel.make(~name="multiCmd", ~owner=None)
-      let publishFn = await ch.publishJsons->TestRunner.resolve
-      await publishFn([
-        {
-          Reventless.Message.id: "id-1",
-          meta: testMeta,
-          commandJson: JSON.Null,
-        },
-        {
-          Reventless.Message.id: "id-2",
-          meta: testMeta,
-          commandJson: JSON.Null,
-        },
-      ])
-      expect(count.contents)->toBe(2)
-    })
+    testPromise(
+      "dispatches multiple commands in order",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+        let count: ref<int> = ref(0)
+        TestBus.registerCommandHandler(
+          "multiCmd",
+          async (_, _) => {
+            count := count.contents + 1
+          },
+        )
+        let ch = TestChannel.make(~name="multiCmd", ~owner=None)
+        let publishFn = await ch.publishJsons->TestRunner.resolve
+        await publishFn([
+          {
+            Reventless.Message.id: "id-1",
+            meta: testMeta,
+            commandJson: JSON.Null,
+          },
+          {
+            Reventless.Message.id: "id-2",
+            meta: testMeta,
+            commandJson: JSON.Null,
+          },
+        ])
+        expect(count.contents)->toBe(2)
+      },
+    )
   })
 
   describe("connect", () => {
-    testPromise("registers handler; dispatch reaches the runtime handlerDeferred", async () => {
-      module TestBus = LocalBus.Make()
-      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
-      let received: ref<option<JSON.t>> = ref(None)
-      let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
-        Deferred.make()->Effect.runSync
-      Deferred.succeed(handlerDeferred, async (json, _ctx) => {
-        received := Some(json)
-      })->Effect.runSync->ignore
-      let runtime: ReventlessCore.Runtime.environment<LocalRuntimeEnvironment.parts> = {
-        parts: {
+    testPromise(
+      "registers handler; dispatch reaches the runtime handlerDeferred",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+        let received: ref<option<JSON.t>> = ref(None)
+        let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
+          Deferred.make()->Effect.runSync
+        Deferred.succeed(
           handlerDeferred,
-          subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
-        },
-        resources: [],
-      }
-      let ch = TestChannel.make(~name="testCmd", ~owner=None)
-      let _ = ch.connect(
-        ~name="testCmd",
-        ~channel=ch,
-        ~runtime,
-        ~resources=[],
-        ~opts={},
-      )
-      await TestBus.dispatchCommand("testCmd", JSON.Encode.string("test-payload"))
-      expect(received.contents)->toEqual(Some(JSON.Encode.string("test-payload")))
-    })
+          async (json, _ctx) => {
+            received := Some(json)
+          },
+        )
+        ->Effect.runSync
+        ->ignore
+        let runtime: ReventlessCore.Runtime.environment<LocalRuntimeEnvironment.parts> = {
+          parts: {
+            handlerDeferred,
+            subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
+          },
+          resources: [],
+        }
+        let ch = TestChannel.make(~name="testCmd", ~owner=None)
+        let _ = ch.connect(~name="testCmd", ~channel=ch, ~runtime, ~resources=[], ~opts={})
+        await TestBus.dispatchCommand("testCmd", JSON.Encode.string("test-payload"))
+        expect(received.contents)->toEqual(Some(JSON.Encode.string("test-payload")))
+      },
+    )
 
-    testPromise("unresolved Deferred does not crash on dispatch", async () => {
-      module TestBus = LocalBus.Make()
-      module TestChannel = LocalCommandTopicChannel.Make(TestBus)
-      // Deferred left incomplete — dispatch starts a pending Effect (no crash)
-      let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
-        Deferred.make()->Effect.runSync
-      let runtime: ReventlessCore.Runtime.environment<LocalRuntimeEnvironment.parts> = {
-        parts: {
-          handlerDeferred,
-          subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
-        },
-        resources: [],
-      }
-      let ch = TestChannel.make(~name="noHandlerCmd", ~owner=None)
-      let _ = ch.connect(
-        ~name="noHandlerCmd",
-        ~channel=ch,
-        ~runtime,
-        ~resources=[],
-        ~opts={},
-      )
-      // Fire-and-forget — the Deferred.await_ will stay pending
-      TestBus.dispatchCommand("noHandlerCmd", JSON.Null)->ignore
-      expect(true)->toBe(true)
-      // Complete the Deferred to avoid open handle
-      Deferred.succeed(handlerDeferred, async (_, _) => ())->Effect.runSync->ignore
-    })
+    testPromise(
+      "unresolved Deferred does not crash on dispatch",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestChannel = LocalCommandTopicChannel.Make(TestBus)
+        // Deferred left incomplete — dispatch starts a pending Effect (no crash)
+        let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
+          Deferred.make()->Effect.runSync
+        let runtime: ReventlessCore.Runtime.environment<LocalRuntimeEnvironment.parts> = {
+          parts: {
+            handlerDeferred,
+            subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
+          },
+          resources: [],
+        }
+        let ch = TestChannel.make(~name="noHandlerCmd", ~owner=None)
+        let _ = ch.connect(~name="noHandlerCmd", ~channel=ch, ~runtime, ~resources=[], ~opts={})
+        // Fire-and-forget — the Deferred.await_ will stay pending
+        TestBus.dispatchCommand("noHandlerCmd", JSON.Null)->ignore
+        expect(true)->toBe(true)
+        // Complete the Deferred to avoid open handle
+        Deferred.succeed(handlerDeferred, async (_, _) => ())->Effect.runSync->ignore
+      },
+    )
   })
 })

package/tests/adapter/CounterHandlerTest.res

@@ -14,10 +14,10 @@ let makeHandler = () =>
   LocalCounterHandler.make(
     ~name="counter",
     ~referencesName="refs",
-    ~referencesDb=Obj.magic(()),
+    ~referencesDb=Obj.magic(),
     ~countsName="counts",
-    ~countsDb=Obj.magic(()),
-    ~counterHandler=Obj.magic(()),
+    ~countsDb=Obj.magic(),
+    ~counterHandler=Obj.magic(),
     ~specModulePath="",
     ~mappingsModulePath="",
     ~publishChannelId=Pulumi.Output.make(""),
@@ -26,88 +26,106 @@ let makeHandler = () =>
 
 describe("LocalCounterHandler", () => {
   describe("addToCounterTarget", () => {
-    testPromise("increments counter by target amount", async () => {
-      let handler = makeHandler()
-      await handler.addToCounterTarget({
-        ReventlessInfra.Counter.counterId: "likes",
-        target: 3,
-        targetRef: "ref-1",
-      })
-      expect(LocalCounterHandler.getCount("likes"))->toBe(3)
-    })
+    testPromise(
+      "increments counter by target amount",
+      async () => {
+        let handler = makeHandler()
+        await handler.addToCounterTarget({
+          ReventlessInfra.Counter.counterId: "likes",
+          target: 3,
+          targetRef: "ref-1",
+        })
+        expect(LocalCounterHandler.getCount("likes"))->toBe(3)
+      },
+    )
 
-    testPromise("same (counterId, targetRef) pair is counted only once", async () => {
-      let handler = makeHandler()
-      await handler.addToCounterTarget({
-        ReventlessInfra.Counter.counterId: "likes",
-        target: 5,
-        targetRef: "ref-dup",
-      })
-      // Duplicate — should be ignored
-      await handler.addToCounterTarget({
-        ReventlessInfra.Counter.counterId: "likes",
-        target: 5,
-        targetRef: "ref-dup",
-      })
-      expect(LocalCounterHandler.getCount("likes"))->toBe(5)
-    })
+    testPromise(
+      "same (counterId, targetRef) pair is counted only once",
+      async () => {
+        let handler = makeHandler()
+        await handler.addToCounterTarget({
+          ReventlessInfra.Counter.counterId: "likes",
+          target: 5,
+          targetRef: "ref-dup",
+        })
+        // Duplicate — should be ignored
+        await handler.addToCounterTarget({
+          ReventlessInfra.Counter.counterId: "likes",
+          target: 5,
+          targetRef: "ref-dup",
+        })
+        expect(LocalCounterHandler.getCount("likes"))->toBe(5)
+      },
+    )
 
-    testPromise("different targetRef values for same counterId accumulate", async () => {
-      let handler = makeHandler()
-      await handler.addToCounterTarget({
-        ReventlessInfra.Counter.counterId: "views",
-        target: 2,
-        targetRef: "ref-a",
-      })
-      await handler.addToCounterTarget({
-        ReventlessInfra.Counter.counterId: "views",
-        target: 3,
-        targetRef: "ref-b",
-      })
-      expect(LocalCounterHandler.getCount("views"))->toBe(5)
-    })
+    testPromise(
+      "different targetRef values for same counterId accumulate",
+      async () => {
+        let handler = makeHandler()
+        await handler.addToCounterTarget({
+          ReventlessInfra.Counter.counterId: "views",
+          target: 2,
+          targetRef: "ref-a",
+        })
+        await handler.addToCounterTarget({
+          ReventlessInfra.Counter.counterId: "views",
+          target: 3,
+          targetRef: "ref-b",
+        })
+        expect(LocalCounterHandler.getCount("views"))->toBe(5)
+      },
+    )
 
-    testPromise("multiple counters are tracked independently", async () => {
-      let handler = makeHandler()
-      await handler.addToCounterTarget({
-        ReventlessInfra.Counter.counterId: "alpha",
-        target: 10,
-        targetRef: "r1",
-      })
-      await handler.addToCounterTarget({
-        ReventlessInfra.Counter.counterId: "beta",
-        target: 7,
-        targetRef: "r1",
-      })
-      expect(LocalCounterHandler.getCount("alpha"))->toBe(10)
-      expect(LocalCounterHandler.getCount("beta"))->toBe(7)
-    })
+    testPromise(
+      "multiple counters are tracked independently",
+      async () => {
+        let handler = makeHandler()
+        await handler.addToCounterTarget({
+          ReventlessInfra.Counter.counterId: "alpha",
+          target: 10,
+          targetRef: "r1",
+        })
+        await handler.addToCounterTarget({
+          ReventlessInfra.Counter.counterId: "beta",
+          target: 7,
+          targetRef: "r1",
+        })
+        expect(LocalCounterHandler.getCount("alpha"))->toBe(10)
+        expect(LocalCounterHandler.getCount("beta"))->toBe(7)
+      },
+    )
   })
 
   describe("getCount", () => {
-    testPromise("returns 0 for unknown counterId", async () => {
-      expect(LocalCounterHandler.getCount("no-such-counter"))->toBe(0)
-    })
+    testPromise(
+      "returns 0 for unknown counterId",
+      async () => {
+        expect(LocalCounterHandler.getCount("no-such-counter"))->toBe(0)
+      },
+    )
   })
 
   describe("reset", () => {
-    testPromise("clears all counter values and deduplication state", async () => {
-      let handler = makeHandler()
-      await handler.addToCounterTarget({
-        ReventlessInfra.Counter.counterId: "x",
-        target: 99,
-        targetRef: "ref-x",
-      })
-      expect(LocalCounterHandler.getCount("x"))->toBe(99)
-      LocalCounterHandler.reset()
-      expect(LocalCounterHandler.getCount("x"))->toBe(0)
-      // After reset, the same (counterId, targetRef) pair should count again
-      await handler.addToCounterTarget({
-        ReventlessInfra.Counter.counterId: "x",
-        target: 99,
-        targetRef: "ref-x",
-      })
-      expect(LocalCounterHandler.getCount("x"))->toBe(99)
-    })
+    testPromise(
+      "clears all counter values and deduplication state",
+      async () => {
+        let handler = makeHandler()
+        await handler.addToCounterTarget({
+          ReventlessInfra.Counter.counterId: "x",
+          target: 99,
+          targetRef: "ref-x",
+        })
+        expect(LocalCounterHandler.getCount("x"))->toBe(99)
+        LocalCounterHandler.reset()
+        expect(LocalCounterHandler.getCount("x"))->toBe(0)
+        // After reset, the same (counterId, targetRef) pair should count again
+        await handler.addToCounterTarget({
+          ReventlessInfra.Counter.counterId: "x",
+          target: 99,
+          targetRef: "ref-x",
+        })
+        expect(LocalCounterHandler.getCount("x"))->toBe(99)
+      },
+    )
   })
 })