tests: answer comments + finish migration

Author: greged93

Cargo.lock

@@ -4,21 +4,14 @@ use super::fixture::TestFixture;
 use crate::test_utils::EventAssertions;
 
 use alloy_primitives::B256;
-use futures::StreamExt;
 use reth_primitives_traits::transaction::TxHashRef;
-use reth_rpc_api::EngineApiClient;
-use reth_scroll_chainspec::ScrollChainSpec;
-use reth_scroll_engine_primitives::ScrollEngineTypes;
 use reth_scroll_primitives::ScrollBlock;
-use rollup_node_sequencer::SequencerEvent;
 use scroll_alloy_consensus::ScrollTransaction;
-use scroll_alloy_provider::ScrollAuthApiEngineClient;
-use scroll_db::Database;
 
 /// Builder for constructing and validating blocks in tests.
 #[derive(Debug)]
-pub struct BlockBuilder<'a, EC> {
-    fixture: &'a mut TestFixture<EC>,
+pub struct BlockBuilder<'a> {
+    fixture: &'a mut TestFixture,
     expected_tx_hashes: Vec<B256>,
     expected_tx_count: Option<usize>,
     expected_base_fee: Option<u64>,
@@ -27,9 +20,9 @@ pub struct BlockBuilder<'a, EC> {
     expected_l1_message_count: Option<usize>,
 }
 
