From 88a0a47cbdce7407e80fc0f129eaf16ce66dff5d Mon Sep 17 00:00:00 2001 From: Fiiranek Date: Fri, 7 Nov 2025 12:22:13 +0100 Subject: [PATCH 1/4] Remove old structs --- crates/forge-runner/src/lib.rs | 23 +- crates/forge-runner/src/package_tests.rs | 91 ---- .../src/package_tests/with_config.rs | 5 - .../src/package_tests/with_config_resolved.rs | 25 +- crates/forge-runner/src/running.rs | 11 +- crates/forge-runner/src/test_case_summary.rs | 4 +- crates/forge/src/run_tests/resolve_config.rs | 450 ++++++------------ crates/forge/src/test_filter.rs | 17 +- 8 files changed, 160 insertions(+), 466 deletions(-) diff --git a/crates/forge-runner/src/lib.rs b/crates/forge-runner/src/lib.rs index a8348c6a38..cde5eab8ac 100644 --- a/crates/forge-runner/src/lib.rs +++ b/crates/forge-runner/src/lib.rs @@ -1,7 +1,6 @@ use crate::coverage_api::run_coverage; use crate::forge_config::{ExecutionDataToSave, ForgeConfig}; -use crate::package_tests::with_config_resolved::TestCaseResolvedConfig; -use crate::package_tests::{TestCase, TestCaseDeprecated}; +use crate::package_tests::TestCase; use crate::running::{run_fuzz_test, run_test}; use crate::test_case_summary::TestCaseSummary; use anyhow::Result; @@ -13,7 +12,6 @@ use foundry_ui::UI; use foundry_ui::components::warning::WarningMessage; use futures::StreamExt; use futures::stream::FuturesUnordered; -use package_tests::with_config_resolved::TestCaseWithResolvedConfig; use profiler_api::run_profiler; use rand::SeedableRng; use rand::prelude::StdRng; @@ -59,11 +57,6 @@ const BUILTINS: [&str; 11] = [ ]; pub trait TestCaseFilter { - // TODO: Remove in next PRs - fn should_be_run(&self, test_case: &TestCaseDeprecated) -> bool - where - T: TestCaseIsIgnored; - fn should_run(&self, is_test_case_ignored: bool) -> bool; } @@ -123,18 +116,10 @@ pub fn run_for_test_case( versioned_program_path: Arc, send: Sender<()>, ) -> JoinHandle> { - // TODO: Change all tests running functions to use `TestCase` in next PRs - let deprecated_test_case: TestCaseDeprecated = 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( - deprecated_test_case, + case, casm_program, forge_config, versioned_program_path, @@ -146,7 +131,7 @@ pub fn run_for_test_case( } else { tokio::task::spawn(async move { let res = run_with_fuzzing( - deprecated_test_case, + case, casm_program, forge_config.clone(), versioned_program_path, @@ -160,7 +145,7 @@ pub fn run_for_test_case( #[tracing::instrument(skip_all, level = "debug")] fn run_with_fuzzing( - case: Arc, + case: Arc, casm_program: Arc, forge_config: Arc, versioned_program_path: Arc, diff --git a/crates/forge-runner/src/package_tests.rs b/crates/forge-runner/src/package_tests.rs index a160e13176..f4899312f4 100644 --- a/crates/forge-runner/src/package_tests.rs +++ b/crates/forge-runner/src/package_tests.rs @@ -1,8 +1,5 @@ -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}; use cairo_lang_sierra::extensions::NamedType; @@ -29,7 +26,6 @@ use serde::Serialize; use starknet_types_core::felt::Felt; use std::collections::HashMap; use std::sync::Arc; -use universal_sierra_compiler_api::compile_raw_sierra_at_path; use universal_sierra_compiler_api::representation::RawCasmProgram; pub mod raw; @@ -129,93 +125,6 @@ impl TestDetails { } } -// TODO: Remove in next PRs -#[derive(Debug, Clone)] -pub struct TestTargetDeprecated { - pub tests_location: TestTargetLocation, - pub sierra_program: ProgramArtifact, - pub sierra_program_path: Arc, - pub casm_program: Arc, - pub test_cases: Vec>, -} - -// TODO: Remove in next PRs -impl TestTargetDeprecated { - #[tracing::instrument(skip_all, level = "debug")] - pub fn from_raw_deprecated( - test_target_raw: TestTargetRaw, - tracked_resource: &ForgeTrackedResource, - ) -> Result { - macro_rules! by_id { - ($field:ident) => {{ - let temp: HashMap<_, _> = test_target_raw - .sierra_program - .program - .$field - .iter() - .map(|f| (f.id.id, f)) - .collect(); - - temp - }}; - } - let funcs = by_id!(funcs); - let type_declarations = by_id!(type_declarations); - - let casm_program = Arc::new(compile_raw_sierra_at_path( - test_target_raw.sierra_program_path.as_std_path(), - )?); - - let sierra_program_registry = - ProgramRegistry::::new(&test_target_raw.sierra_program.program)?; - let type_size_map = get_type_size_map( - &test_target_raw.sierra_program.program, - &sierra_program_registry, - ) - .ok_or_else(|| anyhow!("can not get type size map"))?; - - let default_executables = vec![]; - let debug_info = test_target_raw.sierra_program.debug_info.clone(); - let executables = 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 { - let func = funcs[&case.id]; - - let test_details = TestDetails::build(func, &type_declarations, &type_size_map); - - let raw_config = run_config_pass(&test_details, &casm_program, tracked_resource)?; - - Ok(TestCaseWithConfig { - config: raw_config.into(), - name: case.debug_name.clone().unwrap().into(), - test_details, - }) - }) - .collect::>()?; - - 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, - }) - } -} - -// TODO: Remove in next PRs -#[derive(Debug, Clone, PartialEq)] -pub struct TestCaseDeprecated { - pub test_details: TestDetails, - pub name: String, - pub config: C, -} - #[derive(Debug, Clone, PartialEq)] pub struct TestCase { pub test_details: TestDetails, diff --git a/crates/forge-runner/src/package_tests/with_config.rs b/crates/forge-runner/src/package_tests/with_config.rs index 70974c62cb..725ab88c21 100644 --- a/crates/forge-runner/src/package_tests/with_config.rs +++ b/crates/forge-runner/src/package_tests/with_config.rs @@ -1,4 +1,3 @@ -use super::{TestCaseDeprecated, TestTargetDeprecated}; use crate::{ TestCaseIsIgnored, expected_result::{ExpectedPanicValue, ExpectedTestResult}, @@ -9,10 +8,6 @@ use cheatnet::runtime_extensions::forge_config_extension::config::{ }; use conversions::serde::serialize::SerializeToFeltVec; -pub type TestTargetWithConfig = TestTargetDeprecated; - -pub type TestCaseWithConfig = TestCaseDeprecated; - /// Test case with config that has not yet been resolved /// see [`super::with_config_resolved::TestCaseResolvedConfig`] for more info #[derive(Debug, Clone)] diff --git a/crates/forge-runner/src/package_tests/with_config_resolved.rs b/crates/forge-runner/src/package_tests/with_config_resolved.rs index b7509329fd..0a2274cb83 100644 --- a/crates/forge-runner/src/package_tests/with_config_resolved.rs +++ b/crates/forge-runner/src/package_tests/with_config_resolved.rs @@ -1,18 +1,10 @@ -use super::{TestCaseDeprecated, TestTargetDeprecated}; -use crate::{TestCaseIsIgnored, expected_result::ExpectedTestResult, package_tests::TestDetails}; -use anyhow::Result; -use cairo_vm::types::program::Program; +use crate::{TestCaseIsIgnored, expected_result::ExpectedTestResult}; use cheatnet::runtime_extensions::forge_config_extension::config::{ RawAvailableResourceBoundsConfig, RawFuzzerConfig, }; use starknet_api::block::BlockNumber; -use universal_sierra_compiler_api::representation::RawCasmProgram; use url::Url; -pub type TestTargetWithResolvedConfig = TestTargetDeprecated; - -pub type TestCaseWithResolvedConfig = TestCaseDeprecated; - #[must_use] pub fn sanitize_test_case_name(name: &str) -> String { // Test names generated by `#[test]` and `#[fuzzer]` macros contain internal suffixes @@ -20,21 +12,6 @@ pub fn sanitize_test_case_name(name: &str) -> String { .replace("__snforge_internal_fuzzer_generated", "") } -impl TestCaseWithResolvedConfig { - #[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 { - self.test_details.try_into_program(casm_program) - } -} - #[derive(Debug, Clone, PartialEq)] pub struct ResolvedForkConfig { pub url: Url, diff --git a/crates/forge-runner/src/running.rs b/crates/forge-runner/src/running.rs index fa26a732fc..14fc9e5c18 100644 --- a/crates/forge-runner/src/running.rs +++ b/crates/forge-runner/src/running.rs @@ -1,7 +1,8 @@ use crate::backtrace::add_backtrace_footer; use crate::forge_config::{ForgeConfig, RuntimeConfig}; use crate::gas::calculate_used_gas; -use crate::package_tests::with_config_resolved::{ResolvedForkConfig, TestCaseWithResolvedConfig}; +use crate::package_tests::TestCase; +use crate::package_tests::with_config_resolved::ResolvedForkConfig; use crate::test_case_summary::{Single, TestCaseSummary}; use anyhow::{Result, bail}; use blockifier::execution::call_info::CallInfo; @@ -61,7 +62,7 @@ pub use syscall_handler::syscall_handler_offset; #[must_use] #[tracing::instrument(skip_all, level = "debug")] pub fn run_test( - case: Arc, + case: Arc, casm_program: Arc, forge_config: Arc, versioned_program_path: Arc, @@ -97,7 +98,7 @@ pub fn run_test( #[tracing::instrument(skip_all, level = "debug")] #[allow(clippy::too_many_arguments)] pub(crate) fn run_fuzz_test( - case: Arc, + case: Arc, program: Program, casm_program: Arc, forge_config: Arc, @@ -164,7 +165,7 @@ pub enum RunResult { #[expect(clippy::too_many_lines)] #[tracing::instrument(skip_all, level = "debug")] pub fn run_test_case( - case: &TestCaseWithResolvedConfig, + case: &TestCase, program: &Program, casm_program: &RawCasmProgram, runtime_config: &RuntimeConfig, @@ -394,7 +395,7 @@ pub fn run_test_case( fn extract_test_case_summary( run_result: Result, - case: &TestCaseWithResolvedConfig, + case: &TestCase, forge_config: &ForgeConfig, versioned_program_path: &Utf8Path, ) -> TestCaseSummary { diff --git a/crates/forge-runner/src/test_case_summary.rs b/crates/forge-runner/src/test_case_summary.rs index 980b884982..ac7486ac0d 100644 --- a/crates/forge-runner/src/test_case_summary.rs +++ b/crates/forge-runner/src/test_case_summary.rs @@ -4,7 +4,7 @@ use crate::debugging::{TraceArgs, build_debugging_trace}; use crate::expected_result::{ExpectedPanicValue, ExpectedTestResult}; use crate::gas::check_available_gas; use crate::gas::stats::GasStats; -use crate::package_tests::with_config_resolved::TestCaseWithResolvedConfig; +use crate::package_tests::TestCase; use crate::running::{RunCompleted, RunStatus}; use cairo_annotations::trace_data::VersionedCallTrace as VersionedProfilerCallTrace; use camino::Utf8Path; @@ -284,7 +284,7 @@ impl TestCaseSummary { fuzzer_args, fork_data, }: RunCompleted, - test_case: &TestCaseWithResolvedConfig, + test_case: &TestCase, contracts_data: &ContractsData, versioned_program_path: &Utf8Path, trace_args: &TraceArgs, diff --git a/crates/forge/src/run_tests/resolve_config.rs b/crates/forge/src/run_tests/resolve_config.rs index e2eabc5bd0..3d75367c1c 100644 --- a/crates/forge/src/run_tests/resolve_config.rs +++ b/crates/forge/src/run_tests/resolve_config.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use super::maat::env_ignore_fork_tests; +use crate::run_tests::maat::env_ignore_fork_tests; use crate::{ block_number_map::BlockNumberMap, scarb::config::ForkTarget, test_filter::TestsFilter, }; @@ -9,63 +9,16 @@ use cheatnet::runtime_extensions::forge_config_extension::config::{ BlockId, InlineForkConfig, OverriddenForkConfig, RawForgeConfig, RawForkConfig, }; use conversions::byte_array::ByteArray; -use forge_runner::{ - TestCaseFilter, - forge_config::ForgeTrackedResource, - package_tests::{ - TestCandidate, TestCase, TestTarget, - with_config::TestTargetWithConfig, - with_config_resolved::{ - ResolvedForkConfig, TestCaseResolvedConfig, TestCaseWithResolvedConfig, - TestTargetWithResolvedConfig, - }, - }, - running::config_run::run_config_pass, +use forge_runner::TestCaseFilter; +use forge_runner::forge_config::ForgeTrackedResource; +use forge_runner::package_tests::with_config_resolved::{ + ResolvedForkConfig, TestCaseResolvedConfig, }; +use forge_runner::package_tests::{TestCandidate, TestCase, TestTarget}; +use forge_runner::running::config_run::run_config_pass; use starknet_api::block::BlockNumber; use universal_sierra_compiler_api::compile_raw_sierra_at_path; -// TODO: Remove in next PRs -#[tracing::instrument(skip_all, level = "debug")] -pub async fn resolve_config_deprecated( - test_target: TestTargetWithConfig, - fork_targets: &[ForkTarget], - block_number_map: &mut BlockNumberMap, - tests_filter: &TestsFilter, -) -> Result { - let mut test_cases = Vec::with_capacity(test_target.test_cases.len()); - let env_ignore_fork_tests = env_ignore_fork_tests(); - - for case in test_target.test_cases { - test_cases.push(TestCaseWithResolvedConfig::new( - &case.name, - case.test_details.clone(), - TestCaseResolvedConfig { - available_gas: case.config.available_gas, - ignored: case.config.ignored - || (env_ignore_fork_tests && case.config.fork_config.is_some()), - fork_config: if tests_filter.should_be_run(&case) { - resolve_fork_config(case.config.fork_config, block_number_map, fork_targets) - .await? - } else { - None - }, - expected_result: case.config.expected_result, - fuzzer_config: case.config.fuzzer_config, - disable_predeployed_contracts: case.config.disable_predeployed_contracts, - }, - )); - } - - Ok(TestTargetWithResolvedConfig { - tests_location: test_target.tests_location, - sierra_program: test_target.sierra_program, - sierra_program_path: test_target.sierra_program_path, - casm_program: test_target.casm_program, - test_cases, - }) -} - #[tracing::instrument(skip_all, level = "debug")] pub async fn resolve_config( test_target: TestTarget, @@ -114,7 +67,7 @@ pub async fn resolve_config( }) } -async fn resolved_config_from_raw( +pub async fn resolved_config_from_raw( raw_config: RawForgeConfig, tests_filter: &TestsFilter, fork_targets: &[ForkTarget], @@ -218,67 +171,19 @@ fn replace_id_with_params( mod tests { use super::*; use crate::shared_cache::FailedTestsCache; - use cairo_lang_sierra::program::ProgramArtifact; - use cairo_lang_sierra::{ids::GenericTypeId, program::Program}; - use forge_runner::package_tests::TestTargetLocation; - use forge_runner::package_tests::with_config::{TestCaseConfig, TestCaseWithConfig}; - use forge_runner::{expected_result::ExpectedTestResult, package_tests::TestDetails}; - use std::sync::Arc; - use universal_sierra_compiler_api::compile_raw_sierra; + use cheatnet::runtime_extensions::forge_config_extension::config::RawIgnoreConfig; use url::Url; - fn program_for_testing() -> ProgramArtifact { - ProgramArtifact { - program: Program { - type_declarations: vec![], - libfunc_declarations: vec![], - statements: vec![], - funcs: vec![], - }, - debug_info: None, - } - } - - fn create_test_case_with_config( - name: &str, - ignored: bool, - fork_config: Option, - ) -> TestCaseWithConfig { - TestCaseWithConfig { - name: name.to_string(), - config: TestCaseConfig { - available_gas: None, - ignored, - expected_result: ExpectedTestResult::Success, - fork_config, - fuzzer_config: None, - disable_predeployed_contracts: false, - }, - test_details: TestDetails { - sierra_entry_point_statement_idx: 100, - parameter_types: vec![ - (GenericTypeId("RangeCheck".into()), 1), - (GenericTypeId("GasBuiltin".into()), 1), - ], - return_types: vec![ - (GenericTypeId("RangeCheck".into()), 1), - (GenericTypeId("GasBuiltin".into()), 1), - (GenericTypeId("Enum".into()), 3), - ], - }, - } - } - - fn create_test_target_with_cases(test_cases: Vec) -> TestTargetWithConfig { - TestTargetWithConfig { - sierra_program: program_for_testing(), - sierra_program_path: Arc::default(), - casm_program: Arc::new( - compile_raw_sierra(&serde_json::to_value(&program_for_testing().program).unwrap()) - .unwrap(), - ), - test_cases, - tests_location: TestTargetLocation::Lib, + fn create_raw_config(ignored: bool, fork_config: Option) -> RawForgeConfig { + RawForgeConfig { + available_gas: None, + ignore: Some(RawIgnoreConfig { + is_ignored: ignored, + }), + fork: fork_config, + fuzzer: None, + disable_predeployed_contracts: None, + should_panic: None, } } @@ -292,11 +197,8 @@ mod tests { #[tokio::test] async fn to_runnable_non_existent_id() { - let mocked_tests = create_test_target_with_cases(vec![create_test_case_with_config( - "crate1::do_thing", - false, - Some(RawForkConfig::Named("non_existent".into())), - )]); + let raw_config = + create_raw_config(false, Some(RawForkConfig::Named("non_existent".into()))); let tests_filter = TestsFilter::from_flags( None, @@ -309,15 +211,16 @@ mod tests { ); assert!( - resolve_config_deprecated( - mocked_tests, + resolved_config_from_raw( + raw_config, + &tests_filter, &[create_fork_target( "definitely_non_existing", "https://not_taken.com", BlockId::BlockNumber(120) )], &mut BlockNumberMap::default(), - &tests_filter, + false ) .await .is_err() @@ -326,13 +229,8 @@ mod tests { #[tokio::test] async fn test_ignored_filter_skips_fork_config_resolution() { - let ignored_test = create_test_case_with_config( - "ignored_test", - true, - Some(RawForkConfig::Named("non_existent_fork".into())), - ); - - let test_target = create_test_target_with_cases(vec![ignored_test]); + let ignored_raw_config = + create_raw_config(true, Some(RawForkConfig::Named("non_existent_fork".into()))); // Create a filter that excludes ignored tests let tests_filter = TestsFilter::from_flags( @@ -345,29 +243,30 @@ mod tests { FailedTestsCache::default(), ); - let resolved = resolve_config_deprecated( - test_target, + let resolved_config = resolved_config_from_raw( + ignored_raw_config, + &tests_filter, &[], &mut BlockNumberMap::default(), - &tests_filter, + false, ) .await .unwrap(); - assert_eq!(resolved.test_cases.len(), 1); - assert!(resolved.test_cases[0].config.ignored); - assert!(resolved.test_cases[0].config.fork_config.is_none()); + assert!(resolved_config.ignored); + assert!(resolved_config.fork_config.is_none()); } #[tokio::test] async fn test_non_ignored_filter_resolves_fork_config() { - let test_case = create_test_case_with_config( - "valid_test", - false, - Some(RawForkConfig::Named("valid_fork".into())), - ); + // let test_case = create_test_case_with_config( + // "valid_test", + // false, + // Some(RawForkConfig::Named("valid_fork".into())), + // ); - let test_target = create_test_target_with_cases(vec![test_case]); + // let test_target = create_test_target_with_cases(vec![test_case]); + let raw_config = create_raw_config(false, Some(RawForkConfig::Named("valid_fork".into()))); let fork_targets = vec![create_fork_target( "valid_fork", @@ -385,34 +284,27 @@ mod tests { FailedTestsCache::default(), ); - let resolved = resolve_config_deprecated( - test_target, + let resolved_config = resolved_config_from_raw( + raw_config, + &tests_filter, &fork_targets, &mut BlockNumberMap::default(), - &tests_filter, + false, ) .await .unwrap(); - assert_eq!(resolved.test_cases.len(), 1); - assert!(!resolved.test_cases[0].config.ignored); - assert!(resolved.test_cases[0].config.fork_config.is_some()); + assert!(!resolved_config.ignored); + assert!(resolved_config.fork_config.is_some()); - let fork_config = resolved.test_cases[0].config.fork_config.as_ref().unwrap(); + let fork_config = resolved_config.fork_config.as_ref().unwrap(); assert_eq!(fork_config.url.as_str(), "https://example.com/"); assert_eq!(fork_config.block_number.0, 100); } #[tokio::test] async fn test_name_filtered_test_still_resolves_fork_config() { - let test_case = create_test_case_with_config( - "filtered_out_test", - false, - Some(RawForkConfig::Named("valid_fork".into())), - ); - - let test_target = create_test_target_with_cases(vec![test_case]); - + let raw_config = create_raw_config(false, Some(RawForkConfig::Named("valid_fork".into()))); let fork_targets = vec![create_fork_target( "valid_fork", "https://example.com", @@ -429,46 +321,32 @@ mod tests { FailedTestsCache::default(), ); - let resolved = resolve_config_deprecated( - test_target, + let resolved_config = resolved_config_from_raw( + raw_config, + &tests_filter, &fork_targets, &mut BlockNumberMap::default(), - &tests_filter, + false, ) .await .unwrap(); - assert_eq!(resolved.test_cases.len(), 1); - assert!(!resolved.test_cases[0].config.ignored); - assert!(resolved.test_cases[0].config.fork_config.is_some()); + assert!(!resolved_config.ignored); + assert!(resolved_config.fork_config.is_some()); - let fork_config = resolved.test_cases[0].config.fork_config.as_ref().unwrap(); + let fork_config = resolved_config.fork_config.as_ref().unwrap(); assert_eq!(fork_config.url.as_str(), "https://example.com/"); assert_eq!(fork_config.block_number.0, 100); } #[tokio::test] async fn test_mixed_scenarios_with_ignored_filter() { - let test_cases = vec![ - create_test_case_with_config( - "ignored_with_valid_fork", - true, - Some(RawForkConfig::Named("valid_fork".into())), - ), - create_test_case_with_config( - "matching_test", - false, - Some(RawForkConfig::Named("valid_fork".into())), - ), - create_test_case_with_config( - "non_matching_test", - false, - Some(RawForkConfig::Named("valid_fork".into())), - ), - create_test_case_with_config("no_fork_test", false, None), + let raw_configs = vec![ + create_raw_config(true, Some(RawForkConfig::Named("valid_fork".into()))), + create_raw_config(false, Some(RawForkConfig::Named("valid_fork".into()))), + create_raw_config(false, Some(RawForkConfig::Named("valid_fork".into()))), ]; - let test_target = create_test_target_with_cases(test_cases); let fork_targets = vec![create_fork_target( "valid_fork", "https://example.com", @@ -485,58 +363,45 @@ mod tests { FailedTestsCache::default(), ); - let resolved = resolve_config_deprecated( - test_target, - &fork_targets, - &mut BlockNumberMap::default(), - &tests_filter, - ) - .await - .unwrap(); + let mut resolved_configs = Vec::with_capacity(raw_configs.len()); + for raw_config in raw_configs { + let resolved = resolved_config_from_raw( + raw_config, + &tests_filter, + &fork_targets, + &mut BlockNumberMap::default(), + false, + ) + .await + .unwrap(); - assert_eq!(resolved.test_cases.len(), 4); + resolved_configs.push(resolved); + } // Check ignored test - should have no fork config resolved - let ignored_test = &resolved.test_cases[0]; - assert_eq!(ignored_test.name, "ignored_with_valid_fork"); - assert!(ignored_test.config.ignored); - assert!(ignored_test.config.fork_config.is_none()); + assert!(&resolved_configs[0].ignored); + assert!(&resolved_configs[0].fork_config.is_none()); // Check matching test - should have fork config resolved - let matching_test = &resolved.test_cases[1]; - assert_eq!(matching_test.name, "matching_test"); - assert!(!matching_test.config.ignored); - assert!(matching_test.config.fork_config.is_some()); + assert!(!&resolved_configs[1].ignored); + assert!(&resolved_configs[1].fork_config.is_some()); // Check non-matching test - should still have fork config resolved (name filtering happens later) - let non_matching_test = &resolved.test_cases[2]; - assert_eq!(non_matching_test.name, "non_matching_test"); - assert!(!non_matching_test.config.ignored); - assert!(non_matching_test.config.fork_config.is_some()); + assert!(!&resolved_configs[2].ignored); + assert!(&resolved_configs[2].fork_config.is_some()); // Check no-fork test - should work fine - let no_fork_test = &resolved.test_cases[3]; - assert_eq!(no_fork_test.name, "no_fork_test"); - assert!(!no_fork_test.config.ignored); - assert!(no_fork_test.config.fork_config.is_none()); + assert!(!&resolved_configs[3].ignored); + assert!(&resolved_configs[3].fork_config.is_none()); } #[tokio::test] async fn test_only_ignored_filter_skips_non_ignored_fork_resolution() { - let test_cases = vec![ - create_test_case_with_config( - "ignored_test", - true, - Some(RawForkConfig::Named("valid_fork".into())), - ), - create_test_case_with_config( - "non_ignored_test", - false, - Some(RawForkConfig::Named("valid_fork".into())), - ), + let raw_configs = vec![ + create_raw_config(true, Some(RawForkConfig::Named("valid_fork".into()))), + create_raw_config(false, Some(RawForkConfig::Named("valid_fork".into()))), ]; - let test_target = create_test_target_with_cases(test_cases); let fork_targets = vec![create_fork_target( "valid_fork", "https://example.com", @@ -553,47 +418,38 @@ mod tests { FailedTestsCache::default(), ); - let resolved = resolve_config_deprecated( - test_target, - &fork_targets, - &mut BlockNumberMap::default(), - &tests_filter, - ) - .await - .unwrap(); + let mut resolved_configs = Vec::with_capacity(raw_configs.len()); - assert_eq!(resolved.test_cases.len(), 2); + for raw_config in raw_configs { + let resolved = resolved_config_from_raw( + raw_config, + &tests_filter, + &fork_targets, + &mut BlockNumberMap::default(), + false, + ) + .await + .unwrap(); + + resolved_configs.push(resolved); + } // Ignored test should have fork config resolved since it should be run - let ignored_test = &resolved.test_cases[0]; - assert_eq!(ignored_test.name, "ignored_test"); - assert!(ignored_test.config.ignored); - assert!(ignored_test.config.fork_config.is_some()); + assert!(&resolved_configs[0].ignored); + assert!(&resolved_configs[0].fork_config.is_some()); // Non-ignored test should not have fork config resolved since it won't be run - let non_ignored_test = &resolved.test_cases[1]; - assert_eq!(non_ignored_test.name, "non_ignored_test"); - assert!(!non_ignored_test.config.ignored); - assert!(non_ignored_test.config.fork_config.is_none()); + assert!(!&resolved_configs[1].ignored); + assert!(&resolved_configs[1].fork_config.is_none()); } #[tokio::test] async fn test_include_ignored_filter_resolves_all_fork_configs() { - let test_cases = vec![ - create_test_case_with_config( - "ignored_test", - true, - Some(RawForkConfig::Named("valid_fork".into())), - ), - create_test_case_with_config( - "non_ignored_test", - false, - Some(RawForkConfig::Named("valid_fork".into())), - ), + let raw_configs = vec![ + create_raw_config(true, Some(RawForkConfig::Named("valid_fork".into()))), + create_raw_config(false, Some(RawForkConfig::Named("valid_fork".into()))), ]; - let test_target = create_test_target_with_cases(test_cases); - let fork_targets = vec![create_fork_target( "valid_fork", "https://example.com", @@ -610,37 +466,35 @@ mod tests { FailedTestsCache::default(), ); - let resolved = resolve_config_deprecated( - test_target, - &fork_targets, - &mut BlockNumberMap::default(), - &tests_filter, - ) - .await - .unwrap(); + let mut resolved_configs = Vec::with_capacity(raw_configs.len()); + for raw_config in raw_configs { + let resolved = resolved_config_from_raw( + raw_config, + &tests_filter, + &fork_targets, + &mut BlockNumberMap::default(), + false, + ) + .await + .unwrap(); - assert_eq!(resolved.test_cases.len(), 2); + resolved_configs.push(resolved); + } - for test_case in &resolved.test_cases { - assert!(test_case.config.fork_config.is_some()); - let fork_config = test_case.config.fork_config.as_ref().unwrap(); + for resolved_config in &resolved_configs { + assert!(resolved_config.fork_config.is_some()); + let fork_config = resolved_config.fork_config.as_ref().unwrap(); assert_eq!(fork_config.url.as_str(), "https://example.com/"); assert_eq!(fork_config.block_number.0, 500); } - let ignored_test = &resolved.test_cases[0]; - assert_eq!(ignored_test.name, "ignored_test"); - assert!(ignored_test.config.ignored); - - let non_ignored_test = &resolved.test_cases[1]; - assert_eq!(non_ignored_test.name, "non_ignored_test"); - assert!(!non_ignored_test.config.ignored); + assert!(&resolved_configs[0].ignored); + assert!(!&resolved_configs[1].ignored); } #[tokio::test] async fn test_fork_config_resolution_with_inline_config() { - let test_case = create_test_case_with_config( - "test_with_inline_fork", + let raw_config = create_raw_config( false, Some(RawForkConfig::Inline(InlineForkConfig { url: "https://inline-fork.com".parse().unwrap(), @@ -648,7 +502,6 @@ mod tests { })), ); - let test_target = create_test_target_with_cases(vec![test_case]); let tests_filter = TestsFilter::from_flags( None, false, @@ -659,30 +512,27 @@ mod tests { FailedTestsCache::default(), ); - let resolved = resolve_config_deprecated( - test_target, + let resolved_config = resolved_config_from_raw( + raw_config, + &tests_filter, &[], &mut BlockNumberMap::default(), - &tests_filter, + false, ) .await .unwrap(); - assert_eq!(resolved.test_cases.len(), 1); - - let test_case = &resolved.test_cases[0]; - assert!(!test_case.config.ignored); - assert!(test_case.config.fork_config.is_some()); + assert!(!resolved_config.ignored); + assert!(resolved_config.fork_config.is_some()); - let fork_config = test_case.config.fork_config.as_ref().unwrap(); + let fork_config = resolved_config.fork_config.as_ref().unwrap(); assert_eq!(fork_config.url.as_str(), "https://inline-fork.com/"); assert_eq!(fork_config.block_number.0, 123); } #[tokio::test] async fn test_overridden_fork_config_resolution() { - let test_case = create_test_case_with_config( - "test_with_overridden_fork", + let raw_config = create_raw_config( false, Some(RawForkConfig::Overridden(OverriddenForkConfig { name: "base_fork".into(), @@ -690,7 +540,6 @@ mod tests { })), ); - let test_target = create_test_target_with_cases(vec![test_case]); let fork_targets = vec![create_fork_target( "base_fork", "https://base-fork.com", @@ -707,33 +556,26 @@ mod tests { FailedTestsCache::default(), ); - let resolved = resolve_config_deprecated( - test_target, + let resolved_config = resolved_config_from_raw( + raw_config, + &tests_filter, &fork_targets, &mut BlockNumberMap::default(), - &tests_filter, + false, ) .await .unwrap(); - assert_eq!(resolved.test_cases.len(), 1); - let test_case = &resolved.test_cases[0]; - assert!(test_case.config.fork_config.is_some()); + assert!(resolved_config.fork_config.is_some()); - let fork_config = test_case.config.fork_config.as_ref().unwrap(); + let fork_config = resolved_config.fork_config.as_ref().unwrap(); assert_eq!(fork_config.url.as_str(), "https://base-fork.com/"); assert_eq!(fork_config.block_number.0, 999); } #[tokio::test] async fn test_skip_filter_does_not_affect_fork_resolution() { - let test_case = create_test_case_with_config( - "test_to_be_skipped", - false, - Some(RawForkConfig::Named("valid_fork".into())), - ); - - let test_target = create_test_target_with_cases(vec![test_case]); + let raw_config = create_raw_config(false, Some(RawForkConfig::Named("valid_fork".into()))); let fork_targets = vec![create_fork_target( "valid_fork", @@ -751,22 +593,20 @@ mod tests { FailedTestsCache::default(), ); - let resolved = resolve_config_deprecated( - test_target, + let resolved_config = resolved_config_from_raw( + raw_config, + &tests_filter, &fork_targets, &mut BlockNumberMap::default(), - &tests_filter, + false, ) .await .unwrap(); - assert_eq!(resolved.test_cases.len(), 1); - - let test_case = &resolved.test_cases[0]; - assert!(!test_case.config.ignored); - assert!(test_case.config.fork_config.is_some()); + assert!(!resolved_config.ignored); + assert!(resolved_config.fork_config.is_some()); - let fork_config = test_case.config.fork_config.as_ref().unwrap(); + let fork_config = resolved_config.fork_config.as_ref().unwrap(); assert_eq!(fork_config.url.as_str(), "https://example.com/"); assert_eq!(fork_config.block_number.0, 600); } diff --git a/crates/forge/src/test_filter.rs b/crates/forge/src/test_filter.rs index ea50ec3eef..df5bef9eef 100644 --- a/crates/forge/src/test_filter.rs +++ b/crates/forge/src/test_filter.rs @@ -1,7 +1,7 @@ use crate::shared_cache::FailedTestsCache; use anyhow::Result; -use forge_runner::package_tests::{TestCase, TestCaseDeprecated}; -use forge_runner::{TestCaseFilter, TestCaseIsIgnored}; +use forge_runner::TestCaseFilter; +use forge_runner::package_tests::TestCase; #[derive(Debug, PartialEq)] // Specifies what tests should be included @@ -115,19 +115,6 @@ impl TestsFilter { } impl TestCaseFilter for TestsFilter { - fn should_be_run(&self, test_case: &TestCaseDeprecated) -> bool - where - T: TestCaseIsIgnored, - { - let ignored = test_case.config.is_ignored(); - - match self.ignored_filter { - IgnoredFilter::All => true, - IgnoredFilter::Ignored => ignored, - IgnoredFilter::NotIgnored => !ignored, - } - } - fn should_run(&self, is_test_case_ignored: bool) -> bool { match self.ignored_filter { IgnoredFilter::All => true, From 904057588b4e8ecaf454dd397580ff07f1b2f120 Mon Sep 17 00:00:00 2001 From: Fiiranek Date: Fri, 7 Nov 2025 13:12:03 +0100 Subject: [PATCH 2/4] Fix compilation errors --- crates/forge-runner/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/forge-runner/src/lib.rs b/crates/forge-runner/src/lib.rs index 21594e7903..cde5eab8ac 100644 --- a/crates/forge-runner/src/lib.rs +++ b/crates/forge-runner/src/lib.rs @@ -110,7 +110,7 @@ pub fn maybe_generate_coverage( #[must_use] #[tracing::instrument(skip_all, level = "debug")] pub fn run_for_test_case( - case: &Arc, + case: Arc, casm_program: Arc, forge_config: Arc, versioned_program_path: Arc, From 4171cbb5328cf6003ffd9447e90cd0b9456dc519 Mon Sep 17 00:00:00 2001 From: Fiiranek Date: Fri, 7 Nov 2025 13:15:42 +0100 Subject: [PATCH 3/4] Fix test --- crates/forge/src/run_tests/resolve_config.rs | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/crates/forge/src/run_tests/resolve_config.rs b/crates/forge/src/run_tests/resolve_config.rs index 3d75367c1c..129a9a5571 100644 --- a/crates/forge/src/run_tests/resolve_config.rs +++ b/crates/forge/src/run_tests/resolve_config.rs @@ -259,13 +259,6 @@ mod tests { #[tokio::test] async fn test_non_ignored_filter_resolves_fork_config() { - // let test_case = create_test_case_with_config( - // "valid_test", - // false, - // Some(RawForkConfig::Named("valid_fork".into())), - // ); - - // let test_target = create_test_target_with_cases(vec![test_case]); let raw_config = create_raw_config(false, Some(RawForkConfig::Named("valid_fork".into()))); let fork_targets = vec![create_fork_target( @@ -345,6 +338,7 @@ mod tests { create_raw_config(true, Some(RawForkConfig::Named("valid_fork".into()))), create_raw_config(false, Some(RawForkConfig::Named("valid_fork".into()))), create_raw_config(false, Some(RawForkConfig::Named("valid_fork".into()))), + create_raw_config(false, None), ]; let fork_targets = vec![create_fork_target( From be3d6cd7a0f1daa821f419b0cdd26ef9ef841bd6 Mon Sep 17 00:00:00 2001 From: Fiiranek Date: Fri, 7 Nov 2025 15:30:22 +0100 Subject: [PATCH 4/4] Fix compilation error --- crates/forge/src/run_tests/test_target.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/forge/src/run_tests/test_target.rs b/crates/forge/src/run_tests/test_target.rs index 6aecb57175..a06fd070d7 100644 --- a/crates/forge/src/run_tests/test_target.rs +++ b/crates/forge/src/run_tests/test_target.rs @@ -59,7 +59,7 @@ pub async fn run_for_test_target( let case = Arc::new(case); tasks.push(run_for_test_case( - &case, + case, casm_program.clone().unwrap(), forge_config.clone(), tests.sierra_program_path.clone(),