@reventlessdev/reventless-core 3.0.0-alpha.260 → 3.0.0-alpha.261

package/tests/sideeffecthandler/SideEffectHandlerCallbackTest.res

@@ -5,52 +5,67 @@ let _ = beforeEach(() => reset())
 
 describe("SideEffectHandler_Callback.handleJsonEvents:", () => {
   describe("event matching registered side effect", () => {
-    testPromise("execute called with decoded id and event", async () => {
-      let event = TestSource.SomethingHappened({value: "hello"})
-      let eventJson = makeEventJson("entity-1", event)
-      await TestHandler.handleJsonEvents(Stream.fromIterable([eventJson]))->Effect.runPromise
-      let call = capturedExecuteCalls.contents->Array.getUnsafe(0)
-      expect((call.id, call.event))->toEqual(("entity-1", event))
-    })
+    testPromise(
+      "execute called with decoded id and event",
+      async () => {
+        let event = TestSource.SomethingHappened({value: "hello"})
+        let eventJson = makeEventJson("entity-1", event)
+        await TestHandler.handleJsonEvents(Stream.fromIterable([eventJson]))->Effect.runPromise
+        let call = capturedExecuteCalls.contents->Array.getUnsafe(0)
+        expect((call.id, call.event))->toEqual(("entity-1", event))
+      },
+    )
   })
 
   describe("event with no matching source name", () => {
-    testPromise("execute not called, no error", async () => {
-      let event = TestSource.SomethingHappened({value: "ignored"})
-      let eventJson = makeEventJson(~service="UnknownService", "entity-1", event)
-      await TestHandler.handleJsonEvents(Stream.fromIterable([eventJson]))->Effect.runPromise
-      expect(capturedExecuteCalls.contents->Array.length)->toBe(0)
-    })
+    testPromise(
+      "execute not called, no error",
+      async () => {
+        let event = TestSource.SomethingHappened({value: "ignored"})
+        let eventJson = makeEventJson(~service="UnknownService", "entity-1", event)
+        await TestHandler.handleJsonEvents(Stream.fromIterable([eventJson]))->Effect.runPromise
+        expect(capturedExecuteCalls.contents->Array.length)->toBe(0)
+      },
+    )
   })
 
   describe("event with malformed JSON", () => {
-    testPromise("caught gracefully — does not throw, execute not called", async () => {
-      let invalidJson = JSON.Encode.string("not-an-object")
-      await TestHandler.handleJsonEvents(Stream.fromIterable([invalidJson]))->Effect.runPromise
-      expect(capturedExecuteCalls.contents->Array.length)->toBe(0)
-    })
+    testPromise(
+      "caught gracefully — does not throw, execute not called",
+      async () => {
+        let invalidJson = JSON.Encode.string("not-an-object")
+        await TestHandler.handleJsonEvents(Stream.fromIterable([invalidJson]))->Effect.runPromise
+        expect(capturedExecuteCalls.contents->Array.length)->toBe(0)
+      },
+    )
   })
 
   describe("execute throws", () => {
-    testPromise("error caught per-event, other events still processed", async () => {
-      // First event causes execute to throw; second event processes normally
-      executeThrowOnCall := 1
-      let event = TestSource.SomethingHappened({value: "v"})
-      let event1 = makeEventJson("entity-1", event)
-      let event2 = makeEventJson("entity-2", event)
-      await TestHandler.handleJsonEvents(Stream.fromIterable([event1, event2]))->Effect.runPromise
-      // entity-2 should still be captured (first event threw)
-      expect(capturedExecuteCalls.contents->Array.length)->toBe(1)
-      expect((capturedExecuteCalls.contents->Array.getUnsafe(0)).id)->toBe("entity-2")
-    })
+    testPromise(
+      "error caught per-event, other events still processed",
+      async () => {
+        // First event causes execute to throw; second event processes normally
+        executeThrowOnCall := 1
+        let event = TestSource.SomethingHappened({value: "v"})
+        let event1 = makeEventJson("entity-1", event)
+        let event2 = makeEventJson("entity-2", event)
+        await TestHandler.handleJsonEvents(Stream.fromIterable([event1, event2]))->Effect.runPromise
+        // entity-2 should still be captured (first event threw)
+        expect(capturedExecuteCalls.contents->Array.length)->toBe(1)
+        expect((capturedExecuteCalls.contents->Array.getUnsafe(0)).id)->toBe("entity-2")
+      },
+    )
   })
 
   describe("multiple events in batch", () => {
-    testPromise("each handled independently", async () => {
-      let event = TestSource.SomethingHappened({value: "v"})
-      let events = ["entity-1", "entity-2", "entity-3"]->Array.map(id => makeEventJson(id, event))
-      await TestHandler.handleJsonEvents(Stream.fromIterable(events))->Effect.runPromise
-      expect(capturedExecuteCalls.contents->Array.length)->toBe(3)
-    })
+    testPromise(
+      "each handled independently",
+      async () => {
+        let event = TestSource.SomethingHappened({value: "v"})
+        let events = ["entity-1", "entity-2", "entity-3"]->Array.map(id => makeEventJson(id, event))
+        await TestHandler.handleJsonEvents(Stream.fromIterable(events))->Effect.runPromise
+        expect(capturedExecuteCalls.contents->Array.length)->toBe(3)
+      },
+    )
   })
 })

