Clean up tests

Author: niran

crates/simulator/src/core.rs

@@ -12,9 +12,9 @@ pub trait BundleSimulator: Send + Sync {
     async fn simulate(&self, request: &SimulationRequest) -> Result<()>;
 }
 
-/// Production bundle simulator for Reth
-/// This is the Reth-specific implementation
-pub struct RethBundleSimulator<E, P>
+/// Production bundle simulator implementation
+/// Wires the engine and publisher together for bundle simulation
+pub struct BundleSimulatorImpl<E, P>
 where
     E: SimulationEngine,
     P: SimulationPublisher,
@@ -23,7 +23,7 @@ where
     publisher: P,
 }
 
-impl<E, P> RethBundleSimulator<E, P>
+impl<E, P> BundleSimulatorImpl<E, P>
 where
     E: SimulationEngine,
     P: SimulationPublisher,
@@ -34,7 +34,7 @@ where
 }
 
 #[async_trait]
-impl<E, P> BundleSimulator for RethBundleSimulator<E, P>
+impl<E, P> BundleSimulator for BundleSimulatorImpl<E, P>
 where
     E: SimulationEngine + 'static,
     P: SimulationPublisher + 'static,

crates/simulator/src/lib.rs

@@ -15,7 +15,7 @@ use std::sync::Arc;
 use tracing::{error, info};
 
 pub use config::SimulatorNodeConfig;
-pub use core::{BundleSimulator, RethBundleSimulator};
+pub use core::{BundleSimulator, BundleSimulatorImpl};
 pub use engine::{RethSimulationEngine, SimulationEngine};
 pub use listeners::{ExExEventListener, MempoolEventListener, MempoolListenerConfig};
 pub use publisher::{SimulationPublisher, TipsSimulationPublisher};
@@ -24,7 +24,7 @@ pub use worker_pool::SimulationWorkerPool;
 
 // Type aliases for concrete implementations
 pub type TipsBundleSimulator<Node> =
-    RethBundleSimulator<RethSimulationEngine<Node>, TipsSimulationPublisher>;
+    BundleSimulatorImpl<RethSimulationEngine<Node>, TipsSimulationPublisher>;
 pub type TipsExExEventListener<Node> =
     ExExEventListener<Node, TipsBundleSimulator<Node>, tips_datastore::PostgresDatastore>;
 pub type TipsMempoolEventListener<Node> = MempoolEventListener<Node, TipsBundleSimulator<Node>>;
@@ -47,7 +47,7 @@ async fn init_dependencies<Node>(
     database_url: String,
     kafka_brokers: String,
     kafka_topic: String,
-) -> Result<ListenerDependencies<RethBundleSimulator<RethSimulationEngine<Node>, TipsSimulationPublisher>>>
+) -> Result<ListenerDependencies<BundleSimulatorImpl<RethSimulationEngine<Node>, TipsSimulationPublisher>>>
 where
     Node: FullNodeComponents,
     <Node as FullNodeComponents>::Evm: ConfigureEvm<NextBlockEnvCtx = OpNextBlockEnvAttributes>,
@@ -75,7 +75,7 @@ where
     let engine = RethSimulationEngine::new(Arc::clone(&provider), evm_config);
     info!("Simulation engine initialized");
 
