refactor test_batch_revert_gap with test fixture

Author: jonastheis

crates/chain-orchestrator/src/lib.rs

@@ -826,8 +826,7 @@ impl<
                     missing_index,
                     l1_block_number_reset
                 );
-                // TODO: getting channel closed here
-                // self.l1_watcher_handle.trigger_gap_recovery(l1_block_number_reset).await;
+                self.l1_watcher_handle.trigger_gap_recovery(l1_block_number_reset).await;
             }
             Some(BatchCommitDuplicate(index)) => {
                 tracing::info!(

crates/node/src/test_utils/event_utils.rs

@@ -134,8 +134,8 @@ impl<'a> EventWaiter<'a> {
         self.wait_for_event_on_all(|e| {
             if let ChainOrchestratorEvent::L1MessageGap { missing_index, l1_block_number_reset } = e
             {
-                (*missing_index == expected_missing_index
-                    && *l1_block_number_reset == expected_l1_block_number_reset)
+                (*missing_index == expected_missing_index &&
+                    *l1_block_number_reset == expected_l1_block_number_reset)
                     .then_some(())
             } else {
                 None
@@ -177,10 +177,16 @@ impl<'a> EventWaiter<'a> {
     }
 
     /// Wait for batch commit indexed event on all specified nodes.
-    pub async fn batch_commit_indexed(self, target_batch_index: u64, target_l1_block_number: u64) -> eyre::Result<()> {
+    pub async fn batch_commit_indexed(
+        self,
+        target_batch_index: u64,
+        target_l1_block_number: u64,
+    ) -> eyre::Result<()> {
         self.wait_for_event_on_all(|e| {
-            if let ChainOrchestratorEvent::BatchCommitIndexed {batch_info, l1_block_number} = e {
-                (batch_info.index == target_batch_index && *l1_block_number == target_l1_block_number).then_some(())
+            if let ChainOrchestratorEvent::BatchCommitIndexed { batch_info, l1_block_number } = e {
+                (batch_info.index == target_batch_index &&
+                    *l1_block_number == target_l1_block_number)
+                    .then_some(())
             } else {
                 None
             }
@@ -212,8 +218,42 @@ impl<'a> EventWaiter<'a> {
             if let ChainOrchestratorEvent::BatchCommitGap { missing_index, l1_block_number_reset } =
                 e
             {
-                (*missing_index == expected_missing_index
-                    && *l1_block_number_reset == expected_l1_block_number_reset)
+                (*missing_index == expected_missing_index &&
+                    *l1_block_number_reset == expected_l1_block_number_reset)
+                    .then_some(())
+            } else {
+                None
+            }
+        })
+        .await?;
+        Ok(())
+    }
+
+    /// Wait for batch revert duplicate event on all specified nodes.
+    pub async fn batch_revert_duplicate(self, expected_index: u64) -> eyre::Result<()> {
+        self.wait_for_event_on_all(|e| {
+            if let ChainOrchestratorEvent::BatchRevertDuplicate(index) = e {
+                (*index == expected_index).then_some(())
+            } else {
+                None
+            }
+        })
+        .await?;
+        Ok(())
+    }
+
+    /// Wait for batch revert gap event on all specified nodes.
+    pub async fn batch_revert_gap(
+        self,
+        expected_missing_index: u64,
+        expected_l1_block_number_reset: u64,
+    ) -> eyre::Result<()> {
+        self.wait_for_event_on_all(|e| {
+            if let ChainOrchestratorEvent::BatchRevertGap { missing_index, l1_block_number_reset } =
+                e
+            {
+                (*missing_index == expected_missing_index &&
+                    *l1_block_number_reset == expected_l1_block_number_reset)
                     .then_some(())
             } else {
                 None

crates/node/src/test_utils/fixture.rs

@@ -98,6 +98,14 @@ impl NodeHandle {
     pub const fn is_follower(&self) -> bool {
         matches!(self.typ, NodeType::Follower)
     }
+
+    /// Update the L1 watcher notification sender.
+    ///
+    /// This is used after gap recovery to update the sender to the new channel
+    /// that the `ChainOrchestrator` is now listening on.
+    pub fn set_l1_watcher_tx(&mut self, tx: mpsc::Sender<Arc<L1Notification>>) {
+        self.l1_watcher_tx = Some(tx);
+    }
 }
 
 impl Debug for NodeHandle {
@@ -225,6 +233,41 @@ impl TestFixture {
             .map_err(|_| eyre::eyre!("Timeout waiting for L1 watcher command"))?
             .ok_or_else(|| eyre::eyre!("L1 watcher command channel closed"))
     }
+
+    /// Process an L1 watcher reset command and update the notification sender.
+    ///
+    /// After a gap is detected, the `ChainOrchestrator` calls `trigger_gap_recovery` which
+    /// creates a new notification channel and sends the new sender via the command channel.
+    /// This method reads that command and updates the test fixture's `l1_watcher_tx` so
+    /// subsequent L1 notifications can be sent to the `ChainOrchestrator`.
+    ///
+    /// Returns the block number that the L1 watcher should reset to.
+    pub async fn process_gap_recovery_command(&mut self) -> eyre::Result<u64> {
+        self.process_gap_recovery_command_on(0).await
+    }
+
+    /// Process an L1 watcher reset command on a specific node.
+    ///
+    /// See [`Self::process_gap_recovery_command`] for details.
+    pub async fn process_gap_recovery_command_on(
+        &mut self,
+        node_index: usize,
+    ) -> eyre::Result<u64> {
+        let command = {
+            let mut command_rx = self.nodes[node_index].l1_watcher_command_rx.lock().await;
+            tokio::time::timeout(Duration::from_secs(5), command_rx.recv())
+                .await
+                .map_err(|_| eyre::eyre!("Timeout waiting for L1 watcher command"))?
+                .ok_or_else(|| eyre::eyre!("L1 watcher command channel closed"))?
+        };
+
+        match command {
+            L1WatcherCommand::ResetToBlock { block, new_sender } => {
+                self.nodes[node_index].set_l1_watcher_tx(new_sender);
+                Ok(block)
+            }
+        }
+    }
 }
 
 /// Builder for creating test fixtures with a fluent API.

crates/node/src/test_utils/l1_helpers.rs

@@ -96,6 +96,11 @@ impl<'a> L1Helper<'a> {
         BatchRevertBuilder::new(self)
     }
 
+    /// Create a batch revert range builder.
+    pub fn revert_batch_range(self) -> BatchRevertRangeBuilder<'a> {
+        BatchRevertRangeBuilder::new(self)
+    }
+
     /// Send an L1 finalized block notification.
     pub async fn finalize_l1_block(self, block_number: u64) -> eyre::Result<()> {
         let notification = Arc::new(L1Notification::Finalized(block_number));
@@ -453,3 +458,58 @@ impl<'a> BatchRevertBuilder<'a> {
         self.l1_helper.send_to_nodes(notification).await
     }
 }
+
+/// Builder for creating batch revert range notifications in tests.
+#[derive(Debug)]
+pub struct BatchRevertRangeBuilder<'a> {
+    l1_helper: L1Helper<'a>,
+    block_info: BlockInfo,
+    start: u64,
+    end: u64,
+}
+
+impl<'a> BatchRevertRangeBuilder<'a> {
+    fn new(l1_helper: L1Helper<'a>) -> Self {
+        Self {
+            l1_helper,
+            block_info: BlockInfo { number: 0, hash: B256::random() },
+            start: 0,
+            end: 0,
+        }
+    }
+
+    /// Set the L1 block info for this batch revert range.
+    pub const fn at_block(mut self, block_info: BlockInfo) -> Self {
+        self.block_info = block_info;
+        self
+    }
+
+    /// Set the L1 block number for this batch revert range.
+    pub const fn at_block_number(mut self, block_number: u64) -> Self {
+        self.block_info.number = block_number;
+        self
+    }
+
+    /// Set the start batch index.
+    pub const fn start(mut self, start: u64) -> Self {
+        self.start = start;
+        self
+    }
+
+    /// Set the end batch index.
+    pub const fn end(mut self, end: u64) -> Self {
+        self.end = end;
+        self
+    }
+
+    /// Send the batch revert range notification.
+    pub async fn send(self) -> eyre::Result<()> {
+        let notification = Arc::new(L1Notification::BatchRevertRange {
+            start: self.start,
+            end: self.end,
+            block_info: self.block_info,
+        });
+
+        self.l1_helper.send_to_nodes(notification).await
+    }
+}