package/tests/sideeffecthandler/SideEffectHandlerFixtures.res

@@ -1,4 +1,3 @@
-
 // ─────────────────────────────────────────────────────────────
 // Event source spec for SideEffect
 // ─────────────────────────────────────────────────────────────
@@ -8,7 +7,7 @@ module TestSource = {
   let name = "TestSideEffectSource"
 
   @schema
-  type event = | SomethingHappened({value: string})
+  type event = SomethingHappened({value: string})
 }
 
 // ─────────────────────────────────────────────────────────────
@@ -18,7 +17,7 @@ module TestSource = {
 type executeCall = {id: string, event: TestSource.event}
 
 let capturedExecuteCalls: ref<array<executeCall>> = ref([])
-let executeThrowOnCall = ref(0)  // throw on this call number (1-based); 0 = never throw
+let executeThrowOnCall = ref(0) // throw on this call number (1-based); 0 = never throw
 let executeCallCount = ref(0)
 
 // ─────────────────────────────────────────────────────────────
@@ -35,9 +34,7 @@ module TestSideEffect: Reventless.SideEffect.T = {
       JsError.throwWithMessage("side effect failed")
     }
     capturedExecuteCalls :=
-      capturedExecuteCalls.contents->Array.concat([
-        {id: id->TestSource.Id.toString, event},
-      ])
+      capturedExecuteCalls.contents->Array.concat([{id: id->TestSource.Id.toString, event}])
   }
 }
 
