Use precollection logic in test flow

crates/forge-runner/src/lib.rs

@@ -1,6 +1,7 @@
 use crate::coverage_api::run_coverage;
 use crate::forge_config::{ExecutionDataToSave, ForgeConfig};
-use crate::package_tests::TestCase;
+use crate::package_tests::with_config_resolved::TestCaseResolvedConfig;
+use crate::package_tests::{TestCase, TestCaseDeprecated};
 use crate::running::{run_fuzz_test, run_test};
 use crate::test_case_summary::TestCaseSummary;
 use anyhow::Result;
@@ -58,9 +59,12 @@ const BUILTINS: [&str; 11] = [
 ];
 
 pub trait TestCaseFilter {
-    fn should_be_run<T>(&self, test_case: &TestCase<T>) -> bool
+    // TODO: Remove in next PRs
+    fn should_be_run<T>(&self, test_case: &TestCaseDeprecated<T>) -> bool
     where
         T: TestCaseIsIgnored;
+
+    fn should_run(&self, is_test_case_ignored: bool) -> bool;
 }
 
 pub trait TestCaseIsIgnored {
@@ -113,16 +117,24 @@ pub fn maybe_generate_coverage(
 #[must_use]
 #[tracing::instrument(skip_all, level = "debug")]
 pub fn run_for_test_case(
-    case: Arc<TestCaseWithResolvedConfig>,
+    case: &Arc<TestCase>,
     casm_program: Arc<RawCasmProgram>,
     forge_config: Arc<ForgeConfig>,
     versioned_program_path: Arc<Utf8PathBuf>,
     send: Sender<()>,
 ) -> JoinHandle<Result<AnyTestCaseSummary>> {
+    // TODO: Change all tests running functions to use `TestCase` in next PRs
+    let deprecated_test_case: TestCaseDeprecated<TestCaseResolvedConfig> = TestCaseDeprecated {
+        name: case.name.clone(),
+        test_details: case.test_details.clone(),
+        config: case.config.clone(),
+    };
+    let deprecated_test_case = Arc::new(deprecated_test_case);
+
     if case.config.fuzzer_config.is_none() {
         tokio::task::spawn(async move {
             let res = run_test(
-                case,
+                deprecated_test_case,
                 casm_program,
                 forge_config,
                 versioned_program_path,
@@ -134,7 +146,7 @@ pub fn run_for_test_case(
     } else {
         tokio::task::spawn(async move {
             let res = run_with_fuzzing(
-                case,
+                deprecated_test_case,
                 casm_program,
                 forge_config.clone(),
                 versioned_program_path,

crates/forge-runner/src/package_tests.rs

@@ -1,6 +1,7 @@
 use crate::forge_config::ForgeTrackedResource;
 use crate::package_tests::raw::TestTargetRaw;
 use crate::package_tests::with_config::{TestCaseWithConfig, TestTargetWithConfig};
+use crate::package_tests::with_config_resolved::{TestCaseResolvedConfig, sanitize_test_case_name};
 use crate::running::config_run::run_config_pass;
 use crate::running::hints_to_params;
 use anyhow::{Result, anyhow};
@@ -135,7 +136,7 @@ pub struct TestTargetDeprecated<C> {
     pub sierra_program: ProgramArtifact,
     pub sierra_program_path: Arc<Utf8PathBuf>,
     pub casm_program: Arc<RawCasmProgram>,
-    pub test_cases: Vec<TestCase<C>>,
+    pub test_cases: Vec<TestCaseDeprecated<C>>,
 }
 
 // TODO: Remove in next PRs
@@ -207,13 +208,36 @@ impl TestTargetDeprecated<TestCaseWithConfig> {
     }
 }
 
+// TODO: Remove in next PRs
 #[derive(Debug, Clone, PartialEq)]
-pub struct TestCase<C> {
+pub struct TestCaseDeprecated<C> {
     pub test_details: TestDetails,
     pub name: String,
     pub config: C,
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct TestCase {
+    pub test_details: TestDetails,
+    pub name: String,
+    pub config: TestCaseResolvedConfig,
+}
+
+impl TestCase {
+    #[must_use]
+    pub fn new(name: &str, test_details: TestDetails, config: TestCaseResolvedConfig) -> Self {
+        Self {
+            name: sanitize_test_case_name(name),
+            test_details,
+            config,
+        }
+    }
+
+    pub fn try_into_program(&self, casm_program: &RawCasmProgram) -> Result<Program> {
+        self.test_details.try_into_program(casm_program)
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct TestTarget<T> {
     pub tests_location: TestTargetLocation,

crates/forge-runner/src/package_tests/with_config.rs

@@ -1,4 +1,4 @@
-use super::{TestCase, TestTargetDeprecated};
+use super::{TestCaseDeprecated, TestTargetDeprecated};
 use crate::{
     TestCaseIsIgnored,
     expected_result::{ExpectedPanicValue, ExpectedTestResult},
@@ -11,7 +11,7 @@ use conversions::serde::serialize::SerializeToFeltVec;
 
 pub type TestTargetWithConfig = TestTargetDeprecated<TestCaseConfig>;
 
-pub type TestCaseWithConfig = TestCase<TestCaseConfig>;
+pub type TestCaseWithConfig = TestCaseDeprecated<TestCaseConfig>;
 
 /// Test case with config that has not yet been resolved
 /// see [`super::with_config_resolved::TestCaseResolvedConfig`] for more info

crates/forge-runner/src/package_tests/with_config_resolved.rs

@@ -1,4 +1,4 @@
-use super::{TestCase, TestTargetDeprecated};
+use super::{TestCaseDeprecated, TestTargetDeprecated};
 use crate::{TestCaseIsIgnored, expected_result::ExpectedTestResult, package_tests::TestDetails};
 use anyhow::Result;
 use cairo_vm::types::program::Program;
@@ -11,9 +11,10 @@ use url::Url;
 
 pub type TestTargetWithResolvedConfig = TestTargetDeprecated<TestCaseResolvedConfig>;
 
-pub type TestCaseWithResolvedConfig = TestCase<TestCaseResolvedConfig>;
+pub type TestCaseWithResolvedConfig = TestCaseDeprecated<TestCaseResolvedConfig>;
 
-fn sanitize_test_case_name(name: &str) -> String {
+#[must_use]
+pub fn sanitize_test_case_name(name: &str) -> String {
     // Test names generated by `#[test]` and `#[fuzzer]` macros contain internal suffixes
     name.replace("__snforge_internal_test_generated", "")
         .replace("__snforge_internal_fuzzer_generated", "")

crates/forge/src/run_tests/package.rs

@@ -1,7 +1,4 @@
-use super::{
-    resolve_config::resolve_config,
-    test_target::{TestTargetRunResult, run_for_test_target},
-};
+use super::test_target::{TestTargetRunResult, run_for_test_target};
 use crate::scarb::load_package_config;
 use crate::{
     TestArgs,
@@ -11,12 +8,10 @@ use crate::{
         messages::{
             collected_tests_count::CollectedTestsCountMessage, tests_summary::TestsSummaryMessage,
         },
+        resolve_config::resolve_config,
         workspace::WorkspaceDirs,
     },
-    scarb::{
-        config::{ForgeConfigFromScarb, ForkTarget},
-        load_test_artifacts,
-    },
+    scarb::config::{ForgeConfigFromScarb, ForkTarget},
     shared_cache::FailedTestsCache,
     test_filter::{NameFilter, TestsFilter},
     warn::warn_if_incompatible_rpc_version,
@@ -25,11 +20,8 @@ use anyhow::Result;
 use cheatnet::runtime_extensions::forge_runtime_extension::contracts_data::ContractsData;
 use console::Style;
 use forge_runner::{
-    forge_config::ForgeConfig,
-    package_tests::{
-        TestTargetDeprecated, raw::TestTargetRaw,
-        with_config_resolved::TestTargetWithResolvedConfig,
-    },
+    forge_config::{ForgeConfig, ForgeTrackedResource},
+    package_tests::{TestCandidate, TestCase, TestTarget},
     test_case_summary::AnyTestCaseSummary,
     test_target_summary::TestTargetSummary,
 };
@@ -64,7 +56,7 @@ impl PackageTestResult {
 }
 
 pub struct RunForPackageArgs {
-    pub test_targets: Vec<TestTargetRaw>,
+    pub test_targets: Vec<TestTarget<TestCandidate>>,
     pub tests_filter: TestsFilter,
     pub forge_config: Arc<ForgeConfig>,
     pub fork_targets: Vec<ForkTarget>,
@@ -74,14 +66,13 @@ pub struct RunForPackageArgs {
 impl RunForPackageArgs {
     #[tracing::instrument(skip_all, level = "debug")]
     pub fn build(
+        test_targets: Vec<TestTarget<TestCandidate>>,
         package: PackageMetadata,
         scarb_metadata: &Metadata,
         args: &TestArgs,
         workspace_dirs: &WorkspaceDirs,
         ui: &UI,
     ) -> Result<RunForPackageArgs> {
-        let raw_test_targets = load_test_artifacts(&workspace_dirs.artifacts_dir, &package)?;
-
         let contracts = get_contracts_artifacts_and_source_sierra_paths(
             &workspace_dirs.artifacts_dir,
             &package,
@@ -126,7 +117,7 @@ impl RunForPackageArgs {
         );
 
         Ok(RunForPackageArgs {
-            test_targets: raw_test_targets,
+            test_targets,
             forge_config,
             tests_filter: test_filter,
             fork_targets: forge_config_from_scarb.fork,
@@ -137,30 +128,31 @@ impl RunForPackageArgs {
 
 #[tracing::instrument(skip_all, level = "debug")]
 async fn test_package_with_config_resolved(
-    test_targets: Vec<TestTargetRaw>,
+    test_targets: Vec<TestTarget<TestCandidate>>,
     fork_targets: &[ForkTarget],
     block_number_map: &mut BlockNumberMap,
-    forge_config: &ForgeConfig,
     tests_filter: &TestsFilter,
-) -> Result<Vec<TestTargetWithResolvedConfig>> {
+    tracked_resource: &ForgeTrackedResource,
+) -> Result<Vec<TestTarget<TestCase>>> {
     let mut test_targets_with_resolved_config = Vec::with_capacity(test_targets.len());
 
     for test_target in test_targets {
-        let test_target = TestTargetDeprecated::from_raw_deprecated(
+        let test_target = resolve_config(
             test_target,
-            &forge_config.test_runner_config.tracked_resource,
-        )?;
-
-        let test_target =
-            resolve_config(test_target, fork_targets, block_number_map, tests_filter).await?;
+            fork_targets,
+            block_number_map,
+            tests_filter,
+            tracked_resource,
+        )
+        .await?;
 
         test_targets_with_resolved_config.push(test_target);
     }
 
     Ok(test_targets_with_resolved_config)
 }
 
-fn sum_test_cases(test_targets: &[TestTargetWithResolvedConfig]) -> usize {
+fn sum_test_cases(test_targets: &[TestTarget<TestCase>]) -> usize {
     test_targets.iter().map(|tc| tc.test_cases.len()).sum()
 }
 
@@ -180,8 +172,8 @@ pub async fn run_for_package(
         test_targets,
         &fork_targets,
         block_number_map,
-        &forge_config,
         &tests_filter,
+        &forge_config.test_runner_config.tracked_resource,
     )
     .await?;
     let all_tests = sum_test_cases(&test_targets);