Run tests on a new and compatibility plugin

commit-id:aa2a40e5

Author: cptartur

.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,6 +151,7 @@ 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]
@@ -159,8 +160,23 @@ jobs:
     with:
       overridden_plugin_version: ${{ needs.get-version.outputs.version }}-test.${{ github.run_id }}
 
+  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 }}
+
   publish-std:
-    needs: [get-version, publish-plugin]
+    needs: [get-version, publish-plugin, publish-compatibility-plugin]
     uses: ./.github/workflows/publish-std.yml
     secrets: inherit
     with:

Cargo.lock

@@ -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

@@ -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,12 +401,21 @@ 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.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)?;
 

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()
+}

crates/forge/test_utils/src/lib.rs

@@ -1,4 +1,7 @@
-use crate::{get_assert_macros_version, tempdir_with_tool_versions};
+use crate::{
+    get_assert_macros_version, get_std_name, get_std_path, tempdir_with_tool_versions,
+    use_snforge_std_compatibility,
+};
 use anyhow::{Context, Result, anyhow};
 use assert_fs::{
     TempDir,
@@ -27,6 +30,7 @@ use std::{
     process::{Command, Stdio},
     str::FromStr,
 };
+use walkdir::WalkDir;
 
 /// Represents a dependency of a Cairo project
 #[derive(Debug, Clone)]
@@ -112,6 +116,18 @@ impl Contract {
     }
 }
 
+pub fn replace_snforge_std_with_snforge_std_compatibility(dir: &Path) {
+    let temp_dir_files = WalkDir::new(dir);
+    for entry in temp_dir_files {
+        let entry = entry.unwrap();
+        if entry.path().is_file() {
+            let content = fs::read_to_string(entry.path()).unwrap();
+            let modified_content = content.replace("snforge_std", "snforge_std_compatibility");
+            fs::write(entry.path(), modified_content).unwrap();
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct TestCase {
     dir: TempDir,
@@ -129,31 +145,28 @@ impl<'a> TestCase {
         test_file.touch()?;
         test_file.write_str(test_code)?;
 
-        dir.child("src/lib.cairo").touch().unwrap();
+        if use_snforge_std_compatibility() {
+            replace_snforge_std_with_snforge_std_compatibility(test_file.path());
+        }
 
-        let snforge_std_path = Utf8PathBuf::from_str("../../snforge_std")
-            .unwrap()
-            .canonicalize_utf8()
-            .unwrap()
-            .to_string()
-            .replace('\\', "/");
+        dir.child("src/lib.cairo").touch().unwrap();
 
+        let snforge_std_name = get_std_name();
+        let snforge_std_path = get_std_path().unwrap();
         let assert_macros_version = get_assert_macros_version()?.to_string();
 
         let scarb_toml_path = dir.child("Scarb.toml");
         scarb_toml_path.write_str(&formatdoc!(
             r#"
-                [package]
-                name = "test_package"
-                version = "0.1.0"
-
-                [dependencies]
-                starknet = "2.4.0"
-                snforge_std = {{ path = "{}" }}
-                assert_macros = "{}"
-                "#,
-            snforge_std_path,
-            assert_macros_version
+            [package]
+            name = "test_package"
+            version = "0.1.0"
+
+            [dependencies]
+            starknet = "2.4.0"
+            {snforge_std_name} = {{ path = "{snforge_std_path}" }}
+            assert_macros = "{assert_macros_version}"
+            "#
         ))?;
 
         Ok(Self {

crates/forge/test_utils/src/runner.rs

@@ -1,5 +1,6 @@
 use camino::Utf8PathBuf;
 use packages_validation::check_and_lint;
+use test_utils::use_snforge_std_compatibility;
 
 #[test]
 fn validate_snforge_std() {
@@ -8,5 +9,7 @@ fn validate_snforge_std() {
         .unwrap()
         .try_into()
         .unwrap();
-    check_and_lint(&package_path);
+    if !use_snforge_std_compatibility() {
+        check_and_lint(&package_path);
+    }
 }