@@ -79,10 +76,7 @@ let testMeta: Message.meta = {
 let makeEventJson = (~service=TestSource.name, id, event): JSON.t =>
   [
     ("id", JSON.Encode.string(id)),
-    (
-      "meta",
-      {...testMeta, service: service}->Message.encode(Message.metaSchema),
-    ),
+    ("meta", {...testMeta, service}->Message.encode(Message.metaSchema)),
     ("event", event->Message.encode(TestSource.eventSchema)),
   ]
   ->Dict.fromArray

package/tests/util/CommandPublisherTest.res

@@ -11,7 +11,6 @@
 
 open JestGlobals
 
-
 let published: ref<array<Reventless.Message.commandJson>> = ref([])
 
 module TestSpec = {

package/tests/util/CsvStreamTest.res

@@ -37,9 +37,9 @@ describe("CsvStream.parseRows", () => {
       ->Array.join("\n")
     let path = writeTempCsv("name\n" ++ dataRows)
     let result = await CsvStream.parseRows(~path)
-      ->Stream.take(2)
-      ->Stream.runCollect
-      ->Effect.runPromise
+    ->Stream.take(2)
+    ->Stream.runCollect
+    ->Effect.runPromise
     expect(result->Array.length)->toBe(2)
   })
 

package/tests/util/LruTest.res

@@ -2,72 +2,100 @@ open JestGlobals
 
 describe("Lru:", () => {
   describe("get / put", () => {
-    testSync("get on an empty cache misses", () => {
-      let cache = Lru.make(~capacity=2)
-      expect(cache->Lru.get("a"))->toEqual(None)
-    })
+    testSync(
+      "get on an empty cache misses",
+      () => {
+        let cache = Lru.make(~capacity=2)
+        expect(cache->Lru.get("a"))->toEqual(None)
+      },
+    )
 
-    testSync("put then get returns the stored value", () => {
-      let cache = Lru.make(~capacity=2)
-      cache->Lru.put("a", 1)
-      expect(cache->Lru.get("a"))->toEqual(Some(1))
-    })
+    testSync(
+      "put then get returns the stored value",
+      () => {
+        let cache = Lru.make(~capacity=2)
+        cache->Lru.put("a", 1)
+        expect(cache->Lru.get("a"))->toEqual(Some(1))
+      },
+    )
 
-    testSync("put on an existing key overwrites", () => {
-      let cache = Lru.make(~capacity=2)
-      cache->Lru.put("a", 1)
-      cache->Lru.put("a", 2)
-      expect((cache->Lru.get("a"), cache->Lru.size))->toEqual((Some(2), 1))
-    })
+    testSync(
+      "put on an existing key overwrites",
+      () => {
+        let cache = Lru.make(~capacity=2)
+        cache->Lru.put("a", 1)
+        cache->Lru.put("a", 2)
+        expect((cache->Lru.get("a"), cache->Lru.size))->toEqual((Some(2), 1))
+      },
+    )
 
-    testSync("invalidate removes a key", () => {
-      let cache = Lru.make(~capacity=2)
-      cache->Lru.put("a", 1)
-      cache->Lru.invalidate("a")
-      expect((cache->Lru.get("a"), cache->Lru.size))->toEqual((None, 0))
-    })
+    testSync(
+      "invalidate removes a key",
+      () => {
+        let cache = Lru.make(~capacity=2)
+        cache->Lru.put("a", 1)
+        cache->Lru.invalidate("a")
+        expect((cache->Lru.get("a"), cache->Lru.size))->toEqual((None, 0))
+      },
+    )
   })
 
   describe("eviction", () => {
-    testSync("evicts the least-recently-used entry past capacity", () => {
-      let cache = Lru.make(~capacity=2)
-      cache->Lru.put("a", 1)
-      cache->Lru.put("b", 2)
-      cache->Lru.put("c", 3) // evicts "a" (oldest)
-      expect((cache->Lru.get("a"), cache->Lru.get("b"), cache->Lru.get("c"), cache->Lru.size))->toEqual((
-        None,
-        Some(2),
-        Some(3),
-        2,
-      ))
-    })
+    testSync(
+      "evicts the least-recently-used entry past capacity",
+      () => {
+        let cache = Lru.make(~capacity=2)
+        cache->Lru.put("a", 1)
+        cache->Lru.put("b", 2)
+        cache->Lru.put("c", 3) // evicts "a" (oldest)
+        expect((
+          cache->Lru.get("a"),
+          cache->Lru.get("b"),
+          cache->Lru.get("c"),
+          cache->Lru.size,
+        ))->toEqual((None, Some(2), Some(3), 2))
+      },
+    )
 
-    testSync("get refreshes recency so a touched key survives eviction", () => {
-      let cache = Lru.make(~capacity=2)
-      cache->Lru.put("a", 1)
-      cache->Lru.put("b", 2)
-      let _ = cache->Lru.get("a") // "a" is now most-recently-used
-      cache->Lru.put("c", 3) // evicts "b", not "a"
-      expect((cache->Lru.get("a"), cache->Lru.get("b"), cache->Lru.get("c")))->toEqual((
-        Some(1),
-        None,
-        Some(3),
-      ))
-    })
+    testSync(
+      "get refreshes recency so a touched key survives eviction",
+      () => {
+        let cache = Lru.make(~capacity=2)
+        cache->Lru.put("a", 1)
+        cache->Lru.put("b", 2)
+        let _ = cache->Lru.get("a") // "a" is now most-recently-used
+        cache->Lru.put("c", 3) // evicts "b", not "a"
+        expect((cache->Lru.get("a"), cache->Lru.get("b"), cache->Lru.get("c")))->toEqual((
+          Some(1),
+          None,
+          Some(3),
+        ))
+      },
+    )
 
-    testSync("101 distinct keys against capacity 100 keeps exactly 100", () => {
-      let cache = Lru.make(~capacity=100)
-      // 101 distinct keys: 0..100 inclusive.
-      Array.fromInitializer(~length=101, i => i)->Array.forEach(i => cache->Lru.put(i, i))
-      expect((cache->Lru.size, cache->Lru.get(0), cache->Lru.get(100)))->toEqual((100, None, Some(100)))
-    })
+    testSync(
+      "101 distinct keys against capacity 100 keeps exactly 100",
+      () => {
+        let cache = Lru.make(~capacity=100)
+        // 101 distinct keys: 0..100 inclusive.
+        Array.fromInitializer(~length=101, i => i)->Array.forEach(i => cache->Lru.put(i, i))
+        expect((cache->Lru.size, cache->Lru.get(0), cache->Lru.get(100)))->toEqual((
+          100,
+          None,
+          Some(100),
+        ))
+      },
+    )
   })
 
   describe("disabled cache (capacity <= 0)", () => {
-    testSync("never stores", () => {
-      let cache = Lru.make(~capacity=0)
-      cache->Lru.put("a", 1)
-      expect((cache->Lru.get("a"), cache->Lru.size))->toEqual((None, 0))
-    })
+    testSync(
+      "never stores",
+      () => {
+        let cache = Lru.make(~capacity=0)
+        cache->Lru.put("a", 1)
+        expect((cache->Lru.get("a"), cache->Lru.size))->toEqual((None, 0))
+      },
+    )
   })
 })