fix: test

Author: LeoPatOZ

tests/block_range_scanner.rs

@@ -1,14 +1,12 @@
 use alloy::{
     eips::{BlockId, BlockNumberOrTag},
-    network::Ethereum,
-    providers::{Provider, ProviderBuilder, ext::AnvilApi},
+    providers::{ProviderBuilder, ext::AnvilApi},
     rpc::types::anvil::ReorgOptions,
 };
 use alloy_node_bindings::Anvil;
 use event_scanner::{
     ScannerError, ScannerStatus, assert_closed, assert_empty, assert_next,
-    block_range_scanner::{BlockRangeScanner, Message},
-    robust_provider::RobustProvider,
+    block_range_scanner::BlockRangeScanner, robust_provider::RobustProvider,
 };
 
 #[tokio::test]
@@ -63,27 +61,23 @@ async fn stream_from_latest_starts_at_tip_not_confirmed() -> anyhow::Result<()>
     let anvil = Anvil::new().try_spawn()?;
     let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
 
-    provider.anvil_mine(Some(20), None).await?;
-
     let robust_provider = RobustProvider::new(provider);
-
     let client = BlockRangeScanner::new().connect(robust_provider.clone()).run()?;
 
+    robust_provider.root().anvil_mine(Some(20), None).await?;
+
     let stream = client.stream_from(BlockNumberOrTag::Latest, 5).await?;
 
     let stream = assert_empty!(stream);
 
     robust_provider.root().anvil_mine(Some(4), None).await?;
-
     let mut stream = assert_empty!(stream);
 
     robust_provider.root().anvil_mine(Some(1), None).await?;
-
     assert_next!(stream, 20..=20);
     let mut stream = assert_empty!(stream);
 
     robust_provider.root().anvil_mine(Some(1), None).await?;
-
     assert_next!(stream, 21..=21);
     assert_empty!(stream);
 
@@ -95,16 +89,13 @@ async fn continuous_blocks_if_reorg_less_than_block_confirmation() -> anyhow::Re
     let anvil = Anvil::new().try_spawn()?;
     let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
 
-    let provider = ProviderBuilder::new().connect(anvil.ws_endpoint().as_str()).await?;
-
-    let robust_provider = RobustProvider::new(provider.clone());
-
-    let client = BlockRangeScanner::new().connect(robust_provider).run()?;
+    let robust_provider = RobustProvider::new(provider);
+    let client = BlockRangeScanner::new().connect(robust_provider.clone()).run()?;
 
-    let mut receiver = client.stream_live(5).await?;
+    let mut stream = client.stream_live(5).await?;
 
     // mine initial blocks
-    provider.anvil_mine(Some(10), None).await?;
+    robust_provider.root().anvil_mine(Some(10), None).await?;
 
     // assert initial block ranges immediately to avoid Anvil race condition:
     //
@@ -119,9 +110,9 @@ async fn continuous_blocks_if_reorg_less_than_block_confirmation() -> anyhow::Re
     assert_next!(stream, 5..=5);
 
     // reorg less blocks than the block_confirmation config
-    provider.anvil_reorg(ReorgOptions { depth: 4, tx_block_pairs: vec![] }).await?;
+    robust_provider.root().anvil_reorg(ReorgOptions { depth: 4, tx_block_pairs: vec![] }).await?;
     // mint additional blocks so the scanner processes reorged blocks
-    provider.anvil_mine(Some(5), None).await?;
+    robust_provider.root().anvil_mine(Some(5), None).await?;
 
     // no ReorgDetected should be emitted
     assert_next!(stream, 6..=6);
@@ -139,12 +130,13 @@ async fn shallow_block_confirmation_does_not_mitigate_reorg() -> anyhow::Result<
     let anvil = Anvil::new().try_spawn()?;
     let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
 
-    let client = BlockRangeScanner::new().connect::<Ethereum>(provider.root().clone()).run()?;
+    let robust_provider = RobustProvider::new(provider);
+    let client = BlockRangeScanner::new().connect(robust_provider.clone()).run()?;
 
     let mut stream = client.stream_live(3).await?;
 
     // mine initial blocks
-    provider.anvil_mine(Some(10), None).await?;
+    robust_provider.root().anvil_mine(Some(10), None).await?;
 
     // assert initial block ranges immediately to avoid Anvil race condition:
     //
@@ -161,9 +153,9 @@ async fn shallow_block_confirmation_does_not_mitigate_reorg() -> anyhow::Result<
     assert_next!(stream, 7..=7);
 
     // reorg more blocks than the block_confirmation config
-    provider.anvil_reorg(ReorgOptions { depth: 8, tx_block_pairs: vec![] }).await?;
+    robust_provider.root().anvil_reorg(ReorgOptions { depth: 8, tx_block_pairs: vec![] }).await?;
     // mint additional blocks
-    provider.anvil_mine(Some(3), None).await?;
+    robust_provider.root().anvil_mine(Some(3), None).await?;
 
     assert_next!(stream, ScannerStatus::ReorgDetected);
     assert_next!(stream, 0..=0);

tests/sync/from_block.rs

@@ -86,15 +86,29 @@ async fn block_confirmations_mitigate_reorgs() -> anyhow::Result<()> {
 
     // mine some initial "historic" blocks
     contract.increase().send().await?.watch().await?;
-    provider.anvil_mine(Some(5), None).await?;
+    provider.root().anvil_mine(Some(5), None).await?;
 
     scanner.start().await?;
 
-    // emit initial events
+    // emit "live" events
     for _ in 0..4 {
         contract.increase().send().await?.watch().await?;
     }
 
+    // assert only the first events has enough confirmations to be streamed
+    assert_next!(stream, &[TestCounter::CountIncreased { newCount: U256::from(1) }]);
+    assert_next!(stream, ScannerStatus::SwitchingToLive);
+    let stream = assert_empty!(stream);
+
+    // Perform a shallow reorg on the live tail
+    // note: we include new txs in the same post-reorg block to showcase that the scanner
+    // only streams the post-reorg, confirmed logs
+    let tx_block_pairs = vec![
+        (TransactionData::JSON(contract.increase().into_transaction_request()), 0),
+        (TransactionData::JSON(contract.increase().into_transaction_request()), 0),
+    ];
+    provider.root().anvil_reorg(ReorgOptions { depth: 2, tx_block_pairs }).await?;
+
     // assert that still no events have been streamed
     let mut stream = assert_empty!(stream);