available_gas support (#1514)

<!-- Reference any GitHub issues resolved by this PR -->

Closes #618

## Introduced changes

<!-- A brief description of the changes -->

- `available_gas` attribute can be used with snforge now

## Checklist

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

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

Author: war-in

.tool-versions

@@ -1 +1 @@
-scarb 2.4.0
+scarb 2.4.4

CHANGELOG.md

@@ -13,6 +13,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - `store` and `load` cheatcodes
 
+#### Changed
+
+- `available_gas` attribute is now supported (Scarb >= 2.4.4 is required)
+
 #### Fixed
 
 - Error message for tests that should panic but pass

Cargo.lock

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 
+use crate::test_case_summary::{Single, TestCaseSummary};
 use blockifier::fee::eth_gas_constants;
 use blockifier::fee::fee_utils::calculate_tx_l1_gas_usage;
 use blockifier::fee::gas_usage::get_message_segment_length;
@@ -106,3 +107,27 @@ fn get_onchain_data_segment_length(state_changes_count: StateChangesCount) -> us
 
     onchain_data_segment_length
 }
+
+pub fn check_available_gas(
+    available_gas: &Option<usize>,
+    summary: TestCaseSummary<Single>,
+) -> TestCaseSummary<Single> {
+    match summary {
+        TestCaseSummary::Passed {
+            name,
+            arguments,
+            gas_info,
+            ..
+        } if available_gas.map_or(false, |available_gas| gas_info > available_gas as u128) => {
+            TestCaseSummary::Failed {
+                name,
+                msg: Some(format!(
+                    "\n\tTest cost exceeded the available gas. Consumed gas: ~{gas_info}"
+                )),
+                arguments,
+                test_statistics: (),
+            }
+        }
+        _ => summary,
+    }
+}

crates/forge-runner/src/gas.rs

