Run tests on a new and compatibility plugin

commit-id:aa2a40e5

Author: cptartur

.github/workflows/ci.yml

@@ -272,7 +272,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        # Override scarb version because formatter from 2.12 changes `while` loops to not compile on older Scarbs
       - uses: software-mansion/setup-scarb@v1
+        with:
+          scarb-version: 2.10.1
       - name: Check cairo files format
         run: |
           output=$(find . -type f -name "Scarb.toml" -not -path "*/snforge_std_compatibility/*" -execdir sh -c '

.github/workflows/scheduled.yml

@@ -91,7 +91,7 @@ jobs:
         run: |
           curl -L https://raw.githubusercontent.com/software-mansion/cairo-coverage/main/scripts/install.sh | sh
 
-      - run: cargo test --release -p forge e2e
+      - run: cargo test --release -p forge --features skip_plugin_diagnostics e2e
 
   test-cast:
     if: github.event.repository.fork == false
@@ -151,16 +151,34 @@ jobs:
     uses: ./.github/workflows/_build-plugin-binaries.yml
     with:
       overridden_plugin_version: ${{ needs.get-version.outputs.version }}-test.${{ github.run_id }}
+      plugin_name: 'snforge-scarb-plugin'
 
   publish-plugin:
     needs: [get-version, build-plugin-binaries]
     uses: ./.github/workflows/_publish-plugin.yml
     secrets: inherit
     with:
       overridden_plugin_version: ${{ needs.get-version.outputs.version }}-test.${{ github.run_id }}
+      plugin_name: 'snforge-scarb-plugin'
+
+  build-compatibility-plugin-binaries:
+    name: Build compatibility plugin binaries
+    needs: get-version
+    uses: ./.github/workflows/_build-plugin-binaries.yml
+    with:
+      overridden_plugin_version: ${{ needs.get-version.outputs.version }}-test.${{ github.run_id }}
+      plugin_name: 'snforge-scarb-plugin-compatibility'
+
+  publish-compatibility-plugin:
+    needs: [get-version, build-compatibility-plugin-binaries]
+    uses: ./.github/workflows/_publish-plugin.yml
+    secrets: inherit
+    with:
+      overridden_plugin_version: ${{ needs.get-version.outputs.version }}-test.${{ github.run_id }}
+      plugin_name: 'snforge-scarb-plugin-compatibility'
 
   publish-std:
-    needs: [get-version, publish-plugin]
+    needs: [get-version, publish-plugin, publish-compatibility-plugin]
     uses: ./.github/workflows/publish-std.yml
     secrets: inherit
     with:

.tool-versions

@@ -1,2 +1,2 @@
-scarb nightly-2025-06-18
+scarb nightly-2025-06-18 2.10.1
 starknet-devnet 0.4.3

Cargo.lock

@@ -7,7 +7,9 @@ mod PanicCall {
     fn panic_call(ref self: ContractState) {
         panic(
             array![
-                'shortstring', 0, 0x800000000000011000000000000000000000000000000000000000000000000,
+                'shortstring',
+                0,
+                0x800000000000011000000000000000000000000000000000000000000000000,
                 'shortstring2',
             ],
         );

crates/cheatnet/tests/contracts/src/panic_call.cairo

@@ -11,6 +11,7 @@ scarb_2_9_1 = []
 no_scarb_installed = []
 debugging = []
 assert_non_exact_gas = ["test_utils/assert_non_exact_gas"]
+skip_plugin_diagnostics = []
 supports-panic-backtrace = []
 
 [dependencies]

crates/forge/Cargo.toml

@@ -50,12 +50,12 @@ struct TemplateManifestConfig {
 impl TemplateManifestConfig {
     fn add_dependencies(
         &self,
-        scarb_version: &Version,
         scarb_manifest_path: &PathBuf,
+        use_snforge_std_compatibility: bool,
     ) -> Result<()> {
         if env::var("DEV_DISABLE_SNFORGE_STD_DEPENDENCY").is_err() {
             // TODO: Check Scarb `2.12`
-            let snforge_package = if scarb_version.build.is_empty() {
+            let snforge_package = if use_snforge_std_compatibility {
                 "snforge_std_compatibility"
             } else {
                 "snforge_std"
@@ -76,7 +76,11 @@ impl TemplateManifestConfig {
         Ok(())
     }
 
-    fn update_config(&self, scarb_manifest_path: &Path) -> Result<()> {
+    fn update_config(
+        &self,
+        scarb_manifest_path: &Path,
+        use_snforge_std_compatibility: bool,
+    ) -> Result<()> {
         let scarb_toml_content = fs::read_to_string(scarb_manifest_path)?;
         let mut document = scarb_toml_content
             .parse::<DocumentMut>()
@@ -89,7 +93,7 @@ impl TemplateManifestConfig {
         set_cairo_edition(&mut document, CAIRO_EDITION);
         add_test_script(&mut document);
         add_assert_macros(&mut document)?;
-        add_allow_prebuilt_macros(&mut document)?;
+        add_allow_prebuilt_macros(&mut document, use_snforge_std_compatibility)?;
 
         if self.fork_config {
             add_fork_config(&mut document)?;
@@ -184,18 +188,30 @@ fn overwrite_or_copy_template_files(
     template_path: &Path,
     project_path: &Path,
     project_name: &str,
+    use_snforge_std_compatibility: bool,
 ) -> Result<()> {
     for entry in dir.entries() {
         let path_without_template_name = entry.path().strip_prefix(template_path)?;
         let destination = project_path.join(path_without_template_name);
         match entry {
             DirEntry::Dir(dir) => {
                 fs::create_dir_all(&destination)?;
-                overwrite_or_copy_template_files(dir, template_path, project_path, project_name)?;
+                overwrite_or_copy_template_files(
+                    dir,
+                    template_path,
+                    project_path,
+                    project_name,
+                    use_snforge_std_compatibility,
+                )?;
             }
             DirEntry::File(file) => {
                 let contents = file.contents();
                 let contents = replace_project_name(contents, project_name)?;
+                let contents = if use_snforge_std_compatibility {
+                    replace_imports_snforge_std_with_compatibility(&contents)?
+                } else {
+                    contents
+                };
                 fs::write(destination, contents)?;
             }
         }
@@ -204,6 +220,12 @@ fn overwrite_or_copy_template_files(
     Ok(())
 }
 
+fn replace_imports_snforge_std_with_compatibility(contents: &[u8]) -> Result<Vec<u8>> {
+    let contents = std::str::from_utf8(contents).context("UTF-8 error")?;
+    let contents = contents.replace("snforge_std::", "snforge_std_compatibility::");
+    Ok(contents.into_bytes())
+}
+
 fn replace_project_name(contents: &[u8], project_name: &str) -> Result<Vec<u8>> {
     let contents = std::str::from_utf8(contents).context("UTF-8 error")?;
     let contents = contents.replace("{{ PROJECT_NAME }}", project_name);
@@ -251,7 +273,10 @@ fn add_assert_macros(document: &mut DocumentMut) -> Result<()> {
     Ok(())
 }
 
-fn add_allow_prebuilt_macros(document: &mut DocumentMut) -> Result<()> {
+fn add_allow_prebuilt_macros(
+    document: &mut DocumentMut,
+    use_snforge_std_compatibility: bool,
+) -> Result<()> {
     let tool_section = document.entry("tool").or_insert(Item::Table(Table::new()));
     let tool_table = tool_section
         .as_table_mut()
@@ -261,7 +286,11 @@ fn add_allow_prebuilt_macros(document: &mut DocumentMut) -> Result<()> {
     let mut scarb_table = Table::new();
 
     let mut allow_prebuilt_macros = Array::new();
-    allow_prebuilt_macros.push("snforge_std");
+    if use_snforge_std_compatibility {
+        allow_prebuilt_macros.push("snforge_std_compatibility");
+    } else {
+        allow_prebuilt_macros.push("snforge_std");
+    }
 
     scarb_table.insert(
         "allow-prebuilt-plugins",
@@ -372,21 +401,32 @@ pub fn new(
         create_snfoundry_manifest(&snfoundry_manifest_path)?;
     }
 
+    // TODO: Check Scarb `2.12`
+    let use_snforge_compatibility = scarb_version.build.is_empty();
+
     let template_config = TemplateManifestConfig::try_from(&template)?;
-    template_config.add_dependencies(&scarb_version, &scarb_manifest_path)?;
-    template_config.update_config(&scarb_manifest_path)?;
+    template_config.add_dependencies(&scarb_manifest_path, use_snforge_compatibility)?;
+    template_config.update_config(&scarb_manifest_path, use_snforge_compatibility)?;
 
     let template_dir = get_template_dir(&template)?;
-    overwrite_or_copy_template_files(&template_dir, template_dir.path(), &project_path, &name)?;
+    overwrite_or_copy_template_files(
+        &template_dir,
+        template_dir.path(),
+        &project_path,
+        &name,
+        use_snforge_compatibility,
+    )?;
 
     extend_gitignore(&project_path)?;
 
     // Fetch to create lock file.
-    ScarbCommand::new_with_stdio()
-        .manifest_path(scarb_manifest_path)
-        .arg("fetch")
-        .run()
-        .context("Failed to fetch created project")?;
+    if env::var("DEV_USE_OFFLINE_MODE").is_err() {
+        ScarbCommand::new_with_stdio()
+            .manifest_path(scarb_manifest_path)
+            .arg("fetch")
+            .run()
+            .context("Failed to fetch created project")?;
+    }
 
     Ok(())
 }

crates/forge/src/new.rs

@@ -120,16 +120,14 @@ mod tests {
     use crate::scarb::config::ForkTarget;
     use assert_fs::TempDir;
     use assert_fs::fixture::{FileWriteStr, PathChild, PathCopy};
-    use camino::Utf8PathBuf;
     use cheatnet::runtime_extensions::forge_config_extension::config::BlockId;
     use configuration::load_package_config;
     use forge_runner::forge_config::ForgeTrackedResource;
     use indoc::{formatdoc, indoc};
     use scarb_api::metadata::MetadataCommandExt;
     use scarb_metadata::PackageId;
     use std::env;
-    use std::str::FromStr;
-    use test_utils::tempdir_with_tool_versions;
+    use test_utils::{get_snforge_std_entry, tempdir_with_tool_versions};
 
     fn setup_package(package_name: &str) -> TempDir {
         let temp = tempdir_with_tool_versions().unwrap();
@@ -139,12 +137,7 @@ mod tests {
         )
         .unwrap();
 
-        let snforge_std_path = Utf8PathBuf::from_str("../../snforge_std")
-            .unwrap()
-            .canonicalize_utf8()
-            .unwrap()
-            .to_string()
-            .replace('\\', "/");
+        let snforge_std_entry = get_snforge_std_entry().unwrap();
 
         let manifest_path = temp.child("Scarb.toml");
         manifest_path
@@ -156,7 +149,7 @@ mod tests {
 
                 [dependencies]
                 starknet = "2.4.0"
-                snforge_std = {{ path = "{}" }}
+                {}
 
                 [[tool.snforge.fork]]
                 name = "FIRST_FORK_NAME"
@@ -179,7 +172,7 @@ mod tests {
                 block_id.tag = "latest"
                 "#,
                 package_name,
-                snforge_std_path
+                snforge_std_entry
             ))
             .unwrap();
 

crates/forge/src/scarb.rs

@@ -9,6 +9,7 @@ edition.workspace = true
 assert_non_exact_gas = []
 
 [dependencies]
+walkdir.workspace = true
 anyhow.workspace = true
 shared.workspace = true
 blockifier.workspace = true

crates/forge/test_utils/Cargo.toml

@@ -1,21 +1,17 @@
 pub mod runner;
 pub mod running_tests;
 
-use std::path::PathBuf;
-
 use anyhow::Result;
 use assert_fs::fixture::PathCopy;
+use camino::Utf8PathBuf;
 use project_root::get_project_root;
 use scarb_api::ScarbCommand;
 use semver::Version;
+use std::str::FromStr;
 
 const DEFAULT_ASSERT_MACROS: Version = Version::new(0, 1, 0);
 const MINIMAL_SCARB_FOR_CORRESPONDING_ASSERT_MACROS: Version = Version::new(2, 8, 0);
 
-pub fn get_local_snforge_std_absolute_path() -> Result<PathBuf> {
-    Ok(get_project_root()?.canonicalize()?.join("snforge_std"))
-}
-
 pub fn tempdir_with_tool_versions() -> Result<assert_fs::TempDir> {
     let project_root = get_project_root()?;
     let temp_dir = assert_fs::TempDir::new()?;
@@ -33,3 +29,35 @@ pub fn get_assert_macros_version() -> Result<Version> {
         };
     Ok(assert_macros_version)
 }
+
+#[must_use]
+pub fn get_std_name() -> String {
+    if use_snforge_std_compatibility() {
+        "snforge_std_compatibility".to_string()
+    } else {
+        "snforge_std".to_string()
+    }
+}
+
+pub fn get_std_path() -> Result<String> {
+    let name = get_std_name();
+    Ok(Utf8PathBuf::from_str(&format!("../../{name}"))?
+        .canonicalize_utf8()?
+        .to_string())
+}
+
+pub fn get_snforge_std_entry() -> Result<String> {
+    let name = get_std_name();
+    let path = get_std_path()?;
+
+    Ok(format!("{name} = {{ path = \"{path}\" }}"))
+}
+
+#[must_use]
+pub fn use_snforge_std_compatibility() -> bool {
+    let scarb_version_output = ScarbCommand::version()
+        .run()
+        .expect("Failed to get scarb version");
+    // TODO: Replace with condition for `2.12`
+    scarb_version_output.scarb.build.is_empty()
+}