-impl<'a, EC: EngineApiClient<ScrollEngineTypes> + Sync + Send + 'static> BlockBuilder<'a, EC> {
+impl<'a> BlockBuilder<'a> {
     /// Create a new block builder.
-    pub(crate) fn new(fixture: &'a mut TestFixture<EC>) -> Self {
+    pub(crate) fn new(fixture: &'a mut TestFixture) -> Self {
         Self {
             fixture,
             expected_tx_hashes: Vec::new(),
@@ -109,32 +102,6 @@ impl<'a, EC: EngineApiClient<ScrollEngineTypes> + Sync + Send + 'static> BlockBu
         self.validate_block(&block)
     }
 
-    /// Build a block using the low-level sequencer API (for direct sequencer tests).
-    pub async fn build_with_sequencer(
-        self,
-        sequencer: &mut rollup_node_sequencer::Sequencer<Database, ScrollChainSpec>,
-        engine: &mut scroll_engine::Engine<ScrollAuthApiEngineClient<EC>>,
-    ) -> eyre::Result<Option<ScrollBlock>> {
-        // Start payload building
-        sequencer.start_payload_building(engine).await?;
-
-        // Wait for the payload to be ready
-        let payload_id = loop {
-            if let Some(SequencerEvent::PayloadReady(id)) = sequencer.next().await {
-                break id;
-            }
-        };
-
-        // Finalize the payload building
-        let block_opt = sequencer.finalize_payload_building(payload_id, engine).await?;
-
-        if let Some(ref block) = block_opt {
-            self.validate_block(block)?;
-        }
-
-        Ok(block_opt)
-    }
-
     /// Validate the block against expectations.
     fn validate_block(self, block: &ScrollBlock) -> eyre::Result<ScrollBlock> {
         // Check transaction count

crates/node/src/test_utils/block_builder.rs

@@ -11,15 +11,15 @@ use tokio::time::timeout;
 
 /// Builder for waiting for specific events with optional assertions.
 #[derive(Debug)]
-pub struct EventWaiter<'a, EC> {
-    fixture: &'a mut TestFixture<EC>,
+pub struct EventWaiter<'a> {
+    fixture: &'a mut TestFixture,
     node_index: usize,
     timeout_duration: Duration,
 }
 
-impl<'a, EC> EventWaiter<'a, EC> {
+impl<'a> EventWaiter<'a> {
     /// Create a new event waiter.
-    pub fn new(fixture: &'a mut TestFixture<EC>, node_index: usize) -> Self {
+    pub fn new(fixture: &'a mut TestFixture, node_index: usize) -> Self {
         Self { fixture, node_index, timeout_duration: Duration::from_secs(30) }
     }
 
@@ -60,7 +60,7 @@ impl<'a, EC> EventWaiter<'a, EC> {
     /// Wait for a chain extended event.
     pub async fn chain_extended(self, target: u64) -> eyre::Result<()> {
         self.wait_for_event(|e| {
-            matches!(e, ChainOrchestratorEvent::ChainExtended(ChainImport { chain, .. }) if chain.last().map(|b| b.header.number) == Some(target))
+            matches!(e, ChainOrchestratorEvent::ChainExtended(ChainImport { chain, .. }) if chain.last().map(|b| b.header.number) >= Some(target))
                 .then_some(())
         })
         .await
@@ -174,6 +174,7 @@ impl<'a, EC> EventWaiter<'a, EC> {
 
         let result = timeout(self.timeout_duration, async {
             while let Some(event) = events.next().await {
+                tracing::debug!(target: "event_waiter", ?event);
                 if let Some(value) = extractor(&event) {
                     return Ok(value);
                 }
@@ -188,15 +189,15 @@ impl<'a, EC> EventWaiter<'a, EC> {
 
 /// Builder for waiting for events on multiple nodes.
 #[derive(Debug)]
-pub struct MultiNodeEventWaiter<'a, EC> {
-    fixture: &'a mut TestFixture<EC>,
+pub struct MultiNodeEventWaiter<'a> {
+    fixture: &'a mut TestFixture,
     node_indices: Vec<usize>,
     timeout_duration: Duration,
 }
 
-impl<'a, EC> MultiNodeEventWaiter<'a, EC> {
+impl<'a> MultiNodeEventWaiter<'a> {
     /// Create a new multi-node event waiter.
-    pub fn new(fixture: &'a mut TestFixture<EC>, node_indices: Vec<usize>) -> Self {
+    pub fn new(fixture: &'a mut TestFixture, node_indices: Vec<usize>) -> Self {
         Self { fixture, node_indices, timeout_duration: Duration::from_secs(30) }
     }
 
@@ -397,42 +398,42 @@ impl<'a, EC> MultiNodeEventWaiter<'a, EC> {
 }
 
 /// Extension trait for `TestFixture` to add event waiting capabilities.
-pub trait EventAssertions<EC> {
+pub trait EventAssertions {
     /// Wait for an event on the sequencer node.
-    fn expect_event(&mut self) -> EventWaiter<'_, EC>;
+    fn expect_event(&mut self) -> EventWaiter<'_>;
 
     /// Wait for an event on a specific node.
-    fn expect_event_on(&mut self, node_index: usize) -> EventWaiter<'_, EC>;
+    fn expect_event_on(&mut self, node_index: usize) -> EventWaiter<'_>;
 
     /// Wait for an event on multiple nodes.
-    fn expect_event_on_nodes(&mut self, node_indices: Vec<usize>) -> MultiNodeEventWaiter<'_, EC>;
+    fn expect_event_on_nodes(&mut self, node_indices: Vec<usize>) -> MultiNodeEventWaiter<'_>;
 
     /// Wait for an event on all nodes.
-    fn expect_event_on_all_nodes(&mut self) -> MultiNodeEventWaiter<'_, EC>;
+    fn expect_event_on_all_nodes(&mut self) -> MultiNodeEventWaiter<'_>;
 
     /// Wait for an event on all follower nodes (excluding sequencer at index 0).
-    fn expect_event_on_followers(&mut self) -> MultiNodeEventWaiter<'_, EC>;
+    fn expect_event_on_followers(&mut self) -> MultiNodeEventWaiter<'_>;
 }
 
-impl<EC> EventAssertions<EC> for TestFixture<EC> {
-    fn expect_event(&mut self) -> EventWaiter<'_, EC> {
+impl EventAssertions for TestFixture {
+    fn expect_event(&mut self) -> EventWaiter<'_> {
         EventWaiter::new(self, 0)
     }
 
-    fn expect_event_on(&mut self, node_index: usize) -> EventWaiter<'_, EC> {
+    fn expect_event_on(&mut self, node_index: usize) -> EventWaiter<'_> {
         EventWaiter::new(self, node_index)
     }
 
-    fn expect_event_on_nodes(&mut self, node_indices: Vec<usize>) -> MultiNodeEventWaiter<'_, EC> {
+    fn expect_event_on_nodes(&mut self, node_indices: Vec<usize>) -> MultiNodeEventWaiter<'_> {
         MultiNodeEventWaiter::new(self, node_indices)
     }
 
-    fn expect_event_on_all_nodes(&mut self) -> MultiNodeEventWaiter<'_, EC> {
+    fn expect_event_on_all_nodes(&mut self) -> MultiNodeEventWaiter<'_> {
         let node_indices = (0..self.nodes.len()).collect();
         MultiNodeEventWaiter::new(self, node_indices)
     }
 
-    fn expect_event_on_followers(&mut self) -> MultiNodeEventWaiter<'_, EC> {
+    fn expect_event_on_followers(&mut self) -> MultiNodeEventWaiter<'_> {
         let node_indices = (1..self.nodes.len()).collect();
         MultiNodeEventWaiter::new(self, node_indices)
     }