Runtime checks for _std packages

commit-id:dc2f7a0d

Author: cptartur

crates/forge/src/lib.rs

@@ -41,8 +41,9 @@ 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
 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);
 
 #[derive(Parser, Debug)]
 #[command(

crates/forge/src/run_tests/workspace.rs

@@ -1,6 +1,11 @@
 use super::package::RunForPackageArgs;
 use super::structs::{LatestBlocksNumbersMessage, TestsFailureSummaryMessage};
-use crate::warn::{error_if_snforge_std_not_compatible, warn_if_backtrace_without_panic_hint};
+use crate::warn::{
+    error_if_not_snforge_std_compatibility, error_if_snforge_std_compatibility_not_compatible,
+    error_if_snforge_std_not_compatible, warn_if_backtrace_without_panic_hint,
+    warn_if_snforge_std_compatibility_not_compatible,
+    warn_if_snforge_std_compatibility_on_new_scarb,
+};
 use crate::{
     ColorOption, ExitStatus, TestArgs, block_number_map::BlockNumberMap,
     run_tests::package::run_for_package, scarb::build_artifacts_with_scarb,
@@ -38,8 +43,18 @@ 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;
+    // TODO: Update this check for `2.12.0` before merging
+    if scarb_version.build.is_empty() {
+        error_if_not_snforge_std_compatibility(&scarb_metadata)?;
+        error_if_snforge_std_compatibility_not_compatible(&scarb_metadata)?;
+        warn_if_snforge_std_compatibility_not_compatible(&scarb_metadata, &ui)?;
+    } else {
+        error_if_snforge_std_not_compatible(&scarb_metadata)?;
+        warn_if_snforge_std_not_compatible(&scarb_metadata, &ui)?;
+        warn_if_snforge_std_compatibility_on_new_scarb(&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,70 @@ fn snforge_std_recommended_version() -> VersionReq {
     }
 }
 
+pub fn error_if_not_snforge_std_compatibility(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_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_version_requirement = VersionReq {
+        comparators: vec![snforge_std_version_requirement_comparator],
+    };
+
+    if !package_matches_version_requirement(
+        scarb_metadata,
+        "snforge_std_compatibility",
+        &snforge_std_version_requirement,
+    )? {
+        return Err(anyhow!(
+            "Package snforge_std_compatibility version does not meet the minimum required version {snforge_std_version_requirement}. Please upgrade snforge_std in Scarb.toml"
+        ));
+    }
+    Ok(())
+}
+
+pub fn warn_if_snforge_std_compatibility_not_compatible(
+    scarb_metadata: &Metadata,
+    ui: &UI,
+) -> Result<()> {
+    let snforge_std_version_requirement = snforge_std_recommended_version();
+    if !package_matches_version_requirement(
+        scarb_metadata,
+        "snforge_std_compatibility",
+        &snforge_std_version_requirement,
+    )? {
+        ui.println(&WarningMessage::new(&format!(
+            "Package snforge_std_compatibility version does not meet the recommended version requirement {snforge_std_version_requirement}, it might result in unexpected behaviour"
+        )));
+    }
+    Ok(())
+}
+
+pub fn warn_if_snforge_std_compatibility_on_new_scarb(scarb_metadata: &Metadata, ui: &UI) {
+    if scarb_metadata
+        .packages
+        .iter()
+        .any(|p| p.name == "snforge_std_compatibility")
+    {
+        ui.println(&WarningMessage::new(&"Package snforge_std_compatibility should not be used on Scarb versions >= 2.12.0. Please replace it with snforge_std".to_string()));
+    }
+}
+
 pub fn error_if_snforge_std_not_compatible(scarb_metadata: &Metadata) -> Result<()> {
     let snforge_std_version_requirement_comparator = Comparator {
         op: Op::GreaterEq,