Optimize config resolution for non-matching targets in --exact runs

crates/forge-runner/src/filtering.rs

@@ -1,5 +1,37 @@
 use crate::package_tests::TestCase;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum NameFilter {
+    All,
+    Match(String),
+    ExactMatch(String),
+}
+
+impl NameFilter {
+    #[must_use]
+    pub fn from_flags(test_name_filter: Option<String>, exact_match: bool) -> Self {
+        if exact_match {
+            Self::ExactMatch(
+                test_name_filter
+                    .expect("Argument test_name_filter cannot be None with exact_match"),
+            )
+        } else if let Some(name) = test_name_filter {
+            Self::Match(name)
+        } else {
+            Self::All
+        }
+    }
+
+    #[must_use]
+    pub fn matches(&self, sanitized_name: &str) -> bool {
+        match self {
+            Self::All => true,
+            Self::Match(filter) => sanitized_name.contains(filter),
+            Self::ExactMatch(name) => sanitized_name == name,
+        }
+    }
+}
+
 /// Result of filtering a test case.
 #[derive(Debug)]
 pub enum FilterResult {
@@ -27,3 +59,25 @@ pub trait TestCaseFilter {
 pub trait TestCaseIsIgnored {
     fn is_ignored(&self) -> bool;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::NameFilter;
+
+    #[test]
+    fn name_filter_all_matches_everything() {
+        assert!(NameFilter::All.matches("any::test"));
+    }
+
+    #[test]
+    fn name_filter_match_uses_substring_matching() {
+        assert!(NameFilter::Match("selected".to_string()).matches("pkg::selected_test"));
+        assert!(!NameFilter::Match("other".to_string()).matches("pkg::selected_test"));
+    }
+
+    #[test]
+    fn name_filter_exact_match_uses_equality() {
+        assert!(NameFilter::ExactMatch("pkg::test".to_string()).matches("pkg::test"));
+        assert!(!NameFilter::ExactMatch("pkg::test".to_string()).matches("pkg::test_case"));
+    }
+}

crates/forge-runner/src/running/target.rs

@@ -1,9 +1,11 @@
 use crate::{
+    filtering::NameFilter,
     forge_config::ForgeTrackedResource,
     package_tests::{
-        TestDetails,
+        TestDetails, TestTargetLocation,
         raw::TestTargetRaw,
         with_config::{TestCaseWithConfig, TestTargetWithConfig},
+        with_config_resolved::sanitize_test_case_name,
     },
     running::config_run::run_config_pass,
 };
@@ -12,16 +14,48 @@ use cairo_lang_sierra::{
     ids::ConcreteTypeId,
     program::{GenFunction, StatementIdx, TypeDeclaration},
 };
+use rayon::iter::IntoParallelIterator;
 use rayon::iter::IntoParallelRefIterator;
 use rayon::iter::ParallelIterator;
 use std::{collections::HashMap, sync::Arc};
 use universal_sierra_compiler_api::compile_raw_sierra_at_path;
+use universal_sierra_compiler_api::representation::RawCasmProgram;
 
 #[tracing::instrument(skip_all, level = "debug")]
 pub fn prepare_test_target(
     test_target_raw: TestTargetRaw,
     tracked_resource: &ForgeTrackedResource,
-) -> Result<TestTargetWithConfig> {
+    name_filter: &NameFilter,
+) -> Result<(Option<TestTargetWithConfig>, TestTargetLocation)> {
+    let tests_location = test_target_raw.tests_location;
+    let default_executables = vec![];
+    let executables = test_target_raw
+        .sierra_program
+        .debug_info
+        .as_ref()
+        .and_then(|info| info.executables.get("snforge_internal_test_executable"))
+        .unwrap_or(&default_executables);
+
+    let exact_matches = match name_filter {
+        NameFilter::ExactMatch(exact_match) => {
+            let matches = executables
+                .iter()
+                .filter_map(|case| {
+                    let raw_name: String = case.debug_name.clone()?.into();
+                    let sanitized_name = sanitize_test_case_name(&raw_name);
+                    (sanitized_name == *exact_match).then_some((&case.id, raw_name))
+                })
+                .collect::<Vec<_>>();
+
+            if matches.is_empty() {
+                return Ok((None, tests_location));
+            }
+
+            Some(matches)
+        }
+        NameFilter::All | NameFilter::Match(_) => None,
+    };
+
     macro_rules! by_id {
         ($field:ident) => {{
             let temp: HashMap<_, _> = test_target_raw
@@ -42,37 +76,63 @@ pub fn prepare_test_target(
         test_target_raw.sierra_program_path.as_std_path(),
     )?);
 
-    let default_executables = vec![];
-    let executables = test_target_raw
-        .sierra_program
-        .debug_info
-        .as_ref()
-        .and_then(|info| info.executables.get("snforge_internal_test_executable"))
-        .unwrap_or(&default_executables);
-
-    let test_cases = executables
-        .par_iter()
-        .map(|case| -> Result<TestCaseWithConfig> {
-            let func = funcs[&case.id];
-
-            let test_details = build_test_details(func, &type_declarations);
+    let test_cases = if let Some(matches) = exact_matches {
+        matches
+            .into_par_iter()
+            .map(|(id, name)| {
+                build_test_case_with_config(
+                    funcs[id],
+                    name,
+                    &type_declarations,
+                    &casm_program,
+                    *tracked_resource,
+                )
+            })
+            .collect::<Result<_>>()?
+    } else {
+        executables
+            .par_iter()
+            .map(|case| {
+                build_test_case_with_config(
+                    funcs[&case.id],
+                    case.debug_name
+                        .clone()
+                        .expect("Failed to get test case name")
+                        .into(),
+                    &type_declarations,
+                    &casm_program,
+                    *tracked_resource,
+                )
+            })
+            .collect::<Result<_>>()?
+    };
 
-            let raw_config = run_config_pass(&test_details, &casm_program, tracked_resource)?;
+    Ok((
+        Some(TestTargetWithConfig {
+            tests_location,
+            test_cases,
+            sierra_program: test_target_raw.sierra_program,
+            sierra_program_path: test_target_raw.sierra_program_path.into(),
+            casm_program,
+        }),
+        tests_location,
+    ))
+}
 
-            Ok(TestCaseWithConfig {
-                config: raw_config.into(),
-                name: case.debug_name.clone().unwrap().into(),
-                test_details,
-            })
-        })
-        .collect::<Result<_>>()?;
+fn build_test_case_with_config(
+    func: &GenFunction<StatementIdx>,
+    name: String,
+    type_declarations: &HashMap<u64, &TypeDeclaration>,
+    casm_program: &Arc<RawCasmProgram>,
+    tracked_resource: ForgeTrackedResource,
+) -> Result<TestCaseWithConfig> {
+    let test_details = build_test_details(func, type_declarations);
+    let raw_config = run_config_pass(&test_details, casm_program, &tracked_resource)?;
 
-    Ok(TestTargetWithConfig {
-        tests_location: test_target_raw.tests_location,
-        test_cases,
-        sierra_program: test_target_raw.sierra_program,
-        sierra_program_path: test_target_raw.sierra_program_path.into(),
-        casm_program,
+    Ok(TestCaseWithConfig {
+        config: raw_config.into(),
+        name,
+        test_details,
     })
 }
 

crates/forge/src/run_tests/package.rs

@@ -15,19 +15,23 @@ use crate::{
         tests_summary::TestsSummaryMessage,
     },
     shared_cache::FailedTestsCache,
-    test_filter::{NameFilter, TestsFilter},
+    test_filter::TestsFilter,
     warn::warn_if_incompatible_rpc_version,
 };
 use anyhow::Result;
 use camino::{Utf8Path, Utf8PathBuf};
 use cheatnet::runtime_extensions::forge_runtime_extension::contracts_data::ContractsData;
 use console::Style;
 use forge_runner::{
+    filtering::NameFilter,
     forge_config::{ForgeConfig, ForgeTrackedResource},
     package_tests::{
+        TestTargetLocation,
         raw::TestTargetRaw,
         with_config::TestTargetWithConfig,
-        with_config_resolved::{TestCaseWithResolvedConfig, sanitize_test_case_name},
+        with_config_resolved::{
+            TestCaseWithResolvedConfig, TestTargetWithResolvedConfig, sanitize_test_case_name,
+        },
     },
     partition::PartitionConfig,
     running::target::prepare_test_target,
@@ -41,6 +45,8 @@ use scarb_metadata::{Metadata, PackageMetadata};
 use std::sync::Arc;
 use tokio::task::JoinHandle;
 
+type PrepareTargetHandle = JoinHandle<Result<(Option<TestTargetWithConfig>, TestTargetLocation)>>;
+
 pub struct PackageTestResult {
     summaries: Vec<TestTargetSummary>,
     filtered: Option<usize>,
@@ -67,7 +73,7 @@ impl PackageTestResult {
 }
 
 pub struct RunForPackageArgs {
-    pub target_handles: Vec<JoinHandle<Result<TestTargetWithConfig>>>,
+    pub target_handles: Vec<PrepareTargetHandle>,
     pub tests_filter: TestsFilter,
     pub forge_config: Arc<ForgeConfig>,
     pub fork_targets: Vec<ForkTarget>,
@@ -125,10 +131,11 @@ impl RunForPackageArgs {
         }
 
         let tracked_resource = forge_config.test_runner_config.tracked_resource;
+        let name_filter = tests_filter.name_filter.clone();
 
         let target_handles = raw_test_targets
             .into_iter()
-            .map(|t| spawn_prepare_test_target(t, tracked_resource))
+            .map(|t| spawn_prepare_test_target(t, tracked_resource, name_filter.clone()))
             .collect();
 
         Ok(RunForPackageArgs {
@@ -145,8 +152,11 @@ impl RunForPackageArgs {
 fn spawn_prepare_test_target(
     target: TestTargetRaw,
     tracked_resource: ForgeTrackedResource,
-) -> JoinHandle<Result<TestTargetWithConfig>> {
-    tokio::task::spawn_blocking(move || prepare_test_target(target, &tracked_resource))
+    name_filter: NameFilter,
+) -> PrepareTargetHandle {
+    tokio::task::spawn_blocking(move || {
+        prepare_test_target(target, &tracked_resource, &name_filter)
+    })
 }
 
 fn sum_test_cases_from_test_target(
@@ -185,12 +195,18 @@ pub async fn run_for_package(
     exit_first_channel: &mut ExitFirstChannel,
 ) -> Result<PackageTestResult> {
     // Resolve all targets first so the collected count includes #[ignore] filtering.
-    let mut resolved_targets = vec![];
+    let mut resolved_targets: Vec<(TestTargetLocation, Option<TestTargetWithResolvedConfig>)> =
+        vec![];
     let mut all_tests = 0;
     let mut not_filtered_total = 0;
 
     for handle in target_handles {
-        let target_with_config = handle.await??;
+        let (maybe_target, tests_location) = handle.await??;
+
+        let Some(target_with_config) = maybe_target else {
+            resolved_targets.push((tests_location, None));
+            continue;
+        };
 
         let mut resolved = resolve_config(
             target_with_config,
@@ -212,10 +228,16 @@ pub async fn run_for_package(
         all_tests += all;
         not_filtered_total += not_filtered;
 
-        resolved_targets.push(resolved);
+        resolved_targets.push((tests_location, Some(resolved)));
     }
 
-    warn_if_incompatible_rpc_version(&resolved_targets, ui.clone()).await?;
+    warn_if_incompatible_rpc_version(
+        resolved_targets
+            .iter()
+            .filter_map(|(_, resolved)| resolved.as_ref()),
+        ui.clone(),
+    )
+    .await?;
 
     ui.println(&CollectedTestsCountMessage {
         tests_num: not_filtered_total,
@@ -224,7 +246,12 @@ pub async fn run_for_package(
 
     let mut summaries = vec![];
 
-    for resolved in resolved_targets {
+    for (location, resolved) in resolved_targets {
+        let Some(resolved) = resolved else {
+            ui.println(&TestsRunMessage::new(location, 0));
+            continue;
+        };
+
         ui.println(&TestsRunMessage::new(
             resolved.tests_location,
             sum_test_cases_from_test_target(