forge/cmd/test/

filter.rs

use alloy_json_abi::Function;
use clap::Parser;
use foundry_common::{TestFilter, TestFunctionExt};
use foundry_compilers::{FileFilter, ProjectPathsConfig};
use foundry_config::{Config, filter::GlobMatcher};
use serde::{Deserialize, Serialize};
use std::{fmt, path::Path};

/// A failed test persisted for `forge test --rerun`.
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct RerunFailure {
    /// The test suite identifier (`path:contract_name`).
    pub contract: String,
    /// The test signature or invariant predicate name.
    pub test: String,
}

/// Persisted `forge test --rerun` failures.
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct RerunFailures {
    pub version: u8,
    pub failures: Vec<RerunFailure>,
}

/// The filter to use during testing.
///
/// See also `FileFilter`.
#[derive(Clone, Parser)]
#[command(next_help_heading = "Test filtering")]
pub struct FilterArgs {
    /// Only run test functions matching the specified regex pattern.
    #[arg(long = "match-test", visible_alias = "mt", value_name = "REGEX")]
    pub test_pattern: Option<regex::Regex>,

    /// Only run test functions that do not match the specified regex pattern.
    #[arg(long = "no-match-test", visible_alias = "nmt", value_name = "REGEX")]
    pub test_pattern_inverse: Option<regex::Regex>,

    /// Only run tests in contracts matching the specified regex pattern.
    #[arg(long = "match-contract", visible_alias = "mc", value_name = "REGEX")]
    pub contract_pattern: Option<regex::Regex>,

    /// Only run tests in contracts that do not match the specified regex pattern.
    #[arg(long = "no-match-contract", visible_alias = "nmc", value_name = "REGEX")]
    pub contract_pattern_inverse: Option<regex::Regex>,

    /// Only run tests in source files matching the specified glob pattern.
    #[arg(long = "match-path", visible_alias = "mp", value_name = "GLOB")]
    pub path_pattern: Option<GlobMatcher>,

    /// Only run tests in source files that do not match the specified glob pattern.
    #[arg(
        id = "no-match-path",
        long = "no-match-path",
        visible_alias = "nmp",
        value_name = "GLOB"
    )]
    pub path_pattern_inverse: Option<GlobMatcher>,

    /// Only show coverage for files that do not match the specified regex pattern.
    #[arg(long = "no-match-coverage", visible_alias = "nmco", value_name = "REGEX")]
    pub coverage_pattern_inverse: Option<regex::Regex>,
}

impl FilterArgs {
    /// Returns true if the filter is empty.
    pub const fn is_empty(&self) -> bool {
        self.test_pattern.is_none()
            && self.test_pattern_inverse.is_none()
            && self.contract_pattern.is_none()
            && self.contract_pattern_inverse.is_none()
            && self.path_pattern.is_none()
            && self.path_pattern_inverse.is_none()
    }

    /// Merges the set filter globs with the config's values
    pub fn merge_with_config(mut self, config: &Config) -> ProjectPathsAwareFilter {
        if self.test_pattern.is_none() {
            self.test_pattern = config.test_pattern.clone().map(Into::into);
        }
        if self.test_pattern_inverse.is_none() {
            self.test_pattern_inverse = config.test_pattern_inverse.clone().map(Into::into);
        }
        if self.contract_pattern.is_none() {
            self.contract_pattern = config.contract_pattern.clone().map(Into::into);
        }
        if self.contract_pattern_inverse.is_none() {
            self.contract_pattern_inverse = config.contract_pattern_inverse.clone().map(Into::into);
        }
        if self.path_pattern.is_none() {
            self.path_pattern = config.path_pattern.clone().map(Into::into);
        }
        if self.path_pattern_inverse.is_none() {
            self.path_pattern_inverse = config.path_pattern_inverse.clone().map(Into::into);
        }
        if self.coverage_pattern_inverse.is_none() {
            self.coverage_pattern_inverse = config.coverage_pattern_inverse.clone().map(Into::into);
        }
        ProjectPathsAwareFilter {
            args_filter: self,
            paths: config.project_paths(),
            rerun_failures: None,
        }
    }
}

impl fmt::Debug for FilterArgs {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("FilterArgs")
            .field("match-test", &self.test_pattern.as_ref().map(|r| r.as_str()))
            .field("no-match-test", &self.test_pattern_inverse.as_ref().map(|r| r.as_str()))
            .field("match-contract", &self.contract_pattern.as_ref().map(|r| r.as_str()))
            .field("no-match-contract", &self.contract_pattern_inverse.as_ref().map(|r| r.as_str()))
            .field("match-path", &self.path_pattern.as_ref().map(|g| g.as_str()))
            .field("no-match-path", &self.path_pattern_inverse.as_ref().map(|g| g.as_str()))
            .field("no-match-coverage", &self.coverage_pattern_inverse.as_ref().map(|g| g.as_str()))
            .finish_non_exhaustive()
    }
}

