address comments

Author: colinlyguo

Cargo.lock

@@ -16,3 +16,4 @@ scroll-alloy-network = { workspace = true }
 tokio = { workspace = true, features = ["rt", "time"] }
 eyre = { workspace = true }
 getrandom = { workspace = true }
+tracing = { workspace = true }

tests/Cargo.toml

@@ -12,6 +12,12 @@ pub struct DockerComposeEnv {
 }
 
 impl DockerComposeEnv {
+    /// The sequencer node RPC URL for the Docker Compose environment.
+    const SEQUENCER_RPC_URL: &str = "http://localhost:8545";
+
+    /// The follower node RPC URL for the Docker Compose environment.
+    const FOLLOWER_RPC_URL: &str = "http://localhost:8547";
+
     // ===== CONSTRUCTOR AND LIFECYCLE =====
 
     /// Create a new DockerComposeEnv and wait for all services to be ready
@@ -22,7 +28,7 @@ impl DockerComposeEnv {
         let project_name = format!("test-{test_name}-{timestamp}");
         let compose_file = "docker-compose.test.yml".to_string();
 
-        println!("🚀 Starting test environment: {project_name}");
+        tracing::info!("🚀 Starting test environment: {project_name}");
 
         // Pre-cleanup existing containers to avoid conflicts
         Self::cleanup(&compose_file, &project_name);
@@ -31,16 +37,16 @@ impl DockerComposeEnv {
         let env = Self::start_environment(&compose_file, &project_name)?;
 
         // Wait for all services to be ready
-        println!("⏳ Waiting for services to be ready...");
+        tracing::info!("⏳ Waiting for services to be ready...");
         env.wait_for_sequencer_ready().await?;
         env.wait_for_follower_ready().await?;
 
-        println!("✅ All services are ready!");
+        tracing::info!("✅ All services are ready!");
         Ok(env)
     }
 
     fn start_environment(compose_file: &str, project_name: &str) -> Result<Self> {
-        println!("📦 Starting docker-compose services...");
+        tracing::info!("📦 Starting docker-compose services...");
 
         let mut child = Command::new("docker")
             .args([
@@ -63,14 +69,14 @@ impl DockerComposeEnv {
             use std::io::{BufRead, BufReader};
             let reader = BufReader::new(stdout);
             for line in reader.lines().map_while(Result::ok) {
-                println!("📦 Docker: {line}");
+                tracing::debug!("📦 Docker: {line}");
             }
         }
 
         let output = child.wait_with_output().expect("Failed to wait for docker-compose");
 
         if !output.status.success() {
-            eprintln!("Docker-compose stderr: {}", String::from_utf8_lossy(&output.stderr));
+            tracing::error!("Docker-compose stderr: {}", String::from_utf8_lossy(&output.stderr));
 
             // Show logs for debugging before returning error
             Self::show_all_container_logs(compose_file, project_name);
@@ -83,7 +89,7 @@ impl DockerComposeEnv {
 
     /// Cleanup the environment
     fn cleanup(compose_file: &str, project_name: &str) {
-        println!("🧹 Cleaning up environment: {project_name}");
+        tracing::info!("🧹 Cleaning up environment: {project_name}");
 
         let _result = Command::new("docker")
             .args([
@@ -100,31 +106,19 @@ impl DockerComposeEnv {
             ])
             .output();
 
-        println!("✅ Cleanup completed");
-    }
-
-    // ===== INTERNAL CONFIGURATION =====
-
-    /// Get Sequencer RPC URL
-    fn get_sequencer_rpc_url(&self) -> String {
-        "http://localhost:8545".to_string()
-    }
-
-    /// Get Follower RPC URL
-    fn get_follower_rpc_url(&self) -> String {
-        "http://localhost:8547".to_string()
+        tracing::info!("✅ Cleanup completed");
     }
 
     // ===== READINESS CHECKS =====
 
     /// Wait for sequencer to be ready
     async fn wait_for_sequencer_ready(&self) -> Result<()> {
-        Self::wait_for_l2_node_ready(&self.get_sequencer_rpc_url(), 30).await
+        Self::wait_for_l2_node_ready(Self::SEQUENCER_RPC_URL, 30).await
     }
 
     /// Wait for follower to be ready
     async fn wait_for_follower_ready(&self) -> Result<()> {
-        Self::wait_for_l2_node_ready(&self.get_follower_rpc_url(), 30).await
+        Self::wait_for_l2_node_ready(Self::FOLLOWER_RPC_URL, 30).await
     }
 
     /// Wait for L2 node to be ready
@@ -137,17 +131,19 @@ impl DockerComposeEnv {
             {
                 Ok(provider) => match provider.get_chain_id().await {
                     Ok(chain_id) => {
-                        println!("✅ L2 node ready - Chain ID: {chain_id}");
+                        tracing::info!("✅ L2 node ready - Chain ID: {chain_id}");
                         return Ok(());
                     }
                     Err(e) => {
                         let attempt = i + 1;
-                        println!("⏳ L2 node not ready yet (attempt {attempt}/{max_retries}): {e}");
+                        tracing::warn!(
+                            "⏳ L2 node not ready yet (attempt {attempt}/{max_retries}): {e}"
+                        );
                     }
                 },
                 Err(e) => {
                     let attempt = i + 1;
-                    println!("⏳ Waiting for L2 node (attempt {attempt}/{max_retries}): {e}");
+                    tracing::warn!("⏳ Waiting for L2 node (attempt {attempt}/{max_retries}): {e}");
                 }
             }
             tokio::time::sleep(Duration::from_secs(2)).await;
@@ -163,7 +159,7 @@ impl DockerComposeEnv {
     pub async fn get_sequencer_provider(&self) -> Result<impl Provider<Scroll>> {
         ProviderBuilder::<_, _, Scroll>::default()
             .with_recommended_fillers()
-            .connect(&self.get_sequencer_rpc_url())
+            .connect(Self::SEQUENCER_RPC_URL)
             .await
             .map_err(|e| eyre::eyre!("Failed to connect to sequencer: {}", e))
     }
@@ -172,7 +168,7 @@ impl DockerComposeEnv {
     pub async fn get_follower_provider(&self) -> Result<impl Provider<Scroll>> {
         ProviderBuilder::<_, _, Scroll>::default()
             .with_recommended_fillers()
-            .connect(&self.get_follower_rpc_url())
+            .connect(Self::FOLLOWER_RPC_URL)
             .await
             .map_err(|e| eyre::eyre!("Failed to connect to follower: {}", e))
     }
@@ -181,7 +177,7 @@ impl DockerComposeEnv {
 
     /// Show logs for all containers
     fn show_all_container_logs(compose_file: &str, project_name: &str) {
-        println!("🔍 Getting all container logs...");
+        tracing::info!("🔍 Getting all container logs...");
 
         let logs_output = Command::new("docker")
             .args(["compose", "-f", compose_file, "-p", project_name, "logs"])
@@ -191,10 +187,10 @@ impl DockerComposeEnv {
             let stdout = String::from_utf8_lossy(&logs.stdout);
             let stderr = String::from_utf8_lossy(&logs.stderr);
             if !stdout.trim().is_empty() {
-                eprintln!("❌ All container logs (stdout):\n{stdout}");
+                tracing::error!("❌ All container logs (stdout):\n{stdout}");
             }
             if !stderr.trim().is_empty() {
-                eprintln!("❌ All container logs (stderr):\n{stderr}");
+                tracing::error!("❌ All container logs (stderr):\n{stderr}");
             }
         }
     }

tests/src/docker_compose.rs

@@ -8,24 +8,24 @@ use tests::DockerComposeEnv;
 
 #[tokio::test]
 async fn test_docker_block_production() -> Result<()> {
-    println!("=== STARTING test_docker_block_production ===");
+    tracing::info!("=== STARTING test_docker_block_production ===");
     let env = DockerComposeEnv::new("block-production").await?;
 
     let sequencer = env.get_sequencer_provider().await?;
-    println!("✅ Sequencer provider created");
+    tracing::info!("✅ Sequencer provider created");
 
     let initial_block = sequencer.get_block_number().await?;
-    println!("Initial block number: {initial_block}");
+    tracing::info!("Initial block number: {initial_block}");
 
     let final_block = wait_for_sequencer_blocks(&sequencer, 20).await?;
-    println!("Final block number: {final_block}");
+    tracing::info!("Final block number: {final_block}");
 
     assert!(
         final_block >= initial_block + 5,
         "Sequencer should have produced at least 5 new blocks."
     );
 
-    println!("✅ Block production test completed successfully!");
+    tracing::info!("✅ Block production test completed successfully!");
     Ok(())
 }
 
@@ -36,13 +36,15 @@ async fn wait_for_sequencer_blocks(
 ) -> Result<u64> {
     let start_block = sequencer.get_block_number().await?;
     let target_block = start_block + num_blocks;
-    println!("⏳ Waiting for sequencer to produce {num_blocks} blocks (target: {target_block})...");
+    tracing::info!(
+        "⏳ Waiting for sequencer to produce {num_blocks} blocks (target: {target_block})..."
+    );
 
     for _ in 0..10 {
         // 10 second timeout
         let current_block = sequencer.get_block_number().await?;
         if current_block >= target_block {
-            println!("✅ Sequencer reached block {current_block}");
+            tracing::info!("✅ Sequencer reached block {current_block}");
             return Ok(current_block);
         }
         tokio::time::sleep(Duration::from_secs(1)).await;

tests/tests/block_production.rs

@@ -9,32 +9,32 @@ use tests::DockerComposeEnv;
 
 #[tokio::test]
 async fn test_docker_block_propagation() -> Result<()> {
-    println!("=== STARTING test_docker_block_propagation ===");
+    tracing::info!("=== STARTING test_docker_block_propagation ===");
     let env = DockerComposeEnv::new("basic-block-propagation").await?;
 
     let sequencer = env.get_sequencer_provider().await?;
-    println!("✅ Sequencer provider created");
+    tracing::info!("✅ Sequencer provider created");
 
     let follower = env.get_follower_provider().await?;
-    println!("✅ Follower provider created");
+    tracing::info!("✅ Follower provider created");
 
     let s_chain_id = sequencer.get_chain_id().await?;
     let f_chain_id = follower.get_chain_id().await?;
-    println!(
+    tracing::info!(
         "✅ Sequencer (Chain ID: {s_chain_id}) & Follower (Chain ID: {f_chain_id}) connected."
     );
     assert_eq!(s_chain_id, f_chain_id, "Chain IDs must match");
 
     let target_block = wait_for_sequencer_blocks(&sequencer, 20).await?;
-    println!("Sequencer produced {target_block} blocks, now waiting for follower sync...");
+    tracing::info!("Sequencer produced {target_block} blocks, now waiting for follower sync...");
 
     wait_for_follower_sync(&follower, target_block).await?;
-    println!("Follower synced to block {target_block}");
+    tracing::info!("Follower synced to block {target_block}");
 
     for block_num in 1..=target_block {
         verify_blocks_match(&sequencer, &follower, block_num).await?;
     }
-    println!("✅ Block hashes match for all blocks up to {target_block}, Basic block propagation test completed successfully!");
+    tracing::info!("✅ Block hashes match for all blocks up to {target_block}, Basic block propagation test completed successfully!");
 
     Ok(())
 }
@@ -46,13 +46,15 @@ async fn wait_for_sequencer_blocks(
 ) -> Result<u64> {
     let start_block = sequencer.get_block_number().await?;
     let target_block = start_block + num_blocks;
-    println!("⏳ Waiting for sequencer to produce {num_blocks} blocks (target: {target_block})...",);
+    tracing::info!(
+        "⏳ Waiting for sequencer to produce {num_blocks} blocks (target: {target_block})..."
+    );
 
     for _ in 0..10 {
         // 10 second timeout
         let current_block = sequencer.get_block_number().await?;
         if current_block >= target_block {
-            println!("✅ Sequencer reached block {current_block}");
+            tracing::info!("✅ Sequencer reached block {current_block}");
             return Ok(current_block);
         }
         tokio::time::sleep(Duration::from_secs(1)).await;
@@ -62,13 +64,13 @@ async fn wait_for_sequencer_blocks(
 
 /// Waits for the follower to sync up to the target block.
 async fn wait_for_follower_sync(follower: &impl Provider<Scroll>, target_block: u64) -> Result<()> {
-    println!("⏳ Waiting for follower to sync to block {target_block}...");
+    tracing::info!("⏳ Waiting for follower to sync to block {target_block}...");
 
     for _ in 0..10 {
         // 10 second timeout
         let follower_block = follower.get_block_number().await?;
         if follower_block >= target_block {
-            println!("✅ Follower synced to block {follower_block}");
+            tracing::info!("✅ Follower synced to block {follower_block}");
             return Ok(());
         }
         tokio::time::sleep(Duration::from_secs(1)).await;
@@ -105,6 +107,6 @@ async fn verify_blocks_match(
         );
     }
 
-    println!("✅ Block {block_number} matches: hash={seq_hash:?}");
+    tracing::debug!("✅ Block {block_number} matches: hash={seq_hash:?}");
     Ok(())
 }