style: clean up imports and improve code formatting in e2e tests (fmt and clippy)

- Organized and standardized import statements across multiple files for better readability.
- Enhanced code formatting by removing unnecessary whitespace and aligning method calls for consistency.
- Improved the clarity of test definitions and configurations, ensuring a more maintainable codebase.

These changes contribute to a cleaner and more organized structure in the e2e test suite, facilitating easier navigation and understanding for developers.

Author: ricardo-perello

e2e-tests/src/anvil_setup.rs

@@ -1,10 +1,10 @@
-use std::time::Duration;
+use anyhow::{Context, Result};
 use std::process::Stdio;
-use tokio::time::sleep;
-use anyhow::{Result, Context};
-use tracing::{info, debug, error};
+use std::time::Duration;
 use tokio::io::{AsyncBufReadExt, BufReader};
 use tokio::process::Command as TokioCommand;
+use tokio::time::sleep;
+use tracing::{debug, error, info};
 
 pub struct AnvilInstance {
     pub rpc_url: String,
@@ -14,32 +14,31 @@ pub struct AnvilInstance {
 impl AnvilInstance {
     pub async fn start_local(private_key: &str) -> Result<Self> {
         info!("Starting local Anvil instance");
-        
+
         let mut cmd = TokioCommand::new("anvil");
         cmd.arg("--chain-id")
-           .arg("31337")
-           .arg("--accounts")
-           .arg("10")
-           .arg("--balance")
-           .arg("10000")
-           .arg("--gas-limit")
-           .arg("30000000")
-           .arg("--gas-price")
-           .arg("1000000000")
-           .arg("--block-time")
-           .arg("1")
-           .stdout(Stdio::piped())
-           .stderr(Stdio::piped());
-        
-        let mut child = cmd.spawn()
-            .context("Failed to start Anvil")?;
-        
+            .arg("31337")
+            .arg("--accounts")
+            .arg("10")
+            .arg("--balance")
+            .arg("10000")
+            .arg("--gas-limit")
+            .arg("30000000")
+            .arg("--gas-price")
+            .arg("1000000000")
+            .arg("--block-time")
+            .arg("1")
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+
+        let mut child = cmd.spawn().context("Failed to start Anvil")?;
+
         // Start log streaming for Anvil
         Self::start_log_streaming(&mut child).await;
-        
+
         // Wait a bit for Anvil to start
         sleep(Duration::from_millis(500)).await;
-        
+
         // Check if process is still running
         match child.try_wait()? {
             Some(status) => {
@@ -49,60 +48,60 @@ impl AnvilInstance {
                 info!("Anvil process started successfully");
             }
         }
-        
+
         let rpc_url = "http://127.0.0.1:8545".to_string();
-        
+
         // Wait for RPC to be ready
         Self::wait_for_rpc_ready(&rpc_url).await?;
-        
+
         // Fund the test account
         Self::fund_test_account(&rpc_url, private_key).await?;
-        
-        Ok(Self {
-            rpc_url,
-            process: Some(child),
-        })
+
+        Ok(Self { rpc_url, process: Some(child) })
     }
-    
+
     async fn wait_for_rpc_ready(rpc_url: &str) -> Result<()> {
         let client = reqwest::Client::new();
         let mut attempts = 0;
         const MAX_ATTEMPTS: u32 = 30;
-        
+
         while attempts < MAX_ATTEMPTS {
-            if let Ok(response) = client.post(rpc_url)
+            if let Ok(response) = client
+                .post(rpc_url)
                 .json(&serde_json::json!({
                     "jsonrpc": "2.0",
                     "method": "eth_blockNumber",
                     "params": [],
                     "id": 1
                 }))
                 .send()
-                .await {
+                .await
+            {
                 if response.status().is_success() {
                     info!("Anvil RPC is ready");
                     return Ok(());
                 }
             }
-            
+
             attempts += 1;
             sleep(Duration::from_millis(200)).await;
         }
-        
+
         Err(anyhow::anyhow!("Anvil RPC failed to become ready after {} attempts", MAX_ATTEMPTS))
     }
-    
+
     async fn fund_test_account(_rpc_url: &str, _private_key: &str) -> Result<()> {
         //TODO This would typically fund accounts for testing
         // For now, we'll use the default funded accounts from Anvil
         info!("Using default Anvil funded accounts");
         Ok(())
     }
-    
+
     pub async fn mine_block(&self) -> Result<()> {
         let client = reqwest::Client::new();
-        
-        let response = client.post(&self.rpc_url)
+
+        let response = client
+            .post(&self.rpc_url)
             .json(&serde_json::json!({
                 "jsonrpc": "2.0",
                 "method": "evm_mine",
@@ -111,18 +110,19 @@ impl AnvilInstance {
             }))
             .send()
             .await?;
-        
+
         if !response.status().is_success() {
             return Err(anyhow::anyhow!("Failed to mine block"));
         }
-        
+
         Ok(())
     }
-    
+
     pub async fn get_block_number(&self) -> Result<u64> {
         let client = reqwest::Client::new();
-        
-        let response = client.post(&self.rpc_url)
+
+        let response = client
+            .post(&self.rpc_url)
             .json(&serde_json::json!({
                 "jsonrpc": "2.0",
                 "method": "eth_blockNumber",
@@ -131,31 +131,31 @@ impl AnvilInstance {
             }))
             .send()
             .await?;
-        
+
         let result: serde_json::Value = response.json().await?;
-        let hex_value = result["result"].as_str()
-            .ok_or_else(|| anyhow::anyhow!("Invalid response format"))?;
-        
+        let hex_value =
+            result["result"].as_str().ok_or_else(|| anyhow::anyhow!("Invalid response format"))?;
+
         let block_number = u64::from_str_radix(hex_value.trim_start_matches("0x"), 16)?;
         Ok(block_number)
     }
-    
+
     async fn start_log_streaming(child: &mut tokio::process::Child) {
         if let Some(stdout) = child.stdout.take() {
             let reader = BufReader::new(stdout);
             let mut lines = reader.lines();
-            
+
             tokio::spawn(async move {
                 while let Ok(Some(line)) = lines.next_line().await {
                     debug!("[ANVIL] {}", line);
                 }
             });
         }
-        
+
         if let Some(stderr) = child.stderr.take() {
             let reader = BufReader::new(stderr);
             let mut lines = reader.lines();
-            
+
             tokio::spawn(async move {
                 while let Ok(Some(line)) = lines.next_line().await {
                     error!("[ANVIL ERROR] {}", line);
@@ -169,36 +169,40 @@ impl AnvilInstance {
     /// Deploy a test contract using forge
     pub async fn deploy_test_contract(&self) -> Result<String> {
         info!("Deploying SimpleERC20 test contract...");
-        
+
         let e2e_tests_dir = std::env::current_dir()?;
         let contract_path = e2e_tests_dir.join("contracts/SimpleERC20.sol:SimpleERC20");
         let output = std::process::Command::new("forge")
             .args([
                 "create",
-                "--rpc-url", &self.rpc_url,
-                "--private-key", "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+                "--rpc-url",
+                &self.rpc_url,
+                "--private-key",
+                "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
                 "--broadcast",
-                &contract_path.to_string_lossy()
+                &contract_path.to_string_lossy(),
             ])
             .current_dir(&e2e_tests_dir)
             .output()
             .context("Failed to run forge command")?;
-        
+
         if !output.status.success() {
             let stderr = String::from_utf8_lossy(&output.stderr);
             return Err(anyhow::anyhow!("Contract deployment failed: {}", stderr));
         }
-        
+
         // Parse the contract address from forge output
         let stdout = String::from_utf8_lossy(&output.stdout);
-        let address_line = stdout.lines()
+        let address_line = stdout
+            .lines()
             .find(|line| line.contains("Deployed to:"))
             .ok_or_else(|| anyhow::anyhow!("Could not find contract address in forge output"))?;
-        
-        let address = address_line.split_whitespace()
+
+        let address = address_line
+            .split_whitespace()
             .last()
             .ok_or_else(|| anyhow::anyhow!("Could not parse contract address"))?;
-        
+
         info!("Test contract deployed at: {}", address);
         Ok(address.to_string())
     }
@@ -208,8 +212,8 @@ impl Drop for AnvilInstance {
     fn drop(&mut self) {
         if let Some(mut child) = self.process.take() {
             info!("Shutting down Anvil instance");
-            let _ = child.kill();
-            // Note: tokio::process::Child doesn't have wait_timeout, 
+            std::mem::drop(child.kill());
+            // Note: tokio::process::Child doesn't have wait_timeout,
             // but the process will be cleaned up when the child is dropped
         }
     }

e2e-tests/src/docker.rs

@@ -14,12 +14,18 @@ pub async fn start_postgres_container() -> Result<(String, u16)> {
     // Run container
     let status = Command::new("docker")
         .args([
-            "run", "-d",
-            "--name", &name,
-            "-e", "POSTGRES_PASSWORD=postgres",
-            "-e", "POSTGRES_USER=postgres",
-            "-e", "POSTGRES_DB=postgres",
-            "-p", &format!("{}:5432", port),
+            "run",
+            "-d",
+            "--name",
+            &name,
+            "-e",
+            "POSTGRES_PASSWORD=postgres",
+            "-e",
+            "POSTGRES_USER=postgres",
+            "-e",
+            "POSTGRES_DB=postgres",
+            "-p",
+            &format!("{}:5432", port),
             "postgres:16",
         ])
         .output();
@@ -52,7 +58,9 @@ pub async fn start_postgres_container() -> Result<(String, u16)> {
 /// or Colima if available. Times out after ~30s if daemon is unavailable.
 pub async fn ensure_docker_daemon() -> Result<()> {
     // If docker info works, we're done
-    if docker_info_ok() { return Ok(()); }
+    if docker_info_ok() {
+        return Ok(());
+    }
 
     // Try to start Docker Desktop on macOS
     #[cfg(target_os = "macos")]
@@ -67,7 +75,9 @@ pub async fn ensure_docker_daemon() -> Result<()> {
 
     // Poll for docker daemon readiness
     for _ in 0..60 {
-        if docker_info_ok() { return Ok(()); }
+        if docker_info_ok() {
+            return Ok(());
+        }
         sleep(Duration::from_millis(500)).await;
     }
     Err(anyhow::anyhow!("Docker daemon not available after waiting"))
@@ -96,5 +106,3 @@ fn allocate_free_port() -> Result<u16> {
 async fn port_open(port: u16) -> bool {
     tokio::net::TcpStream::connect(("127.0.0.1", port)).await.is_ok()
 }
-
-

e2e-tests/src/health_client.rs

@@ -1,8 +1,8 @@
-use anyhow::{Result, Context};
+use anyhow::{Context, Result};
 use reqwest::Client;
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
-use tracing::{info, debug};
+use tracing::{debug, info};
 
 #[derive(Debug, Deserialize, Serialize)]
 pub struct HealthResponse {
@@ -32,17 +32,15 @@ pub struct HealthClient {
 
 impl HealthClient {
     pub fn new(port: u16) -> Self {
-        Self {
-            client: Client::new(),
-            base_url: format!("http://localhost:{}", port),
-        }
+        Self { client: Client::new(), base_url: format!("http://localhost:{}", port) }
     }
 
     pub async fn get_health(&self) -> Result<HealthResponse> {
         let url = format!("{}/health", self.base_url);
         debug!("Checking health at: {}", url);
-        
-        let response = self.client
+
+        let response = self
+            .client
             .get(&url)
             .timeout(Duration::from_secs(5))
             .send()
@@ -53,10 +51,8 @@ impl HealthClient {
             return Err(anyhow::anyhow!("Health endpoint returned status: {}", response.status()));
         }
 
-        let health: HealthResponse = response
-            .json()
-            .await
-            .context("Failed to parse health response")?;
+        let health: HealthResponse =
+            response.json().await.context("Failed to parse health response")?;
 
         Ok(health)
     }

e2e-tests/src/lib.rs

@@ -1,8 +1,7 @@
 pub mod anvil_setup;
+pub mod docker;
 pub mod health_client;
+pub mod live_feeder;
 pub mod rindexer_client;
 pub mod test_suite;
 pub mod tests;
-pub mod live_feeder;
-pub mod docker;
-