Runtime checks for _std packages

commit-id:dc2f7a0d

# Conflicts:
#	crates/forge/src/run_tests/workspace.rs

Author: cptartur

crates/forge/src/lib.rs

@@ -11,12 +11,12 @@ use foundry_ui::components::warning::WarningMessage;
 use run_tests::workspace::run_for_workspace;
 use scarb_api::{ScarbCommand, metadata::MetadataCommandExt};
 use scarb_ui::args::{FeaturesSpec, PackagesFilter};
-use semver::Version;
+use semver::{Version, VersionReq};
 use shared::auto_completions::{Completion, generate_completions};
 use std::cell::RefCell;
 use std::ffi::OsString;
 use std::process::Command;
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 use std::{fs, num::NonZeroU32, thread::available_parallelism};
 use tokio::runtime::Builder;
 use universal_sierra_compiler_api::UniversalSierraCompilerCommand;
@@ -41,8 +41,12 @@ const MINIMAL_RECOMMENDED_SCARB_VERSION: Version = Version::new(2, 9, 4);
 const MINIMAL_SCARB_VERSION_PREBUILT_PLUGIN: Version = Version::new(2, 10, 0);
 const MINIMAL_USC_VERSION: Version = Version::new(2, 0, 0);
 const MINIMAL_SCARB_VERSION_FOR_SIERRA_GAS: Version = Version::new(2, 10, 0);
-// TODO(#3344) Set this to 0.44.0 after it has been released
+// TODO Set this to version from v2 macros release
 const MINIMAL_SNFORGE_STD_VERSION: Version = Version::new(0, 44, 0);
+// TODO Set this to version from v2 macros release
+const MINIMAL_SNFORGE_STD_COMPATIBILITY_VERSION: Version = Version::new(0, 44, 0);
+pub static MINIMAL_SCARB_VERSION_FOR_V2_MACROS_REQUIREMENT: LazyLock<VersionReq> =
+    LazyLock::new(|| VersionReq::parse(">=2.12.0-rc.1").expect("Failed to parse version req"));
 
 #[derive(Parser, Debug)]
 #[command(

crates/forge/src/run_tests/workspace.rs

@@ -1,11 +1,16 @@
 use super::package::RunForPackageArgs;
 use super::structs::{LatestBlocksNumbersMessage, TestsFailureSummaryMessage};
 use crate::run_tests::structs::OverallSummaryMessage;
-use crate::warn::{error_if_snforge_std_not_compatible, warn_if_backtrace_without_panic_hint};
+use crate::warn::{
+    error_if_snforge_std_compatibility_missing, error_if_snforge_std_compatibility_not_compatible,
+    error_if_snforge_std_not_compatible, warn_if_backtrace_without_panic_hint,
+    warn_if_snforge_std_compatibility_does_not_match_package_version,
+};
 use crate::{
-    ColorOption, ExitStatus, TestArgs, block_number_map::BlockNumberMap,
-    run_tests::package::run_for_package, scarb::build_artifacts_with_scarb,
-    shared_cache::FailedTestsCache, warn::warn_if_snforge_std_not_compatible,
+    ColorOption, ExitStatus, MINIMAL_SCARB_VERSION_FOR_V2_MACROS_REQUIREMENT, TestArgs,
+    block_number_map::BlockNumberMap, run_tests::package::run_for_package,
+    scarb::build_artifacts_with_scarb, shared_cache::FailedTestsCache,
+    warn::warn_if_snforge_std_does_not_match_package_version,
 };
 use anyhow::{Context, Result};
 use forge_runner::{CACHE_DIR, test_target_summary::TestTargetSummary};
@@ -38,8 +43,16 @@ pub async fn run_for_workspace(args: TestArgs, ui: Arc<UI>) -> Result<ExitStatus
         can_coverage_be_generated(&scarb_metadata)?;
     }
 
-    error_if_snforge_std_not_compatible(&scarb_metadata)?;
-    warn_if_snforge_std_not_compatible(&scarb_metadata, &ui)?;
+    let scarb_version = ScarbCommand::version().run()?.scarb;
+    if MINIMAL_SCARB_VERSION_FOR_V2_MACROS_REQUIREMENT.matches(&scarb_version) {
+        error_if_snforge_std_not_compatible(&scarb_metadata)?;
+        warn_if_snforge_std_does_not_match_package_version(&scarb_metadata, &ui)?;
+    } else {
+        error_if_snforge_std_compatibility_missing(&scarb_metadata)?;
+        error_if_snforge_std_compatibility_not_compatible(&scarb_metadata)?;
+        warn_if_snforge_std_compatibility_does_not_match_package_version(&scarb_metadata, &ui)?;
+    }
+
     warn_if_backtrace_without_panic_hint(&scarb_metadata, &ui);
 
     let artifacts_dir_path =

