Small coverage validation refactor (#3654)

Related #3272

commit-id:075b62ba

---

**Stack**:
- #3656
- #3655
- #3654 ⬅


⚠️ *Part of a stack created by [spr](https://github.com/ejoffe/spr). Do
not merge manually using the UI - doing so may have unexpected results.*

Author: ksew1

crates/forge-runner/src/coverage_api.rs

@@ -1,25 +1,14 @@
 use anyhow::{Context, Result, ensure};
-use indoc::{formatdoc, indoc};
-use scarb_api::metadata::Metadata;
-use semver::Version;
+use indoc::indoc;
 use shared::command::CommandExt;
 use std::ffi::OsString;
 use std::process::Stdio;
 use std::{env, fs, path::PathBuf, process::Command};
-use toml_edit::{DocumentMut, Table};
 use which::which;
 
 pub const COVERAGE_DIR: &str = "coverage";
 pub const OUTPUT_FILE_NAME: &str = "coverage.lcov";
 
-const MINIMAL_SCARB_VERSION: Version = Version::new(2, 8, 0);
-
-const CAIRO_COVERAGE_REQUIRED_ENTRIES: [(&str, &str); 3] = [
-    ("unstable-add-statements-functions-debug-info", "true"),
-    ("unstable-add-statements-code-locations-debug-info", "true"),
-    ("inlining-strategy", "avoid"),
-];
-
 pub fn run_coverage(saved_trace_data_paths: &[PathBuf], coverage_args: &[OsString]) -> Result<()> {
     let coverage = env::var("CAIRO_COVERAGE")
         .map(PathBuf::from)
@@ -67,54 +56,3 @@ pub fn run_coverage(saved_trace_data_paths: &[PathBuf], coverage_args: &[OsStrin
 
     Ok(())
 }
-
-pub fn can_coverage_be_generated(scarb_metadata: &Metadata) -> Result<()> {
-    let manifest = fs::read_to_string(&scarb_metadata.runtime_manifest)?.parse::<DocumentMut>()?;
-
-    ensure!(
-        scarb_metadata.app_version_info.version >= MINIMAL_SCARB_VERSION,
-        "Coverage generation requires scarb version >= {MINIMAL_SCARB_VERSION}",
-    );
-
-    let has_needed_entries = manifest
-        .get("profile")
-        .and_then(|profile| profile.get(&scarb_metadata.current_profile))
-        .and_then(|profile| profile.get("cairo"))
-        .and_then(|cairo| cairo.as_table())
-        .is_some_and(|profile_cairo| {
-            CAIRO_COVERAGE_REQUIRED_ENTRIES
-                .iter()
-                .all(|(key, value)| contains_entry_with_value(profile_cairo, key, value))
-        });
-
-    ensure!(
-        has_needed_entries,
-        formatdoc! {
-            "Scarb.toml must have the following Cairo compiler configuration to run coverage:
-
-            [profile.{profile}.cairo]
-            unstable-add-statements-functions-debug-info = true
-            unstable-add-statements-code-locations-debug-info = true
-            inlining-strategy = \"avoid\"
-            ... other entries ...
-            ",
-            profile = scarb_metadata.current_profile
-        },
-    );
-
-    Ok(())
-}
-
-/// Check if the table contains an entry with the given key and value.
-/// Accepts only bool and string values.
-fn contains_entry_with_value(table: &Table, key: &str, value: &str) -> bool {
-    table.get(key).is_some_and(|entry| {
-        if let Some(entry) = entry.as_bool() {
-            entry.to_string() == value
-        } else if let Some(entry) = entry.as_str() {
-            entry == value
-        } else {
-            false
-        }
-    })
-}

crates/forge/src/lib.rs

@@ -27,6 +27,7 @@ mod combine_configs;
 mod compatibility_check;
 mod init;
 mod new;
+mod profile_validation;
 pub mod run_tests;
 pub mod scarb;
 pub mod shared_cache;

crates/forge/src/profile_validation/coverage.rs

@@ -0,0 +1,53 @@
+use crate::profile_validation::{check_cairo_profile_entries, get_manifest};
+use anyhow::ensure;
+use indoc::formatdoc;
+use scarb_metadata::Metadata;
+use semver::Version;
+
+/// Checks if coverage can be based on scarb version and profile settings extracted from the provided [`Metadata`].
+pub fn check_coverage_compatibility(scarb_metadata: &Metadata) -> anyhow::Result<()> {
+    check_scarb_version(scarb_metadata)?;
+    check_profile(scarb_metadata)?;
+    Ok(())
+}
+
+/// Checks if the scarb version from the provided [`Metadata`] is greater than or equal to the minimal required version.
+fn check_scarb_version(scarb_metadata: &Metadata) -> anyhow::Result<()> {
+    const MINIMAL_SCARB_VERSION: Version = Version::new(2, 8, 0);
+    ensure!(
+        scarb_metadata.app_version_info.version >= MINIMAL_SCARB_VERSION,
+        "Coverage generation requires scarb version >= {MINIMAL_SCARB_VERSION}",
+    );
+    Ok(())
+}
+
+/// Checks if the runtime profile settings in the provided from [`Metadata`] contain the required entries for coverage generation.
+fn check_profile(scarb_metadata: &Metadata) -> anyhow::Result<()> {
+    const CAIRO_COVERAGE_REQUIRED_ENTRIES: &[(&str, &str)] = &[
+        ("unstable-add-statements-functions-debug-info", "true"),
+        ("unstable-add-statements-code-locations-debug-info", "true"),
+        ("inlining-strategy", "avoid"),
+    ];
+
+    let manifest = get_manifest(scarb_metadata)?;
+
+    let has_needed_entries =
+        check_cairo_profile_entries(&manifest, scarb_metadata, CAIRO_COVERAGE_REQUIRED_ENTRIES);
+
+    ensure!(
+        has_needed_entries,
+        formatdoc! {
+            "Scarb.toml must have the following Cairo compiler configuration to run coverage:
+
+            [profile.{profile}.cairo]
+            unstable-add-statements-functions-debug-info = true
+            unstable-add-statements-code-locations-debug-info = true
+            inlining-strategy = \"avoid\"
+            ... other entries ...
+            ",
+            profile = scarb_metadata.current_profile
+        },
+    );
+
+    Ok(())
+}

crates/forge/src/profile_validation/mod.rs

@@ -0,0 +1,55 @@
+mod coverage;
+
+use crate::TestArgs;
+use crate::profile_validation::coverage::check_coverage_compatibility;
+use scarb_metadata::Metadata;
+use std::fs;
+use toml_edit::{DocumentMut, Table};
+
+/// Checks if current profile provided in [`Metadata`] can be used to run coverage and backtrace if applicable.
+pub fn check_profile_compatibility(
+    test_args: &TestArgs,
+    scarb_metadata: &Metadata,
+) -> anyhow::Result<()> {
+    if test_args.coverage {
+        check_coverage_compatibility(scarb_metadata)?;
+    }
+    Ok(())
+}
+
+/// Gets the runtime manifest from the [`Metadata`] and parses it into a [`DocumentMut`].
+fn get_manifest(scarb_metadata: &Metadata) -> anyhow::Result<DocumentMut> {
+    Ok(fs::read_to_string(&scarb_metadata.runtime_manifest)?.parse::<DocumentMut>()?)
+}
+
+/// Check if the Cairo profile entries in the manifest contain the required entries.
+fn check_cairo_profile_entries(
+    manifest: &DocumentMut,
+    scarb_metadata: &Metadata,
+    required_entries: &[(&str, &str)],
+) -> bool {
+    manifest
+        .get("profile")
+        .and_then(|profile| profile.get(&scarb_metadata.current_profile))
+        .and_then(|profile| profile.get("cairo"))
+        .and_then(|cairo| cairo.as_table())
+        .is_some_and(|profile_cairo| {
+            required_entries
+                .iter()
+                .all(|(key, value)| contains_entry_with_value(profile_cairo, key, value))
+        })
+}
+
+/// Check if the table contains an entry with the given key and value.
+/// Accepts only bool and string values.
+fn contains_entry_with_value(table: &Table, key: &str, value: &str) -> bool {
+    table.get(key).is_some_and(|entry| {
+        if let Some(entry) = entry.as_bool() {
+            entry.to_string() == value
+        } else if let Some(entry) = entry.as_str() {
+            entry == value
+        } else {
+            false
+        }
+    })
+}

crates/forge/src/run_tests/workspace.rs

@@ -1,5 +1,6 @@
 use super::package::RunForPackageArgs;
 use super::structs::{LatestBlocksNumbersMessage, TestsFailureSummaryMessage};
+use crate::profile_validation::check_profile_compatibility;
 use crate::run_tests::structs::OverallSummaryMessage;
 use crate::warn::{
     error_if_snforge_std_deprecated_missing, error_if_snforge_std_deprecated_not_compatible,
@@ -13,10 +14,8 @@ use crate::{
     warn::warn_if_snforge_std_does_not_match_package_version,
 };
 use anyhow::{Context, Result};
+use forge_runner::test_case_summary::AnyTestCaseSummary;
 use forge_runner::{CACHE_DIR, test_target_summary::TestTargetSummary};
-use forge_runner::{
-    coverage_api::can_coverage_be_generated, test_case_summary::AnyTestCaseSummary,
-};
 use foundry_ui::UI;
 use scarb_api::{
     ScarbCommand,
@@ -43,9 +42,7 @@ pub async fn run_for_workspace(args: TestArgs, ui: Arc<UI>) -> Result<ExitStatus
     }
     let scarb_metadata = metadata_command.inherit_stderr().run()?;
 
-    if args.coverage {
-        can_coverage_be_generated(&scarb_metadata)?;
-    }
+    check_profile_compatibility(&args, &scarb_metadata)?;
 
     let scarb_version = ScarbCommand::version().run()?.scarb;
     if scarb_version >= MINIMAL_SCARB_VERSION_FOR_V2_MACROS_REQUIREMENT {