@@ -176,19 +176,15 @@ pub fn run_test_case(
     runner_params: &Arc<RunnerParams>,
 ) -> Result<RunResultWithInfo> {
     ensure!(
-        case.available_gas.is_none(),
-        "\n    Attribute `available_gas` is not supported\n"
+        case.available_gas != Some(0),
+        "\n\t`available_gas` attribute was incorrectly configured. Make sure you use scarb >= 2.4.4\n"
     );
-    let available_gas = Some(usize::MAX);
 
     let func = runner.find_function(case.name.as_str()).unwrap();
-    let initial_gas = runner
-        .get_initial_available_gas(func, available_gas)
-        .unwrap();
     let runner_args: Vec<Arg> = args.into_iter().map(Arg::Value).collect();
 
     let (entry_code, builtins) = runner
-        .create_entry_code(func, &runner_args, initial_gas)
+        .create_entry_code(func, &runner_args, usize::MAX)
         .unwrap();
     let footer = SierraCasmRunner::create_code_footer();
     let instructions = chain!(
@@ -301,7 +297,7 @@ fn extract_test_case_summary(
             }
         }
         // `ForkStateReader.get_block_info`, `get_fork_state_reader` may return an error
-        // unsupported `available_gas` attribute may be specified
+        // `available_gas` may be specified with Scarb ~2.4
         Err(error) => Ok(TestCaseSummary::Failed {
             name: case.name.clone(),
             msg: Some(error.to_string()),

crates/forge-runner/src/running.rs

@@ -380,6 +380,7 @@ impl SierraCasmRunner {
 
     /// Returns the initial value for the gas counter.
     /// If `available_gas` is None returns 0.
+    #[allow(dead_code)]
     pub fn get_initial_available_gas(
         &self,
         func: &Function,
@@ -401,6 +402,7 @@ impl SierraCasmRunner {
             .ok_or(RunnerError::NotEnoughGasToCall)
     }
 
+    #[allow(dead_code)]
     pub fn initial_required_gas(&self, func: &Function) -> Option<usize> {
         if self.metadata.gas_info.function_costs.is_empty() {
             return None;

crates/forge-runner/src/sierra_casm_runner.rs

@@ -1,5 +1,6 @@
 use crate::compiled_runnable::TestCaseRunnable;
 use crate::expected_result::{ExpectedPanicValue, ExpectedTestResult};
+use crate::gas::check_available_gas;
 use cairo_felt::Felt252;
 use cairo_lang_runner::short_string::as_cairo_short_string;
 use cairo_lang_runner::{RunResult, RunResultValue};
@@ -195,13 +196,16 @@ impl TestCaseSummary<Single> {
         let msg = extract_result_data(&run_result, &test_case.expected_result);
         match run_result.value {
             RunResultValue::Success(_) => match &test_case.expected_result {
-                ExpectedTestResult::Success => TestCaseSummary::Passed {
-                    name,
-                    msg,
-                    arguments,
-                    test_statistics: (),
-                    gas_info: gas,
-                },
+                ExpectedTestResult::Success => {
+                    let summary = TestCaseSummary::Passed {
+                        name,
+                        msg,
+                        arguments,
+                        test_statistics: (),
+                        gas_info: gas,
+                    };
+                    check_available_gas(&test_case.available_gas, summary)
+                }
                 ExpectedTestResult::Panics(_) => TestCaseSummary::Failed {
                     name,
                     msg,

crates/forge-runner/src/test_case_summary.rs

@@ -2,12 +2,11 @@ use anyhow::{anyhow, Context, Ok, Result};
 
 use include_dir::{include_dir, Dir};
 
-use regex::Regex;
+use scarb_api::version::scarb_version_command;
 use scarb_api::ScarbCommand;
 use std::fs::{self, OpenOptions};
 use std::io::Write;
 use std::path::Path;
-use std::str::from_utf8;
 use toml_edit::{value, ArrayOfTables, Document, Item, Table};
 
 const CAIRO_EDITION: &str = "2023_10";
@@ -106,25 +105,7 @@ pub fn run(project_name: &str) -> Result<()> {
         .run()
         .context("Failed to add snforge_std")?;
 
-    let scarb_version = ScarbCommand::new()
-        .arg("--version")
-        .inherit_stderr()
-        .command()
-        .output()
-        .context("Failed to execute `scarb --version`")?;
-    let version_output = from_utf8(&scarb_version.stdout)
-        .context("Failed to parse `scarb --version` output to UTF-8")?;
-
-    let cairo_version_regex = Regex::new(r"(?:cairo:?\s*)([0-9]+.[0-9]+.[0-9]+)")
-        .expect("Could not create cairo version matching regex");
-    let cairo_version_capture = cairo_version_regex
-        .captures(version_output)
-        .expect("Could not find cairo version");
-    let cairo_version = cairo_version_capture
-        .get(1)
-        .expect("Could not find cairo version")
-        .as_str();
-
+    let cairo_version = scarb_version_command()?.cairo;
     ScarbCommand::new_with_stdio()
         .current_dir(&project_path)
         .offline()

crates/forge/src/init.rs

@@ -3,14 +3,17 @@ use camino::Utf8Path;
 
 use crate::scarb::load_test_artifacts;
 use forge_runner::test_case_summary::AnyTestCaseSummary;
+use semver::Version;
 use std::sync::Arc;
 
 use compiled_raw::{CompiledTestCrateRaw, RawForkConfig, RawForkParams};
 use forge_runner::test_crate_summary::TestCrateSummary;
 use forge_runner::{RunnerConfig, RunnerParams, TestCrateRunResult};
 
 use crate::block_number_map::BlockNumberMap;
+use crate::pretty_printing::print_warning;
 use forge_runner::compiled_runnable::{CompiledTestCrateRunnable, TestCaseRunnable};
+use scarb_api::version::scarb_version_command;
 
 use crate::scarb::config::ForkTarget;
 use crate::test_filter::TestsFilter;
@@ -105,6 +108,8 @@ pub async fn run(
     let not_filtered: usize = test_crates.iter().map(|tc| tc.test_cases.len()).sum();
     let filtered = all_tests - not_filtered;
 
+    warn_if_available_gas_used_with_incompatible_scarb_version(&test_crates)?;
+
     pretty_printing::print_collected_tests_count(
         test_crates.iter().map(|tests| tests.test_cases.len()).sum(),
         package_name,
@@ -164,6 +169,25 @@ pub async fn run(
     Ok(summaries)
 }
 
+fn warn_if_available_gas_used_with_incompatible_scarb_version(
+    test_crates: &Vec<CompiledTestCrateRaw>,
+) -> Result<()> {
+    for test_crate in test_crates {
+        for case in &test_crate.test_cases {
+            if case.available_gas == Some(0)
+                && scarb_version_command()?.scarb <= Version::new(2, 4, 3)
+            {
+                print_warning(&anyhow!(
+                    "`available_gas` attribute was probably specified when using Scarb ~2.4.3 \
+                    Make sure to use Scarb >=2.4.4"
+                ));
+            }
+        }
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;