Test that processEventBatch correctly wires eventOrigin through to handlers

Author: Segfaultd

scenarios/test_codegen/src/EventHandlers.res

@@ -141,11 +141,13 @@ Handlers.Gravatar.TestEvent.handler(async _ => {
   ()
 })
 
-// Test eventOrigin accessibility
+// Test eventOrigin accessibility - exposed for testing
+let lastEmptyEventOrigin: ref<option<Internal.eventOrigin>> = ref(None)
+
 Handlers.Gravatar.EmptyEvent.handler(async ({context}) => {
   // This handler tests that eventOrigin is accessible in the context
   // It will be Historical during sync and Live during live indexing
-  let _origin = context.eventOrigin
+  lastEmptyEventOrigin := Some(context.eventOrigin)
   // Log it so we can verify it's working
   switch context.eventOrigin {
   | Historical => context.log.debug("Processing historical event")

scenarios/test_codegen/test/EventOriginDetection_test.res

@@ -174,53 +174,186 @@ describe("EventOrigin Detection Logic", () => {
   })
 
   describe("eventOrigin determination in processEventBatch", () => {
-    it("should be Historical when chains have not reached end block", () => {
-      // This test verifies the logic:
-      // eventOrigin = if chainFetchers->allChainsEventsProcessedToEndblock { Live } else { Historical }
+    // These tests actually invoke EventProcessing.processEventBatch and verify
+    // that it correctly passes eventOrigin to handlers based on chainFetchers state
 
+    Async.it("should pass Historical when chains have not reached end block", async () => {
+      EventHandlers.lastEmptyEventOrigin := None
+
+      // Setup: chain has NOT reached its end block (500 < 1000)
       let chainFetcher = {
         "committedProgressBlockNumber": 500,
-        "fetchState": {
-          "endBlock": Some(1000),
-        },
+        "fetchState": {"endBlock": Some(1000)},
       }->Utils.magic
+      let chainFetchers = ChainMap.fromArrayUnsafe([(ChainMap.Chain.makeUnsafe(~chainId=54321), chainFetcher)])
+
+      let config = RegisterHandlers.registerAllHandlers()
+      let inMemoryStore = InMemoryStore.make()
+      let loadManager = LoadManager.make()
+
+      // Create an EmptyEvent that will trigger our handler
+      let emptyEventLog: Types.eventLog<Types.Gravatar.EmptyEvent.eventArgs> = {
+        params: (),
+        chainId: 54321,
+        srcAddress: "0xabc0000000000000000000000000000000000000"->Address.Evm.fromStringOrThrow,
+        logIndex: 1,
+        transaction: MockEvents.tx1,
+        block: MockEvents.block1,
+      }
 
-      let chainFetchers = ChainMap.fromArrayUnsafe([(ChainMap.Chain.makeUnsafe(~chainId=1), chainFetcher)])
-      let allProcessed = EventProcessing.allChainsEventsProcessedToEndblock(chainFetchers)
-
-      // When not all chains processed to end block
-      Assert.equal(allProcessed, false)
-      // Then eventOrigin should be Historical
-      let expectedOrigin: Internal.eventOrigin = Historical
-      let actualOrigin: Internal.eventOrigin = if allProcessed {
-        Live
-      } else {
-        Historical
+      let item = Internal.Event({
+        timestamp: emptyEventLog.block.timestamp,
+        chain: MockConfig.chain1337,
+        blockNumber: emptyEventLog.block.number,
+        logIndex: emptyEventLog.logIndex,
+        eventConfig: (Types.Gravatar.EmptyEvent.register() :> Internal.eventConfig),
+        event: emptyEventLog->Internal.fromGenericEvent,
+      })
+
+      // Actually call processEventBatch - the real code path
+      let _ = (await EventProcessing.processEventBatch(
+        ~items=[item],
+        ~progressedChains=[{
+          chainId: 54321,
+          batchSize: 1,
+          progressBlockNumber: 500,
+          isProgressAtHead: false,
+          totalEventsProcessed: 1,
+        }],
+        ~inMemoryStore,
+        ~isInReorgThreshold=false,
+        ~loadManager,
+        ~config,
+        ~chainFetchers,
+      ))->Belt.Result.getExn
+
+      // Assert on the eventOrigin that processEventBatch passed to the handler
+      switch EventHandlers.lastEmptyEventOrigin.contents {
+      | Some(Historical) => Assert.ok(true)
+      | Some(Live) => Assert.fail("Expected Historical but processEventBatch passed Live")
+      | None => Assert.fail("Handler was not called - processEventBatch didn't execute handler")
       }
-      Assert.equal(actualOrigin, expectedOrigin)
     })
 
-    it("should be Live when all chains have reached end block", () => {
+    Async.it("should pass Live when all chains have reached end block", async () => {
+      EventHandlers.lastEmptyEventOrigin := None
+
+      // Setup: chain HAS reached its end block (1000 >= 1000)
       let chainFetcher = {
         "committedProgressBlockNumber": 1000,
-        "fetchState": {
-          "endBlock": Some(1000),
-        },
+        "fetchState": {"endBlock": Some(1000)},
       }->Utils.magic
+      let chainFetchers = ChainMap.fromArrayUnsafe([(ChainMap.Chain.makeUnsafe(~chainId=54321), chainFetcher)])
+
+      let config = RegisterHandlers.registerAllHandlers()
+      let inMemoryStore = InMemoryStore.make()
+      let loadManager = LoadManager.make()
+
+      let emptyEventLog: Types.eventLog<Types.Gravatar.EmptyEvent.eventArgs> = {
+        params: (),
+        chainId: 54321,
+        srcAddress: "0xabc0000000000000000000000000000000000000"->Address.Evm.fromStringOrThrow,
+        logIndex: 1,
+        transaction: MockEvents.tx1,
+        block: MockEvents.block1,
+      }
 
-      let chainFetchers = ChainMap.fromArrayUnsafe([(ChainMap.Chain.makeUnsafe(~chainId=1), chainFetcher)])
-      let allProcessed = EventProcessing.allChainsEventsProcessedToEndblock(chainFetchers)
+      let item = Internal.Event({
+        timestamp: emptyEventLog.block.timestamp,
+        chain: MockConfig.chain1337,
+        blockNumber: emptyEventLog.block.number,
+        logIndex: emptyEventLog.logIndex,
+        eventConfig: (Types.Gravatar.EmptyEvent.register() :> Internal.eventConfig),
+        event: emptyEventLog->Internal.fromGenericEvent,
+      })
+
+      // Actually call processEventBatch
+      let _ = (await EventProcessing.processEventBatch(
+        ~items=[item],
+        ~progressedChains=[{
+          chainId: 54321,
+          batchSize: 1,
+          progressBlockNumber: 1000,
+          isProgressAtHead: true,
+          totalEventsProcessed: 1,
+        }],
+        ~inMemoryStore,
+        ~isInReorgThreshold=false,
+        ~loadManager,
+        ~config,
+        ~chainFetchers,
+      ))->Belt.Result.getExn
+
+      // Assert on what processEventBatch actually passed to the handler
+      switch EventHandlers.lastEmptyEventOrigin.contents {
+      | Some(Live) => Assert.ok(true)
+      | Some(Historical) => Assert.fail("Expected Live but processEventBatch passed Historical")
+      | None => Assert.fail("Handler was not called")
+      }
+    })
+
+    Async.it("should pass Historical in multi-chain when not all reached end", async () => {
+      EventHandlers.lastEmptyEventOrigin := None
+
+      // Setup: chain 1 reached end, chain 2 has not
+      let chainFetcher1 = {
+        "committedProgressBlockNumber": 1000,
+        "fetchState": {"endBlock": Some(1000)},
+      }->Utils.magic
+      let chainFetcher2 = {
+        "committedProgressBlockNumber": 1500,
+        "fetchState": {"endBlock": Some(2000)},
+      }->Utils.magic
+      let chainFetchers = ChainMap.fromArrayUnsafe([
+        (ChainMap.Chain.makeUnsafe(~chainId=1), chainFetcher1),
+        (ChainMap.Chain.makeUnsafe(~chainId=2), chainFetcher2),
+      ])
+
+      let config = RegisterHandlers.registerAllHandlers()
+      let inMemoryStore = InMemoryStore.make()
+      let loadManager = LoadManager.make()
+
+      let emptyEventLog: Types.eventLog<Types.Gravatar.EmptyEvent.eventArgs> = {
+        params: (),
+        chainId: 54321,
+        srcAddress: "0xabc0000000000000000000000000000000000000"->Address.Evm.fromStringOrThrow,
+        logIndex: 1,
+        transaction: MockEvents.tx1,
+        block: MockEvents.block1,
+      }
 
-      // When all chains processed to end block
-      Assert.equal(allProcessed, true)
-      // Then eventOrigin should be Live
-      let expectedOrigin: Internal.eventOrigin = Live
-      let actualOrigin: Internal.eventOrigin = if allProcessed {
-        Live
-      } else {
-        Historical
+      let item = Internal.Event({
+        timestamp: emptyEventLog.block.timestamp,
+        chain: MockConfig.chain1337,
+        blockNumber: emptyEventLog.block.number,
+        logIndex: emptyEventLog.logIndex,
+        eventConfig: (Types.Gravatar.EmptyEvent.register() :> Internal.eventConfig),
+        event: emptyEventLog->Internal.fromGenericEvent,
+      })
+
+      // Call the real processEventBatch with multi-chain scenario
+      let _ = (await EventProcessing.processEventBatch(
+        ~items=[item],
+        ~progressedChains=[{
+          chainId: 54321,
+          batchSize: 1,
+          progressBlockNumber: 1000,
+          isProgressAtHead: false,
+          totalEventsProcessed: 1,
+        }],
+        ~inMemoryStore,
+        ~isInReorgThreshold=false,
+        ~loadManager,
+        ~config,
+        ~chainFetchers,
+      ))->Belt.Result.getExn
+
+      // Verify processEventBatch correctly determined Historical
+      switch EventHandlers.lastEmptyEventOrigin.contents {
+      | Some(Historical) => Assert.ok(true)
+      | Some(Live) => Assert.fail("Expected Historical but got Live")
+      | None => Assert.fail("Handler was not called")
       }
-      Assert.equal(actualOrigin, expectedOrigin)
     })
   })
 })