crates/forge/src/warn.rs

@@ -1,4 +1,4 @@
-use crate::MINIMAL_SNFORGE_STD_VERSION;
+use crate::{MINIMAL_SNFORGE_STD_COMPATIBILITY_VERSION, MINIMAL_SNFORGE_STD_VERSION};
 use anyhow::{Result, anyhow};
 use forge_runner::backtrace::is_backtrace_enabled;
 use forge_runner::package_tests::with_config_resolved::TestTargetWithResolvedConfig;
@@ -85,6 +85,65 @@ fn snforge_std_recommended_version() -> VersionReq {
     }
 }
 
+fn snforge_std_compatibility_recommended_version() -> VersionReq {
+    snforge_std_recommended_version()
+}
+
+pub fn error_if_snforge_std_compatibility_missing(scarb_metadata: &Metadata) -> Result<()> {
+    if !scarb_metadata
+        .packages
+        .iter()
+        .any(|p| p.name == "snforge_std_compatibility")
+    {
+        return Err(anyhow!(
+            "On Scarb versions < 2.12.0, the `snforge_std` package must be replaced with `snforge_std_compatibility`. Please update it in Scarb.toml"
+        ));
+    }
+    Ok(())
+}
+
+pub fn error_if_snforge_std_compatibility_not_compatible(scarb_metadata: &Metadata) -> Result<()> {
+    let snforge_std_compatibility_version_requirement_comparator = Comparator {
+        op: Op::GreaterEq,
+        major: MINIMAL_SNFORGE_STD_COMPATIBILITY_VERSION.major,
+        minor: Some(MINIMAL_SNFORGE_STD_COMPATIBILITY_VERSION.minor),
+        patch: Some(MINIMAL_SNFORGE_STD_COMPATIBILITY_VERSION.patch),
+        pre: MINIMAL_SNFORGE_STD_COMPATIBILITY_VERSION.pre,
+    };
+    let snforge_std_compatibility_version_requirement = VersionReq {
+        comparators: vec![snforge_std_compatibility_version_requirement_comparator],
+    };
+
+    if !package_matches_version_requirement(
+        scarb_metadata,
+        "snforge_std_compatibility",
+        &snforge_std_compatibility_version_requirement,
+    )? {
+        return Err(anyhow!(
+            "Package `snforge_std_compatibility` version does not meet the minimum required version {snforge_std_compatibility_version_requirement}. Please upgrade `snforge_std_compatibility` in Scarb.toml"
+        ));
+    }
+    Ok(())
+}
+
+pub fn warn_if_snforge_std_compatibility_does_not_match_package_version(
+    scarb_metadata: &Metadata,
+    ui: &UI,
+) -> Result<()> {
+    let snforge_std_compatibility_version_requirement =
+        snforge_std_compatibility_recommended_version();
+    if !package_matches_version_requirement(
+        scarb_metadata,
+        "snforge_std_compatibility",
+        &snforge_std_compatibility_version_requirement,
+    )? {
+        ui.println(&WarningMessage::new(&format!(
+            "Package `snforge_std_compatibility` version does not meet the recommended version requirement {snforge_std_compatibility_version_requirement}, it might result in unexpected behaviour"
+        )));
+    }
+    Ok(())
+}
+
 pub fn error_if_snforge_std_not_compatible(scarb_metadata: &Metadata) -> Result<()> {
     let snforge_std_version_requirement_comparator = Comparator {
         op: Op::GreaterEq,
@@ -109,7 +168,10 @@ pub fn error_if_snforge_std_not_compatible(scarb_metadata: &Metadata) -> Result<
     Ok(())
 }
 
-pub fn warn_if_snforge_std_not_compatible(scarb_metadata: &Metadata, ui: &UI) -> Result<()> {
+pub fn warn_if_snforge_std_does_not_match_package_version(
+    scarb_metadata: &Metadata,
+    ui: &UI,
+) -> Result<()> {
     let snforge_std_version_requirement = snforge_std_recommended_version();
     if !package_matches_version_requirement(
         scarb_metadata,