impl FileFilter for FilterArgs {
    /// Returns true if the file regex pattern match the `file`
    ///
    /// If no file regex is set this returns true by default
    fn is_match(&self, file: &Path) -> bool {
        self.matches_path(file)
    }
}

impl TestFilter for FilterArgs {
    fn matches_test(&self, test_signature: &str) -> bool {
        let mut ok = true;
        if let Some(re) = &self.test_pattern {
            ok = ok && re.is_match(test_signature);
        }
        if let Some(re) = &self.test_pattern_inverse {
            ok = ok && !re.is_match(test_signature);
        }
        ok
    }

    fn matches_contract(&self, contract_name: &str) -> bool {
        let mut ok = true;
        if let Some(re) = &self.contract_pattern {
            ok = ok && re.is_match(contract_name);
        }
        if let Some(re) = &self.contract_pattern_inverse {
            ok = ok && !re.is_match(contract_name);
        }
        ok
    }

    fn matches_path(&self, path: &Path) -> bool {
        let mut ok = true;
        if let Some(re) = &self.path_pattern {
            ok = ok && re.is_match(path);
        }
        if let Some(re) = &self.path_pattern_inverse {
            ok = ok && !re.is_match(path);
        }
        ok
    }
}

impl fmt::Display for FilterArgs {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(p) = &self.test_pattern {
            writeln!(f, "\tmatch-test: `{}`", p.as_str())?;
        }
        if let Some(p) = &self.test_pattern_inverse {
            writeln!(f, "\tno-match-test: `{}`", p.as_str())?;
        }
        if let Some(p) = &self.contract_pattern {
            writeln!(f, "\tmatch-contract: `{}`", p.as_str())?;
        }
        if let Some(p) = &self.contract_pattern_inverse {
            writeln!(f, "\tno-match-contract: `{}`", p.as_str())?;
        }
        if let Some(p) = &self.path_pattern {
            writeln!(f, "\tmatch-path: `{}`", p.as_str())?;
        }
        if let Some(p) = &self.path_pattern_inverse {
            writeln!(f, "\tno-match-path: `{}`", p.as_str())?;
        }
        if let Some(p) = &self.coverage_pattern_inverse {
            writeln!(f, "\tno-match-coverage: `{}`", p.as_str())?;
        }
        Ok(())
    }
}

/// A filter that combines all command line arguments and the paths of the current projects
#[derive(Clone, Debug)]
pub struct ProjectPathsAwareFilter {
    args_filter: FilterArgs,
    paths: ProjectPathsConfig,
    rerun_failures: Option<Vec<RerunFailure>>,
}

impl ProjectPathsAwareFilter {
    /// Returns true if the filter is empty.
    pub const fn is_empty(&self) -> bool {
        self.args_filter.is_empty()
    }

    /// Returns the CLI arguments.
    pub const fn args(&self) -> &FilterArgs {
        &self.args_filter
    }

    /// Returns the CLI arguments mutably.
    pub const fn args_mut(&mut self) -> &mut FilterArgs {
        &mut self.args_filter
    }

    /// Returns the project paths.
    pub const fn paths(&self) -> &ProjectPathsConfig {
        &self.paths
    }

    /// Sets exact contract/test pairs persisted by `forge test --rerun`.
    pub fn set_rerun_failures(&mut self, failures: Vec<RerunFailure>) {
        self.rerun_failures = Some(failures);
    }
}

impl FileFilter for ProjectPathsAwareFilter {
    /// Returns true if the file regex pattern match the `file`
    ///
    /// If no file regex is set this returns true by default
    fn is_match(&self, mut file: &Path) -> bool {
        file = file.strip_prefix(&self.paths.root).unwrap_or(file);
        self.args_filter.is_match(file)
    }
}

impl TestFilter for ProjectPathsAwareFilter {
    fn matches_test(&self, test_signature: &str) -> bool {
        self.args_filter.matches_test(test_signature)
    }

    fn matches_contract(&self, contract_name: &str) -> bool {
        self.args_filter.matches_contract(contract_name)
    }

    fn matches_path(&self, mut path: &Path) -> bool {
        // we don't want to test files that belong to a library
        path = path.strip_prefix(&self.paths.root).unwrap_or(path);
        self.args_filter.matches_path(path) && !self.paths.has_library_ancestor(path)
    }

    fn matches_test_function_in_contract(&self, contract_id: &str, func: &Function) -> bool {
        if let Some(failures) = &self.rerun_failures {
            if !func.is_any_test() || !self.args_filter.matches_test(&func.signature()) {
                return false;
            }
            let signature = func.signature();
            let name = signature.split('(').next().unwrap_or(&signature);
            failures.iter().any(|failure| {
                failure.contract == contract_id
                    && (failure.test == signature || failure.test == name)
            })
        } else {
            func.is_any_test() && self.args_filter.matches_test(&func.signature())
        }
    }
}

impl fmt::Display for ProjectPathsAwareFilter {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.args_filter.fmt(f)
    }
}