feat(forge): exit test run gracefully if show progress (#12290)

feat(forge): exit test gracefully if show progress

Author: grandizzy

crates/evm/evm/src/executors/fuzz/mod.rs

@@ -1,5 +1,5 @@
 use crate::executors::{
-    DURATION_BETWEEN_METRICS_REPORT, Executor, FailFast, FuzzTestTimer, RawCallResult,
+    DURATION_BETWEEN_METRICS_REPORT, EarlyExit, Executor, FuzzTestTimer, RawCallResult,
 };
 use alloy_dyn_abi::JsonAbiExt;
 use alloy_json_abi::Function;
@@ -102,7 +102,7 @@ impl FuzzedExecutor {
         address: Address,
         rd: &RevertDecoder,
         progress: Option<&ProgressBar>,
-        fail_fast: &FailFast,
+        early_exit: &EarlyExit,
     ) -> Result<FuzzTestResult> {
         // Stores the fuzz test execution data.
         let mut test_data = FuzzTestData::default();
@@ -132,7 +132,7 @@ impl FuzzedExecutor {
         let mut last_metrics_report = Instant::now();
         let max_runs = self.config.runs;
         let continue_campaign = |runs: u32| {
-            if fail_fast.should_stop() {
+            if early_exit.should_stop() {
                 return false;
             }
 

crates/evm/evm/src/executors/invariant/mod.rs

@@ -52,7 +52,7 @@ use serde_json::json;
 
 mod shrink;
 use crate::executors::{
-    DURATION_BETWEEN_METRICS_REPORT, EvmError, FailFast, FuzzTestTimer, corpus::CorpusManager,
+    DURATION_BETWEEN_METRICS_REPORT, EarlyExit, EvmError, FuzzTestTimer, corpus::CorpusManager,
 };
 pub use shrink::check_sequence;
 
@@ -330,7 +330,7 @@ impl<'a> InvariantExecutor<'a> {
         fuzz_fixtures: &FuzzFixtures,
         deployed_libs: &[Address],
         progress: Option<&ProgressBar>,
-        fail_fast: &FailFast,
+        early_exit: &EarlyExit,
     ) -> Result<InvariantFuzzTestResult> {
         // Throw an error to abort test run if the invariant function accepts input params
         if !invariant_contract.invariant_function.inputs.is_empty() {
@@ -345,7 +345,7 @@ impl<'a> InvariantExecutor<'a> {
         let timer = FuzzTestTimer::new(self.config.timeout);
         let mut last_metrics_report = Instant::now();
         let continue_campaign = |runs: u32| {
-            if fail_fast.should_stop() {
+            if early_exit.should_stop() {
                 return false;
             }
 

crates/evm/evm/src/executors/invariant/replay.rs

@@ -2,7 +2,7 @@ use super::{
     call_after_invariant_function, call_invariant_function, error::FailedInvariantCaseData,
     shrink_sequence,
 };
-use crate::executors::Executor;
+use crate::executors::{EarlyExit, Executor};
 use alloy_dyn_abi::JsonAbiExt;
 use alloy_primitives::{Log, U256, map::HashMap};
 use eyre::Result;
@@ -109,6 +109,7 @@ pub fn replay_error(
     deprecated_cheatcodes: &mut HashMap<&'static str, Option<&'static str>>,
     progress: Option<&ProgressBar>,
     show_solidity: bool,
+    early_exit: &EarlyExit,
 ) -> Result<Vec<BaseCounterExample>> {
     match failed_case.test_error {
         // Don't use at the moment.
@@ -121,6 +122,7 @@ pub fn replay_error(
                 &executor,
                 invariant_contract.call_after_invariant,
                 progress,
+                early_exit,
             )?;
 
             set_up_inner_replay(&mut executor, &failed_case.inner_sequence);

crates/evm/evm/src/executors/invariant/shrink.rs

@@ -1,5 +1,5 @@
 use crate::executors::{
-    Executor,
+    EarlyExit, Executor,
     invariant::{
         call_after_invariant_function, call_invariant_function, error::FailedInvariantCaseData,
     },
@@ -43,6 +43,7 @@ pub(crate) fn shrink_sequence(
     executor: &Executor,
     call_after_invariant: bool,
     progress: Option<&ProgressBar>,
+    early_exit: &EarlyExit,
 ) -> eyre::Result<Vec<BasicTxDetails>> {
     trace!(target: "forge::test", "Shrinking sequence of {} calls.", calls.len());
 
@@ -65,6 +66,10 @@ pub(crate) fn shrink_sequence(
 
     let mut shrinker = CallSequenceShrinker::new(calls.len());
     for _ in 0..failed_case.shrink_run_limit {
+        if early_exit.should_stop() {
+            break;
+        }
+
         // Remove call at current index.
         shrinker.included_calls.clear(call_idx);
 

crates/evm/evm/src/executors/mod.rs

@@ -1130,32 +1130,33 @@ impl FuzzTestTimer {
     }
 }
 
-/// Helper struct to enable fail fast behavior: when one test fails, all other tests stop early.
+/// Helper struct to enable early exit behavior: when one test fails or run is interrupted,
+/// all other tests stop early.
 #[derive(Clone, Debug)]
-pub struct FailFast {
-    /// Shared atomic flag set to `true` when a failure occurs.
-    /// None if fail-fast is disabled.
+pub struct EarlyExit {
+    /// Shared atomic flag set to `true` when a failure occurs or ctrl-c received.
+    /// None if running without fail-fast or show-progress.
     inner: Option<Arc<AtomicBool>>,
 }
 
-impl FailFast {
-    pub fn new(fail_fast: bool) -> Self {
-        Self { inner: fail_fast.then_some(Arc::new(AtomicBool::new(false))) }
+impl EarlyExit {
+    pub fn new(early_exit: bool) -> Self {
+        Self { inner: early_exit.then_some(Arc::new(AtomicBool::new(false))) }
     }
 
     /// Returns `true` if fail-fast is enabled.
     pub fn is_enabled(&self) -> bool {
         self.inner.is_some()
     }
 
-    /// Sets the failure flag. Used by other tests to stop early.
-    pub fn record_fail(&self) {
-        if let Some(fail_fast) = &self.inner {
-            fail_fast.store(true, Ordering::Relaxed);
+    /// Sets the exit flag. Used by other tests to stop early.
+    pub fn record_exit(&self) {
+        if let Some(early_exit) = &self.inner {
+            early_exit.store(true, Ordering::Relaxed);
         }
     }
 
-    /// Whether a failure has been recorded and test should stop.
+    /// Whether tests should stop and exit early.
     pub fn should_stop(&self) -> bool {
         self.inner.as_ref().map(|flag| flag.load(Ordering::Relaxed)).unwrap_or(false)
     }

crates/forge/src/cmd/test/mod.rs

@@ -566,6 +566,7 @@ impl TestArgs {
         let mut backtrace_builder = None;
         for (contract_name, mut suite_result) in rx {
             let tests = &mut suite_result.test_results;
+            let has_tests = !tests.is_empty();
 
             // Clear the addresses and labels from previous test.
             decoder.clear_addresses();
@@ -583,7 +584,7 @@ impl TestArgs {
                 for warning in &suite_result.warnings {
                     sh_warn!("{warning}")?;
                 }
-                if !tests.is_empty() {
+                if has_tests {
                     let len = tests.len();
                     let tests = if len > 1 { "tests" } else { "test" };
                     sh_println!("Ran {len} {tests} for {contract_name}")?;
@@ -808,7 +809,7 @@ impl TestArgs {
             }
 
             // Print suite summary.
-            if !silent {
+            if !silent && has_tests {
                 sh_println!("{}", suite_result.summary())?;
             }
 

crates/forge/src/multi_runner.rs

@@ -21,7 +21,7 @@ use foundry_evm::{
     Env,
     backend::Backend,
     decode::RevertDecoder,
-    executors::{Executor, ExecutorBuilder, FailFast},
+    executors::{EarlyExit, Executor, ExecutorBuilder},
     fork::CreateFork,
     inspectors::CheatsConfig,
     opts::EvmOpts,
@@ -307,8 +307,8 @@ pub struct TestRunnerConfig {
     pub isolation: bool,
     /// Networks with enabled features.
     pub networks: NetworkConfigs,
-    /// Whether to exit early on test failure.
-    pub fail_fast: FailFast,
+    /// Whether to exit early on test failure or if test run interrupted.
+    pub early_exit: EarlyExit,
 }
 
 impl TestRunnerConfig {
@@ -601,8 +601,8 @@ impl MultiContractRunnerBuilder {
                 inline_config: Arc::new(InlineConfig::new_parsed(output, &self.config)?),
                 isolation: self.isolation,
                 networks: self.networks,
+                early_exit: EarlyExit::new(self.fail_fast || self.config.show_progress),
                 config: self.config,
-                fail_fast: FailFast::new(self.fail_fast),
             },
 
             fork: self.fork,

crates/forge/src/runner.rs

@@ -43,6 +43,7 @@ use std::{
     sync::Arc,
     time::Instant,
 };
+use tokio::signal;
 use tracing::Span;
 
 /// When running tests, we deploy all external libraries present in the project. To avoid additional
@@ -395,14 +396,22 @@ impl<'a> ContractRunner<'a> {
             return SuiteResult::new(start.elapsed(), test_results, warnings);
         }
 
-        let fail_fast = &self.tcfg.fail_fast;
+        let early_exit = &self.tcfg.early_exit;
+
+        if self.progress.is_some() {
+            let interrupt = early_exit.clone();
+            self.tokio_handle.spawn(async move {
+                signal::ctrl_c().await.expect("Failed to listen for Ctrl+C");
+                interrupt.record_exit();
+            });
+        }
 
         let test_results = functions
             .par_iter()
-            .map(|&func| {
+            .filter_map(|&func| {
                 // Early exit if we're running with fail-fast and a test already failed.
-                if fail_fast.should_stop() {
-                    return (func.signature(), TestResult::setup_result(setup.clone()));
+                if early_exit.should_stop() {
+                    return None;
                 }
 
                 let start = Instant::now();
@@ -435,10 +444,10 @@ impl<'a> ContractRunner<'a> {
 
                 // Set fail fast flag if current test failed.
                 if res.status.is_failure() {
-                    fail_fast.record_fail();
+                    early_exit.record_exit();
                 }
 
-                (sig, res)
+                Some((sig, res))
             })
             .collect::<BTreeMap<_, _>>();
 
@@ -637,7 +646,7 @@ impl<'a> FunctionRunner<'a> {
         let mut result = FuzzTestResult::default();
 
         for i in 0..fixtures_len {
-            if self.tcfg.fail_fast.should_stop() {
+            if self.tcfg.early_exit.should_stop() {
                 return self.result;
             }
 
@@ -822,7 +831,7 @@ impl<'a> FunctionRunner<'a> {
             &self.setup.fuzz_fixtures,
             &self.setup.deployed_libs,
             progress.as_ref(),
-            &self.tcfg.fail_fast,
+            &self.tcfg.early_exit,
         ) {
             Ok(x) => x,
             Err(e) => {
@@ -856,6 +865,7 @@ impl<'a> FunctionRunner<'a> {
                         &mut self.result.deprecated_cheatcodes,
                         progress.as_ref(),
                         show_solidity,
+                        &self.tcfg.early_exit,
                     ) {
                         Ok(call_sequence) => {
                             if !call_sequence.is_empty() {
@@ -973,7 +983,7 @@ impl<'a> FunctionRunner<'a> {
             self.address,
             &self.cr.mcr.revert_decoder,
             progress.as_ref(),
-            &self.tcfg.fail_fast,
+            &self.tcfg.early_exit,
         ) {
             Ok(x) => x,
             Err(e) => {