Fix Fee history test (#66)

Resolves #59 

Adds safe anvil drop (thread blocking drop of anvil)

---------

Co-authored-by: Nenad <nenad.misic@openzeppelin.com>

Author: LeoPatOZ

tests/common/mod.rs

@@ -10,6 +10,32 @@ use alloy::{
     providers::{Provider, ProviderBuilder, RootProvider, ext::AnvilApi},
 };
 use robust_provider::{RobustProvider, RobustProviderBuilder};
+use tokio::time::sleep;
+
+/// Safely drops an `AnvilInstance` by sending SIGTERM and waiting for the process to exit.
+/// This ensures the anvil process is fully terminated before returning.
+pub fn safe_drop_anvil(mut anvil: AnvilInstance) {
+    let child = anvil.child_mut();
+    #[cfg(unix)]
+    {
+        use std::process::Command;
+
+        if let Ok(out) = Command::new("kill").arg("-SIGTERM").arg(child.id().to_string()).output() &&
+            out.status.success()
+        {
+            let _ = child.wait();
+            return;
+        }
+    }
+
+    if let Err(err) = child.kill() {
+        eprintln!("alloy-node-bindings: failed to kill anvil process: {err}");
+    } else {
+        let _ = child.wait();
+    }
+
+    std::mem::forget(anvil);
+}
 
 alloy::sol! {
     // Built directly with solc 0.8.30+commit.73712a01.Darwin.appleclang
@@ -66,6 +92,10 @@ pub async fn setup_anvil_with_blocks(
 ) -> anyhow::Result<(AnvilInstance, RobustProvider, impl Provider)> {
     let (anvil, robust, alloy_provider) = setup_anvil().await?;
     alloy_provider.anvil_mine(Some(num_blocks), None).await?;
+    // some tests rely on blocks being cached, this allows time for blocks to be propelry cached in
+    // foundry.
+    // for more info, see: https://github.com/OpenZeppelin/Robust-Provider/issues/59#issuecomment-4010684560
+    sleep(Duration::from_millis(200)).await;
     Ok((anvil, robust, alloy_provider))
 }
 

tests/eth_namespace/fee.rs

@@ -9,7 +9,6 @@ use alloy::{
 // ============================================================================
 
 #[tokio::test]
-#[ignore = "Flaky, see: https://github.com/OpenZeppelin/Robust-Provider/issues/59"]
 async fn test_get_blob_base_fee_succeeds() -> anyhow::Result<()> {
     let (_anvil, robust, alloy_provider) = setup_anvil().await?;
 
@@ -26,11 +25,10 @@ async fn test_get_blob_base_fee_succeeds() -> anyhow::Result<()> {
 // ============================================================================
 
 #[tokio::test]
-#[ignore = "Flaky, see: https://github.com/OpenZeppelin/Robust-Provider/issues/59"]
 async fn test_get_fee_history_succeeds() -> anyhow::Result<()> {
-    let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(100).await?;
+    let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(1).await?;
 
-    let block_count = 10;
+    let block_count = 1;
     let reward_percentiles = [25.0, 50.0, 75.0];
 
     let robust_fee_history =
@@ -49,7 +47,6 @@ async fn test_get_fee_history_succeeds() -> anyhow::Result<()> {
 // ============================================================================
 
 #[tokio::test]
-#[ignore = "Flaky, see: https://github.com/OpenZeppelin/Robust-Provider/issues/59"]
 async fn test_get_gas_price_succeeds() -> anyhow::Result<()> {
     let (_anvil, robust, alloy_provider) = setup_anvil().await?;
 
@@ -66,7 +63,6 @@ async fn test_get_gas_price_succeeds() -> anyhow::Result<()> {
 // ============================================================================
 
 #[tokio::test]
-#[ignore = "Flaky, see: https://github.com/OpenZeppelin/Robust-Provider/issues/59"]
 async fn test_get_max_priority_fee_per_gas_succeeds() -> anyhow::Result<()> {
     let (_anvil, robust, alloy_provider) = setup_anvil().await?;
 
@@ -83,7 +79,6 @@ async fn test_get_max_priority_fee_per_gas_succeeds() -> anyhow::Result<()> {
 // ============================================================================
 
 #[tokio::test]
-#[ignore = "Flaky, see: https://github.com/OpenZeppelin/Robust-Provider/issues/59"]
 async fn test_estimate_eip1559_fees_succeeds() -> anyhow::Result<()> {
     let (_anvil, robust, alloy_provider) = setup_anvil().await?;
 
@@ -100,9 +95,8 @@ async fn test_estimate_eip1559_fees_succeeds() -> anyhow::Result<()> {
 // ============================================================================
 
 #[tokio::test]
-#[ignore = "Flaky, see: https://github.com/OpenZeppelin/Robust-Provider/issues/59"]
 async fn test_estimate_eip1559_fees_with_default_estimator() -> anyhow::Result<()> {
-    let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(100).await?;
+    let (_anvil, robust, alloy_provider) = setup_anvil().await?;
 
     let robust_gas = robust.estimate_eip1559_fees_with(Eip1559Estimator::default()).await?;
     let alloy_gas = alloy_provider.estimate_eip1559_fees_with(Eip1559Estimator::default()).await?;
@@ -113,9 +107,8 @@ async fn test_estimate_eip1559_fees_with_default_estimator() -> anyhow::Result<(
 }
 
 #[tokio::test]
-#[ignore = "Flaky, see: https://github.com/OpenZeppelin/Robust-Provider/issues/59"]
 async fn test_estimate_eip1559_fees_with_custom_estimator() -> anyhow::Result<()> {
-    let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(100).await?;
+    let (_anvil, robust, alloy_provider) = setup_anvil().await?;
 
     let robust_gas = robust
         .estimate_eip1559_fees_with(Eip1559Estimator::new(|base_fee, _rewards| Eip1559Estimation {
@@ -137,9 +130,8 @@ async fn test_estimate_eip1559_fees_with_custom_estimator() -> anyhow::Result<()
 }
 
 #[tokio::test]
-#[ignore = "Flaky, see: https://github.com/OpenZeppelin/Robust-Provider/issues/59"]
 async fn test_estimate_eip1559_fees_with_zero_priority_fee() -> anyhow::Result<()> {
-    let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(50).await?;
+    let (_anvil, robust, alloy_provider) = setup_anvil().await?;
 
     let robust_gas = robust
         .estimate_eip1559_fees_with(Eip1559Estimator::new(|base_fee, _rewards| Eip1559Estimation {
@@ -161,9 +153,8 @@ async fn test_estimate_eip1559_fees_with_zero_priority_fee() -> anyhow::Result<(
 }
 
 #[tokio::test]
-#[ignore = "Flaky, see: https://github.com/OpenZeppelin/Robust-Provider/issues/59"]
 async fn test_estimate_eip1559_fees_with_high_priority_fee() -> anyhow::Result<()> {
-    let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(50).await?;
+    let (_anvil, robust, alloy_provider) = setup_anvil().await?;
 
     let robust_gas = robust
         .estimate_eip1559_fees_with(Eip1559Estimator::new(|base_fee, _rewards| Eip1559Estimation {
@@ -185,9 +176,8 @@ async fn test_estimate_eip1559_fees_with_high_priority_fee() -> anyhow::Result<(
 }
 
 #[tokio::test]
-#[ignore = "Flaky, see: https://github.com/OpenZeppelin/Robust-Provider/issues/59"]
 async fn test_estimate_eip1559_fees_with_reward_percentile_based() -> anyhow::Result<()> {
-    let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(100).await?;
+    let (_anvil, robust, alloy_provider) = setup_anvil().await?;
 
     let robust_gas = robust
         .estimate_eip1559_fees_with(Eip1559Estimator::new(|base_fee, rewards| Eip1559Estimation {

tests/http_subscription.rs

@@ -18,6 +18,8 @@ use common::{BUFFER_TIME, SHORT_TIMEOUT};
 use robust_provider::{Error, RobustProviderBuilder};
 use tokio_stream::StreamExt;
 
+use crate::common::safe_drop_anvil;
+
 // ============================================================================
 // Test Helpers
 // ============================================================================
@@ -115,7 +117,7 @@ async fn test_ws_only_chain_works_with_http_subscriptions_enabled() -> anyhow::R
     assert!(subscription.is_empty());
 
     // Kill WS primary and ensure we can still fail over to WS fallback.
-    drop(anvil_primary);
+    safe_drop_anvil(anvil_primary);
 
     tokio::spawn(async move {
         // sleep just enough before mining to ensure subscription switches to this fallback provider
@@ -166,7 +168,7 @@ async fn test_mixed_fallback_ordering_ws_to_http_to_ws() -> anyhow::Result<()> {
     assert_eq!(block.number, 1);
 
     // Kill WS primary to force failover to HTTP fallback.
-    drop(anvil_ws_primary);
+    safe_drop_anvil(anvil_ws_primary);
     let http_clone = http_fallback.clone();
     let http_mining_task = tokio::spawn(async move {
         tokio::time::sleep(BUFFER_TIME).await;
@@ -202,7 +204,7 @@ async fn test_mixed_fallback_ordering_ws_to_http_to_ws() -> anyhow::Result<()> {
     }
 
     // Now kill HTTP fallback too, and ensure we can fail over to WS fallback.
-    drop(anvil_http);
+    safe_drop_anvil(anvil_http);
     let ws2_clone = ws_fallback.clone();
     tokio::spawn(async move {
         // Wait long enough for:
@@ -328,7 +330,7 @@ async fn test_failover_ws_to_http_on_provider_death() -> anyhow::Result<()> {
     assert!(subscription.is_empty());
 
     // Kill WS provider - this will cause subscription to fail
-    drop(anvil_ws);
+    safe_drop_anvil(anvil_ws);
 
     // Spawn task to mine repeatedly on HTTP after timeout triggers failover.
     // Mining just once can be flaky if it happens before the HTTP poller is fully established.
@@ -386,7 +388,7 @@ async fn test_failover_http_to_ws_on_provider_death() -> anyhow::Result<()> {
     assert_eq!(block.number, 1, "Should start on HTTP primary");
 
     // Kill HTTP provider
-    drop(anvil_http);
+    safe_drop_anvil(anvil_http);
 
     // Mine on WS shortly after HTTP error is detected.
     // The HTTP poll will fail quickly (connection refused), triggering immediate failover to WS.
@@ -590,7 +592,7 @@ async fn test_all_providers_fail_returns_error() -> anyhow::Result<()> {
         .expect("recv error");
 
     // Kill the only provider
-    drop(anvil);
+    safe_drop_anvil(anvil);
 
     // Next recv should eventually error (after timeout)
     let result = tokio::time::timeout(Duration::from_secs(5), subscription.recv()).await;
@@ -693,7 +695,7 @@ async fn test_poll_interval_propagated_from_builder() -> anyhow::Result<()> {
     assert!(subscription.is_empty());
 
     // Kill WS to force failover to HTTP
-    drop(anvil_ws);
+    safe_drop_anvil(anvil_ws);
 
     // Mine on HTTP and wait for failover
     let http_clone = http_provider.clone();
@@ -774,7 +776,7 @@ async fn test_http_reconnect_validates_provider() -> anyhow::Result<()> {
     assert_eq!(block.number, 1);
 
     // Kill primary - subscription should failover to fallback
-    drop(anvil_primary);
+    safe_drop_anvil(anvil_primary);
 
     // Trigger failover by waiting for timeout, then mine on fallback
     let fb_clone = fallback.clone();
@@ -844,8 +846,8 @@ async fn test_timeout_triggered_failover_with_multiple_fallbacks() -> anyhow::Re
     assert_eq!(block.number, 1);
 
     // Kill primary AND fallback1 - only fallback2 will work
-    drop(anvil_primary);
-    drop(anvil_fb1);
+    safe_drop_anvil(anvil_primary);
+    safe_drop_anvil(anvil_fb1);
 
     // Don't mine on fallback2 immediately - let timeouts trigger failover
     // After SHORT_TIMEOUT, primary poll fails -> try fallback1
@@ -895,8 +897,8 @@ async fn test_single_fallback_timeout_exhausts_providers() -> anyhow::Result<()>
     assert_eq!(block.number, 1);
 
     // Kill both providers
-    drop(anvil_primary);
-    drop(anvil_fb);
+    safe_drop_anvil(anvil_primary);
+    safe_drop_anvil(anvil_fb);
 
     // Don't mine anything - let it timeout and exhaust providers
     let result = tokio::time::timeout(Duration::from_secs(3), subscription.recv()).await;

tests/rpc_failover.rs

@@ -12,6 +12,8 @@ use alloy::{
 };
 use robust_provider::{Error, RobustProviderBuilder};
 
+use crate::common::safe_drop_anvil;
+
 // ============================================================================
 // RPC Failover Tests
 // ============================================================================
@@ -39,7 +41,7 @@ async fn test_rpc_failover_when_primary_dead() -> anyhow::Result<()> {
     assert_eq!(block_num, 10);
 
     // Kill primary
-    drop(anvil_primary);
+    safe_drop_anvil(anvil_primary);
 
     // Should failover to fallback
     let block_num = robust.get_block_number().await?;
@@ -71,8 +73,8 @@ async fn test_rpc_cycles_through_multiple_fallbacks() -> anyhow::Result<()> {
         .await?;
 
     // Kill primary and first fallback
-    drop(anvil_primary);
-    drop(anvil_fb1);
+    safe_drop_anvil(anvil_primary);
+    safe_drop_anvil(anvil_fb1);
 
     // give some time so that OS can actually finish killing Anvil processes
     tokio::time::sleep(Duration::from_millis(100)).await;
@@ -99,8 +101,8 @@ async fn test_rpc_all_providers_fail() -> anyhow::Result<()> {
         .await?;
 
     // Kill all providers
-    drop(anvil_primary);
-    drop(anvil_fallback);
+    safe_drop_anvil(anvil_primary);
+    safe_drop_anvil(anvil_fallback);
 
     // Should fail after trying all providers
     let result = robust.get_block_number().await;
@@ -148,7 +150,7 @@ async fn test_operation_completes_when_provider_unavailable() -> anyhow::Result<
     // Create and immediately kill provider so endpoint doesn't exist
     let anvil = Anvil::new().try_spawn()?;
     let endpoint = anvil.endpoint_url();
-    drop(anvil);
+    safe_drop_anvil(anvil);
 
     let provider = ProviderBuilder::new().connect_http(endpoint);
 
@@ -190,7 +192,7 @@ async fn test_get_accounts_failover() -> anyhow::Result<()> {
         .await?;
 
     // Kill primary
-    drop(anvil_primary);
+    safe_drop_anvil(anvil_primary);
 
     let accounts = robust.get_accounts().await?;
     assert!(!accounts.is_empty());
@@ -216,7 +218,7 @@ async fn test_get_balance_failover() -> anyhow::Result<()> {
         .await?;
 
     // Kill primary
-    drop(anvil_primary);
+    safe_drop_anvil(anvil_primary);
 
     let balance = robust.get_balance(address).await?;
     assert!(balance > alloy::primitives::U256::ZERO);
@@ -241,7 +243,7 @@ async fn test_get_block_failover() -> anyhow::Result<()> {
         .await?;
 
     // Kill primary
-    drop(anvil_primary);
+    safe_drop_anvil(anvil_primary);
 
     let block = robust.get_block_by_number(BlockNumberOrTag::Number(3)).await?;
     assert_eq!(block.header.number, 3);

tests/subscription.rs

@@ -19,6 +19,8 @@ use robust_provider::{
 use tokio::time::sleep;
 use tokio_stream::StreamExt;
 
+use crate::common::safe_drop_anvil;
+
 // ============================================================================
 // Test Helpers
 // ============================================================================
@@ -390,7 +392,7 @@ async fn test_single_fallback_provider() -> anyhow::Result<()> {
     assert_next_block!(stream, 1);
 
     // Kill primary so reconnect attempts fail
-    drop(anvil_pp);
+    safe_drop_anvil(anvil_pp);
 
     // PP -> FB
     trigger_failover(&mut stream, fallback.clone(), 1).await?;
@@ -423,7 +425,7 @@ async fn subscription_cycles_through_multiple_fallbacks() -> anyhow::Result<()>
     assert_next_block!(stream, 1);
 
     // Kill primary - all future PP reconnection attempts will fail
-    drop(anvil_pp);
+    safe_drop_anvil(anvil_pp);
 
     // PP times out -> FP1
     trigger_failover(&mut stream, fb_1.clone(), 1).await?;
@@ -468,7 +470,7 @@ async fn test_many_fallback_providers() -> anyhow::Result<()> {
     assert_next_block!(stream, 1);
 
     // Kill primary
-    drop(anvil_pp);
+    safe_drop_anvil(anvil_pp);
 
     // Cycle through all fallbacks
     trigger_failover(&mut stream, fb_1.clone(), 1).await?;
@@ -668,7 +670,7 @@ async fn test_multiple_failed_reconnection_attempts() -> anyhow::Result<()> {
     assert_next_block!(stream, 1);
 
     // Kill primary
-    drop(anvil_pp);
+    safe_drop_anvil(anvil_pp);
 
     // Failover to fb_1 (primary is dead)
     trigger_failover(&mut stream, fb_1.clone(), 1).await?;
@@ -739,7 +741,7 @@ async fn test_backend_gone_error_propagation() -> anyhow::Result<()> {
     assert_next_block!(stream, 1);
 
     // Kill the provider
-    drop(anvil);
+    safe_drop_anvil(anvil);
 
     // Should get BackendGone or Timeout error
     assert!(matches!(stream.next().await.unwrap(), Err(Error::Timeout)));
@@ -764,7 +766,7 @@ async fn test_immediate_consecutive_failures() -> anyhow::Result<()> {
     assert_next_block!(stream, 1);
 
     // Kill provider immediately
-    drop(anvil);
+    safe_drop_anvil(anvil);
 
     // First failure
     assert!(matches!(stream.next().await.unwrap(), Err(Error::Timeout)));