test: clarify why historical reorg tests are ignored + ref

Author: 0xNeshi

tests/block_range_scanner.rs

@@ -13,12 +13,11 @@ use event_scanner::{
 #[tokio::test]
 async fn live_mode_processes_all_blocks_respecting_block_confirmations() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
-    let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
+    let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
 
     // --- Zero block confirmations -> stream immediately ---
 
-    let client =
-        BlockRangeScanner::new().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?.run()?;
+    let client = BlockRangeScanner::new().connect::<Ethereum>(provider.root().clone()).run()?;
 
     let mut stream = client.stream_live(0).await?;
 
@@ -60,30 +59,24 @@ async fn live_mode_processes_all_blocks_respecting_block_confirmations() -> anyh
 #[tokio::test]
 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?;
 
-    let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
-    provider.anvil_mine(Some(20), None).await?;
-
-    let block_confirmations = 5;
+    let client = BlockRangeScanner::new().connect::<Ethereum>(provider.root().clone()).run()?;
 
-    let client =
-        BlockRangeScanner::new().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?.run()?;
+    provider.anvil_mine(Some(20), None).await?;
 
-    let stream = client.stream_from(BlockNumberOrTag::Latest, block_confirmations).await?;
+    let stream = client.stream_from(BlockNumberOrTag::Latest, 5).await?;
 
     let stream = assert_empty!(stream);
 
     provider.anvil_mine(Some(4), None).await?;
-
     let mut stream = assert_empty!(stream);
 
     provider.anvil_mine(Some(1), None).await?;
-
     assert_next!(stream, 20..=20);
     let mut stream = assert_empty!(stream);
 
     provider.anvil_mine(Some(1), None).await?;
-
     assert_next!(stream, 21..=21);
     assert_empty!(stream);
 
@@ -94,6 +87,7 @@ async fn stream_from_latest_starts_at_tip_not_confirmed() -> anyhow::Result<()>
 async fn continuous_blocks_if_reorg_less_than_block_confirmation() -> 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 mut stream = client.stream_live(5).await?;
@@ -133,8 +127,8 @@ async fn continuous_blocks_if_reorg_less_than_block_confirmation() -> anyhow::Re
 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_ws::<Ethereum>(anvil.ws_endpoint_url()).await?.run()?;
+
+    let client = BlockRangeScanner::new().connect::<Ethereum>(provider.root().clone()).run()?;
 
     let mut stream = client.stream_live(3).await?;
 
@@ -178,19 +172,18 @@ async fn shallow_block_confirmation_does_not_mitigate_reorg() -> anyhow::Result<
 }
 
 #[tokio::test]
-#[ignore = "too flaky, un-ignore once a full local node is used: https://github.com/OpenZeppelin/Event-Scanner/issues/109"]
+#[ignore = "historical currently has no reorg logic: https://github.com/OpenZeppelin/Event-Scanner/issues/56"]
 async fn historical_emits_correction_range_when_reorg_below_end() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
-    let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
+    let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
 
     provider.anvil_mine(Some(120), None).await?;
 
     let end_num = 110;
 
     let client = BlockRangeScanner::new()
         .max_block_range(30)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     let mut stream = client
@@ -213,7 +206,7 @@ async fn historical_emits_correction_range_when_reorg_below_end() -> anyhow::Res
 }
 
 #[tokio::test]
-#[ignore = "too flaky, un-ignore once a full local node is used: https://github.com/OpenZeppelin/Event-Scanner/issues/109"]
+#[ignore = "historical currently has no reorg logic: https://github.com/OpenZeppelin/Event-Scanner/issues/56"]
 async fn historical_emits_correction_range_when_end_num_reorgs() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
     let provider = ProviderBuilder::new().connect(anvil.ws_endpoint_url().as_str()).await?;
@@ -224,8 +217,7 @@ async fn historical_emits_correction_range_when_end_num_reorgs() -> anyhow::Resu
 
     let client = BlockRangeScanner::new()
         .max_block_range(30)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     let mut stream = client
@@ -252,15 +244,13 @@ async fn historical_emits_correction_range_when_end_num_reorgs() -> anyhow::Resu
 #[tokio::test]
 async fn historic_mode_respects_blocks_read_per_epoch() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
-
     let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
 
     provider.anvil_mine(Some(100), None).await?;
 
     let client = BlockRangeScanner::new()
         .max_block_range(5)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     // ranges where each batch is of max blocks per epoch size
