Redesigned init_new_project_test (#2400)

Closes
[#2274](#2274 (comment)),
Closes
[#2393](#2393)

## Introduced changes
- `init_new_project_test` only expects `snforge test` to pass on a newly
created project and no longer asserts concrete Starknet/Foundry versions
- `test_init_project_with_custom_snforge_dependency_git` tests
downloading dustom `snforge_std` dependency from a remote branch, as
`init_new_project_test` would before. The test is marked with
`#cfg[feature = "smoke"]` so it can be ran conditionally, e.g. on CI or
smoke tests

## Checklist

<!-- Make sure all of these are complete -->

- [x] Linked relevant issue
- [ ] Updated relevant documentation
- [x] Added relevant tests
- [x] Performed self-review of the code
- [ ] Added changes to `CHANGELOG.md`

Author: integraledelebesgue

Cargo.lock

@@ -5,6 +5,9 @@ edition.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[features]
+smoke = []
+
 [dependencies]
 anyhow.workspace = true
 blockifier.workspace = true
@@ -61,6 +64,7 @@ num-integer.workspace = true
 url.workspace = true
 trace-data.workspace = true
 fs_extra.workspace = true
+project-root.workspace = true
 
 [[bin]]
 name = "snforge"

crates/forge/Cargo.toml

@@ -2,6 +2,7 @@ use crate::CAIRO_EDITION;
 use anyhow::{anyhow, Context, Ok, Result};
 use include_dir::{include_dir, Dir};
 use scarb_api::ScarbCommand;
+use std::env;
 use std::fs::{self, OpenOptions};
 use std::io::Write;
 use std::path::Path;
@@ -103,8 +104,6 @@ pub fn run(project_name: &str) -> Result<()> {
             .context("Failed to initialize a new project")?;
     }
 
-    let version = env!("CARGO_PKG_VERSION");
-
     ScarbCommand::new_with_stdio()
         .current_dir(&project_path)
         .manifest_path(manifest_path.clone())
@@ -115,19 +114,23 @@ pub fn run(project_name: &str) -> Result<()> {
         .run()
         .context("Failed to remove cairo_test")?;
 
-    ScarbCommand::new_with_stdio()
-        .current_dir(&project_path)
-        .manifest_path(manifest_path.clone())
-        .offline()
-        .arg("add")
-        .arg("--dev")
-        .arg("snforge_std")
-        .arg("--git")
-        .arg("https://github.com/foundry-rs/starknet-foundry.git")
-        .arg("--tag")
-        .arg(format!("v{version}"))
-        .run()
-        .context("Failed to add snforge_std")?;
+    let version = env!("CARGO_PKG_VERSION");
+
+    if env::var("DEV_DISABLE_SNFORGE_STD_DEPENDENCY").is_err() {
+        ScarbCommand::new_with_stdio()
+            .current_dir(&project_path)
+            .manifest_path(manifest_path.clone())
+            .offline()
+            .arg("add")
+            .arg("--dev")
+            .arg("snforge_std")
+            .arg("--git")
+            .arg("https://github.com/foundry-rs/starknet-foundry.git")
+            .arg("--tag")
+            .arg(format!("v{version}"))
+            .run()
+            .context("Failed to add snforge_std")?;
+    }
 
     let cairo_version = ScarbCommand::version().run()?.cairo;
 

crates/forge/src/init.rs

@@ -1,11 +1,18 @@
 pub mod runner;
 pub mod running_tests;
 
+use std::path::PathBuf;
+
 use anyhow::Result;
 use assert_fs::fixture::PathCopy;
+use project_root::get_project_root;
+
+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 = project_root::get_project_root()?;
+    let project_root = get_project_root()?;
     let temp_dir = assert_fs::TempDir::new()?;
     temp_dir.copy_from(project_root, &[".tool-versions"])?;
     Ok(temp_dir)

crates/forge/test_utils/src/lib.rs

@@ -6,9 +6,10 @@ use camino::Utf8PathBuf;
 use forge::CAIRO_EDITION;
 use indoc::{formatdoc, indoc};
 use shared::test_utils::output_assert::assert_stdout_contains;
-use std::{env, fs, path::Path, str::FromStr};
-use test_utils::tempdir_with_tool_versions;
-use toml_edit::{value, DocumentMut, Item};
+use snapbox::assert_matches;
+use std::{fs, path::Path, str::FromStr};
+use test_utils::{get_local_snforge_std_absolute_path, tempdir_with_tool_versions};
+use toml_edit::{value, DocumentMut, Formatted, InlineTable, Item, Value};
 
 #[test]
 fn simple_package() {
@@ -655,90 +656,143 @@ fn with_exit_first_flag() {
     );
 }
 
-// TODO (2274): This test has inherently flawed logic, needs to be re-written
-#[ignore]
 #[test]
 fn init_new_project_test() {
     let temp = tempdir_with_tool_versions().unwrap();
 
-    runner(&temp).args(["init", "test_name"]).assert().success();
-    let manifest_path = temp.child("test_name/Scarb.toml");
+    runner(&temp)
+        .args(["init", "test_name"])
+        .env("DEV_DISABLE_SNFORGE_STD_DEPENDENCY", "true")
+        .assert()
+        .success();
+
+    let manifest_path = temp.join("test_name/Scarb.toml");
+    let scarb_toml = std::fs::read_to_string(manifest_path.clone()).unwrap();
 
-    let generated_toml = std::fs::read_to_string(manifest_path.path()).unwrap();
-    let version = env!("CARGO_PKG_VERSION");
-    let expected_toml = formatdoc!(
+    let expected = formatdoc!(
         r#"
             [package]
             name = "test_name"
             version = "0.1.0"
-            edition = "{}"
+            edition = "{CAIRO_EDITION}"
 
             # See more keys and their definitions at https://docs.swmansion.com/scarb/docs/reference/manifest.html
 
             [dependencies]
-            starknet = "2.6.4"
+            starknet = "[..]"
 
             [dev-dependencies]
-            snforge_std = {{ git = "https://github.com/foundry-rs/starknet-foundry", tag = "v{}" }}
 
             [[target.starknet-contract]]
             sierra = true
 
             [scripts]
             test = "snforge test"
-        "#,
-        CAIRO_EDITION,
-        version,
+        "#
     );
 
-    assert_eq!(generated_toml, expected_toml);
+    assert_matches(&expected, &scarb_toml);
 
-    let remote_url = get_remote_url();
-    let branch = get_current_branch();
-    manifest_path
-        .write_str(&formatdoc!(
-            r#"
-        [package]
-        name = "test_name"
-        version = "0.1.0"
+    let mut scarb_toml = DocumentMut::from_str(&scarb_toml).unwrap();
 
-        [[target.starknet-contract]]
+    let dependencies = scarb_toml
+        .get_mut("dev-dependencies")
+        .unwrap()
+        .as_table_mut()
+        .unwrap();
 
-        [dependencies]
-        starknet = "2.5.4"
+    let local_snforge_std = get_local_snforge_std_absolute_path()
+        .unwrap()
+        .to_str()
+        .unwrap()
+        .to_string();
 
-        [dev-dependencies]
-        snforge_std = {{ git = "https://github.com/{}", branch = "{}" }}
-        "#,
-            remote_url,
-            branch
-        ))
-        .unwrap();
+    let mut snforge_std = InlineTable::new();
+    snforge_std.insert("path", Value::String(Formatted::new(local_snforge_std)));
+
+    dependencies.remove("snforge_std");
+    dependencies.insert("snforge_std", Item::Value(Value::InlineTable(snforge_std)));
+
+    std::fs::write(manifest_path, scarb_toml.to_string()).unwrap();
 
-    // Check if template works with current version of snforge_std
     let output = test_runner(&temp)
         .current_dir(temp.child(Path::new("test_name")))
         .assert()
         .success();
-    assert_stdout_contains(
-        output,
-        formatdoc!(
-            r"
-        [..]Updating git repository https://github.com/{}
+
+    let expected = indoc!(
+        r"
         [..]Compiling test_name v0.1.0[..]
         [..]Finished[..]
 
+        Collected 2 test(s) from test_name package
+        Running 0 test(s) from src/
+        Running 2 test(s) from tests/
+        [PASS] test_name_integrationtest::test_contract::test_increase_balance [..]
+        [PASS] test_name_integrationtest::test_contract::test_cannot_increase_balance_with_zero_value [..]
+        Tests: 2 passed, 0 failed, 0 skipped, 0 ignored, 0 filtered out
+        "
+    );
+
+    assert_stdout_contains(output, expected);
+}
+
+#[test]
+#[cfg(feature = "smoke")]
+fn test_init_project_with_custom_snforge_dependency_git() {
+    let temp = tempdir_with_tool_versions().unwrap();
+
+    runner(&temp)
+        .args(["init", "test_name"])
+        .env("DEV_DISABLE_SNFORGE_STD_DEPENDENCY", "true")
+        .assert()
+        .success();
+
+    let manifest_path = temp.child("test_name/Scarb.toml");
+
+    let scarb_toml = std::fs::read_to_string(manifest_path.path()).unwrap();
+    let mut scarb_toml = DocumentMut::from_str(&scarb_toml).unwrap();
+
+    let dependencies = scarb_toml
+        .get_mut("dev-dependencies")
+        .unwrap()
+        .as_table_mut()
+        .unwrap();
+
+    let branch = get_current_branch();
+    let remote_url = format!("https://github.com/{}", get_remote_url());
+
+    let mut snforge_std = InlineTable::new();
+    snforge_std.insert("git", Value::String(Formatted::new(remote_url.clone())));
+    snforge_std.insert("branch", Value::String(Formatted::new(branch)));
+
+    dependencies.remove("snforge_std");
+    dependencies.insert("snforge_std", Item::Value(Value::InlineTable(snforge_std)));
+
+    std::fs::write(manifest_path.path(), scarb_toml.to_string()).unwrap();
+
+    let output = test_runner(&temp)
+        .current_dir(temp.child(Path::new("test_name")))
+        .assert()
+        .success();
+
+    let expected = formatdoc!(
+        r"
+        [..]Updating git repository {}
+        [..]Compiling test_name v0.1.0[..]
+        [..]Finished[..]
 
         Collected 2 test(s) from test_name package
         Running 0 test(s) from src/
         Running 2 test(s) from tests/
         [PASS] test_name_integrationtest::test_contract::test_increase_balance [..]
         [PASS] test_name_integrationtest::test_contract::test_cannot_increase_balance_with_zero_value [..]
         Tests: 2 passed, 0 failed, 0 skipped, 0 ignored, 0 filtered out
-    ",
-            remote_url.trim_end_matches(".git")
-        ),
+        ",
+        remote_url.trim_end_matches(".git")
     );
+
+    assert_stdout_contains(output, expected);
 }
 
 #[test]

crates/forge/tests/e2e/running.rs

@@ -202,8 +202,8 @@ pub fn package_matches_version_requirement(
         .filter(|package| package.name == name);
 
     match (packages.next(), packages.next()) {
-        (None, None) => Ok(true),
         (Some(package), None) => Ok(version_req.matches(&package.version)),
+        (None, None) => Err(anyhow!("Package {name} is not present in dependencies.")),
         _ => Err(anyhow!("Package {name} is duplicated in dependencies")),
     }
 }
@@ -246,7 +246,7 @@ mod tests {
                 [dependencies]
                 starknet = "2.4.0"
                 snforge_std = {{ path = "{}" }}
-                
+
                 [[target.starknet-contract]]
 
                 [[tool.snforge.fork]]
@@ -328,12 +328,14 @@ mod tests {
             &VersionReq::parse("2.5").unwrap(),
         )
         .unwrap());
+
         assert!(package_matches_version_requirement(
             &scarb_metadata,
             "not_existing",
             &VersionReq::parse("2.5").unwrap(),
         )
-        .unwrap());
+        .is_err());
+
         assert!(!package_matches_version_requirement(
             &scarb_metadata,
             "starknet",