-    let simulator = RethBundleSimulator::new(engine, publisher);
+    let simulator = BundleSimulatorImpl::new(engine, publisher);
     info!("Core bundle simulator initialized");
 
     Ok(ListenerDependencies {

crates/simulator/tests/bundle_simulator_impl_test.rs

@@ -0,0 +1,178 @@
+// Tests for the concrete BundleSimulator implementation
+mod common;
+
+use common::builders::*;
+use common::fixtures::*;
+use common::mocks::*;
+use tips_simulator::{core::BundleSimulator, core::BundleSimulatorImpl, SimulationError};
+use uuid::Uuid;
+
+#[tokio::test]
+async fn test_bundle_simulator_impl_successful_flow() {
+    // Setup - exercise the concrete BundleSimulator implementation
+    let bundle_id = Uuid::new_v4();
+    let expected_result = SimulationResultBuilder::successful()
+        .with_ids(Uuid::new_v4(), bundle_id)
+        .with_gas_used(250_000)
+        .with_execution_time_us(2500)
+        .build();
+
+    let engine = MockSimulationEngine::new().with_result(expected_result.clone());
+    let publisher = MockSimulationPublisher::new();
+    let simulator = BundleSimulatorImpl::new(engine.clone(), publisher.clone());
+
+    let request = SimulationRequestBuilder::new()
+        .with_bundle_id(bundle_id)
+        .with_bundle(bundles::single_tx_bundle())
+        .build();
+
+    // Act - test the actual BundleSimulator trait implementation
+    let result = simulator.simulate(&request).await;
+
+    // Assert
+    assert!(result.is_ok());
+    assert_eq!(engine.simulation_count(), 1);
+    assert_eq!(publisher.published_count(), 1);
+
+    let published = publisher.get_published();
+    assert_eq!(published[0].bundle_id, bundle_id);
+    assert_eq!(published[0].gas_used, Some(250_000));
+    assert!(published[0].success);
+}
+
+#[tokio::test]
+async fn test_bundle_simulator_impl_engine_failure() {
+    // Test that the concrete BundleSimulator handles engine failures
+    let bundle_id = Uuid::new_v4();
+    let engine = MockSimulationEngine::new().fail_next_with(SimulationError::OutOfGas);
+    let publisher = MockSimulationPublisher::new();
+    let simulator = BundleSimulatorImpl::new(engine.clone(), publisher.clone());
+
+    let request = SimulationRequestBuilder::new()
+        .with_bundle_id(bundle_id)
+        .build();
+
+    // Act
+    let result = simulator.simulate(&request).await;
+
+    // Assert - simulate() should succeed even if the engine simulation fails
+    assert!(result.is_ok());
+    assert_eq!(engine.simulation_count(), 1);
+    assert_eq!(publisher.published_count(), 1);
+
+    let published = publisher.get_published();
+    assert!(!published[0].success);
+    assert!(published[0].error_reason.is_some());
+}
+
+#[tokio::test]
+async fn test_bundle_simulator_impl_publisher_failure() {
+    // Test that the concrete BundleSimulator handles publisher failures gracefully
+    let engine = MockSimulationEngine::new();
+    let publisher = MockSimulationPublisher::new().fail_next();
+    let simulator = BundleSimulatorImpl::new(engine.clone(), publisher.clone());
+
+    let request = SimulationRequestBuilder::new().build();
+
+    // Act - should complete without error even if publisher fails
+    let result = simulator.simulate(&request).await;
+
+    // Assert
+    assert!(result.is_ok());
+    assert_eq!(engine.simulation_count(), 1);
+    assert_eq!(publisher.published_count(), 0); // Publisher failed
+}
+
+#[tokio::test]
+async fn test_bundle_simulator_impl_multiple_simulations() {
+    // Test the concrete BundleSimulator with multiple sequential simulations
+    let engine = MockSimulationEngine::new();
+    let publisher = MockSimulationPublisher::new();
+    let simulator = BundleSimulatorImpl::new(engine.clone(), publisher.clone());
+
+    // Run multiple simulations with different bundle IDs
+    for i in 0..3 {
+        let bundle_id = Uuid::new_v4();
+        let result = SimulationResultBuilder::successful()
+            .with_ids(Uuid::new_v4(), bundle_id)
+            .with_gas_used(100_000 + i * 50_000)
+            .build();
+
+        let _ = engine.clone().with_result(result);
+
+        let request = SimulationRequestBuilder::new()
+            .with_bundle_id(bundle_id)
+            .with_bundle(
+                TestBundleBuilder::new()
+                    .with_simple_transaction(&[i as u8, 0x01, 0x02])
+                    .build(),
+            )
+            .build();
+
+        let sim_result = simulator.simulate(&request).await;
+        assert!(sim_result.is_ok());
+    }
+
+    // Verify all simulations were processed
+    assert_eq!(engine.simulation_count(), 3);
+    assert_eq!(publisher.published_count(), 3);
+
+    let published = publisher.get_published();
+    assert_eq!(published.len(), 3);
+    for (i, result) in published.iter().enumerate() {
+        assert!(result.success);
+        assert_eq!(result.gas_used, Some(100_000 + i as u64 * 50_000));
+    }
+}
+
+#[tokio::test]
+async fn test_bundle_simulator_impl_various_error_types() {
+    // Test the concrete BundleSimulator with different types of simulation errors
+    let errors = vec![
+        SimulationError::Revert {
+            reason: "Contract reverted".to_string(),
+        },
+        SimulationError::InvalidNonce {
+            tx_index: 1,
+            expected: 10,
+            actual: 5,
+        },
+        SimulationError::InsufficientBalance {
+            tx_index: 0,
+            required: alloy_primitives::U256::from(1000000),
+            available: alloy_primitives::U256::from(500000),
+        },
+        SimulationError::StateAccessError {
+            message: "RPC timeout".to_string(),
+        },
+        SimulationError::Timeout,
+    ];
+
+    for (_i, error) in errors.into_iter().enumerate() {
+        let engine = MockSimulationEngine::new().fail_next_with(error.clone());
+        let publisher = MockSimulationPublisher::new();
+        let simulator = BundleSimulatorImpl::new(engine.clone(), publisher.clone());
+
+        let request = SimulationRequestBuilder::new()
+            .with_bundle_id(Uuid::new_v4())
+            .build();
+
+        let result = simulator.simulate(&request).await;
+        assert!(result.is_ok());
+
+        let published = publisher.get_published();
+        assert_eq!(published.len(), 1);
+        assert!(!published[0].success);
+
+        let error_msg = published[0].error_reason.as_ref().unwrap();
+        match error {
+            SimulationError::Revert { .. } => assert!(error_msg.contains("reverted")),
+            SimulationError::InvalidNonce { .. } => assert!(error_msg.contains("nonce")),
+            SimulationError::InsufficientBalance { .. } => assert!(error_msg.contains("balance")),
+            SimulationError::StateAccessError { .. } => assert!(error_msg.contains("State access")),
+            SimulationError::Timeout => assert!(error_msg.contains("timed out")),
+            _ => {}
+        }
+    }
+}
+

crates/simulator/tests/common/builders.rs

@@ -1,4 +1,7 @@
+#![allow(dead_code)]
+
 /// Test data builders for creating complex test scenarios
+
 use alloy_primitives::{Address, Bytes, B256, U256};
 use alloy_rpc_types_mev::EthSendBundle;
 use std::collections::HashMap;
@@ -277,51 +280,3 @@ impl ScenarioBuilder {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_bundle_builder() {
-        let bundle = TestBundleBuilder::new()
-            .with_simple_transaction(&[0x01, 0x02])
-            .with_simple_transaction(&[0x03, 0x04])
-            .with_block_number(18_500_000)
-            .with_timestamps(1000, 2000)
-            .build();
-
-        assert_eq!(bundle.txs.len(), 2);
-        assert_eq!(bundle.block_number, 18_500_000);
-        assert_eq!(bundle.min_timestamp, Some(1000));
-        assert_eq!(bundle.max_timestamp, Some(2000));
-    }
-
-    #[test]
-    fn test_result_builder() {
-        let bundle_id = Uuid::new_v4();
-        let result = SimulationResultBuilder::successful()
-            .with_ids(Uuid::new_v4(), bundle_id)
-            .with_gas_used(200_000)
-            .with_state_change(Address::random(), U256::from(1), U256::from(100))
-            .build();
-
-        assert!(result.success);
-        assert_eq!(result.bundle_id, bundle_id);
-        assert_eq!(result.gas_used, Some(200_000));
-        assert!(!result.state_diff.is_empty());
-    }
-
-    #[test]
-    fn test_scenario_builder() {
-        let requests = ScenarioBuilder::new()
-            .with_block(19_000_000, B256::random())
-            .add_simple_bundle(2)
-            .add_simple_bundle(3)
-            .build_requests();
-
-        assert_eq!(requests.len(), 2);
-        assert_eq!(requests[0].block_number, 19_000_000);
-        assert_eq!(requests[0].bundle.txs.len(), 2);
-        assert_eq!(requests[1].bundle.txs.len(), 3);
-    }
-}

crates/simulator/tests/common/fixtures.rs

@@ -1,4 +1,7 @@
+#![allow(dead_code)]
+
 /// Test fixtures and pre-configured test data
+
 use alloy_primitives::Bytes;
 use alloy_rpc_types_mev::EthSendBundle;
 
@@ -141,38 +144,3 @@ pub mod scenarios {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_fixture_addresses() {
-        assert_ne!(*addresses::ALICE, *addresses::BOB);
-        assert_ne!(*addresses::CONTRACT_A, *addresses::CONTRACT_B);
-    }
-
-    #[test]
-    fn test_fixture_bundles() {
-        let single = bundles::single_tx_bundle();
-        assert_eq!(single.txs.len(), 1);
-
-        let multi = bundles::multi_tx_bundle();
-        assert_eq!(multi.txs.len(), 3);
-
-        let large = bundles::large_bundle(100);
-        assert_eq!(large.txs.len(), 100);
-    }
-
-    #[test]
-    fn test_fixture_scenarios() {
-        let request = scenarios::basic_simulation();
-        assert_eq!(request.block_number, blocks::BLOCK_18M);
-        assert_eq!(request.bundle.txs.len(), 1);
-
-        let interaction = scenarios::contract_interaction();
-        assert_eq!(interaction.bundle.txs.len(), 3);
-
-        let large_scenario = scenarios::large_bundle_scenario();
-        assert_eq!(large_scenario.bundle.txs.len(), 100);
-    }
-}

crates/simulator/tests/common/mock_bundle_simulator.rs

@@ -1,3 +1,5 @@
+#![allow(dead_code)]
+
 use crate::common::mocks::{MockSimulationEngine, MockSimulationPublisher};
 use async_trait::async_trait;
 use eyre::Result;
@@ -55,25 +57,3 @@ impl BundleSimulator for MockBundleSimulator {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::common;
-
-    #[tokio::test]
-    async fn test_mock_bundle_simulator() {
-        let engine = MockSimulationEngine::new();
-        let publisher = MockSimulationPublisher::new();
-        let simulator = MockBundleSimulator::new(engine.clone(), publisher.clone());
-
-        let bundle = common::create_test_bundle(1, 18_000_000);
-        let request = common::create_test_request(bundle);
-
-        // Use the clean trait interface
-        let result = simulator.simulate(&request).await;
-
-        assert!(result.is_ok());
-        assert_eq!(engine.simulation_count(), 1);
-        assert_eq!(publisher.published_count(), 1);
-    }
-}