@@ -290,8 +280,7 @@ async fn historic_mode_respects_blocks_read_per_epoch() -> anyhow::Result<()> {
     // range where blocks per epoch is larger than the number of blocks on chain
     let client = BlockRangeScanner::new()
         .max_block_range(200)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     let mut stream = client.stream_historical(0, 20).await?;
@@ -308,14 +297,13 @@ async fn historic_mode_respects_blocks_read_per_epoch() -> anyhow::Result<()> {
 #[tokio::test]
 async fn historic_mode_normalises_start_and_end_block() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
-
     let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
+
     provider.anvil_mine(Some(11), None).await?;
 
     let client = BlockRangeScanner::new()
         .max_block_range(5)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     let mut stream = client.stream_historical(10, 0).await?;
@@ -324,21 +312,25 @@ async fn historic_mode_normalises_start_and_end_block() -> anyhow::Result<()> {
     assert_next!(stream, 10..=10);
     assert_closed!(stream);
 
+    let mut stream = client.stream_historical(0, 10).await?;
+    assert_next!(stream, 0..=4);
+    assert_next!(stream, 5..=9);
+    assert_next!(stream, 10..=10);
+    assert_closed!(stream);
+
     Ok(())
 }
 
 #[tokio::test]
 async fn rewind_single_batch_when_epoch_larger_than_range() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
-
     let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
 
     provider.anvil_mine(Some(150), None).await?;
 
     let client = BlockRangeScanner::new()
         .max_block_range(100)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     let mut stream = client.rewind(100, 150).await?;
@@ -353,15 +345,13 @@ async fn rewind_single_batch_when_epoch_larger_than_range() -> anyhow::Result<()
 #[tokio::test]
 async fn rewind_exact_multiple_of_epoch_creates_full_batches_in_reverse() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
-
     let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
 
     provider.anvil_mine(Some(15), None).await?;
 
     let client = BlockRangeScanner::new()
         .max_block_range(5)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     let mut stream = client.rewind(0, 14).await?;
@@ -378,15 +368,13 @@ async fn rewind_exact_multiple_of_epoch_creates_full_batches_in_reverse() -> any
 #[tokio::test]
 async fn rewind_with_remainder_trims_first_batch_to_stream_start() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
-
     let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
 
     provider.anvil_mine(Some(15), None).await?;
 
     let client = BlockRangeScanner::new()
         .max_block_range(4)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     let mut stream = client.rewind(3, 12).await?;
@@ -403,15 +391,13 @@ async fn rewind_with_remainder_trims_first_batch_to_stream_start() -> anyhow::Re
 #[tokio::test]
 async fn rewind_single_block_range() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
-
     let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
 
     provider.anvil_mine(Some(15), None).await?;
 
     let client = BlockRangeScanner::new()
         .max_block_range(5)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     let mut stream = client.rewind(7, 7).await?;
@@ -425,15 +411,13 @@ async fn rewind_single_block_range() -> anyhow::Result<()> {
 #[tokio::test]
 async fn rewind_epoch_of_one_sends_each_block_in_reverse_order() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
-
     let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
 
     provider.anvil_mine(Some(15), None).await?;
 
     let client = BlockRangeScanner::new()
         .max_block_range(1)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     let mut stream = client.rewind(5, 8).await?;
@@ -451,15 +435,14 @@ async fn rewind_epoch_of_one_sends_each_block_in_reverse_order() -> anyhow::Resu
 #[tokio::test]
 async fn command_rewind_defaults_latest_to_earliest_batches_correctly() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
-
     let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
+
     // Mine 20 blocks, so the total number of blocks is 21 (including 0th block)
     provider.anvil_mine(Some(20), None).await?;
 
     let client = BlockRangeScanner::new()
         .max_block_range(7)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     let mut stream = client.rewind(BlockNumberOrTag::Earliest, BlockNumberOrTag::Latest).await?;
@@ -475,15 +458,14 @@ async fn command_rewind_defaults_latest_to_earliest_batches_correctly() -> anyho
 #[tokio::test]
 async fn command_rewind_handles_start_and_end_in_any_order() -> anyhow::Result<()> {
     let anvil = Anvil::new().try_spawn()?;
-
     let provider = ProviderBuilder::new().connect(anvil.endpoint().as_str()).await?;
+
     // Ensure blocks at 3 and 15 exist
     provider.anvil_mine(Some(16), None).await?;
 
     let client = BlockRangeScanner::new()
         .max_block_range(5)
-        .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
-        .await?
+        .connect::<Ethereum>(provider.root().clone())
         .run()?;
 
     let mut stream = client.rewind(15, 3).await?;