Fix #[test_case] not adding required config_run if (#3900)

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

Closes #3885 

## Introduced changes

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

- Add better handling in `test_case` with removing duplication of
`#[__internal_config_statement]` and adding it if necessary, with 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: MKowalski8

CHANGELOG.md

@@ -13,6 +13,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Gas values in fuzzing test output are now displayed as whole numbers without fractional parts
 
+#### Fixed
+
+- A bug that prevented the `#[test_case]` attribute from being used on its own with cheatcodes
+
 ## [0.51.2] - 2025-10-31
 
 ### Cast

crates/forge/tests/data/test_case/src/lib.cairo

@@ -1,9 +1,29 @@
+#[starknet::interface]
+pub trait IValueStorage<TContractState> {
+    fn set_value(ref self: TContractState, value: u128);
+    fn get_value(self: @TContractState) -> u128;
+}
+
 #[starknet::contract]
-pub mod HelloStarknet {
+pub mod ValueStorage {
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+
     #[storage]
-    struct Storage {}
-}
+    struct Storage {
+        stored_value: u128,
+    }
+
+    #[abi(embed_v0)]
+    impl ValueStorageImpl of super::IValueStorage<ContractState> {
+        fn set_value(ref self: ContractState, value: u128) {
+            self.stored_value.write(value);
+        }
 
+        fn get_value(self: @ContractState) -> u128 {
+            self.stored_value.read()
+        }
+    }
+}
 
 pub fn add(a: felt252, b: felt252) -> felt252 {
     a + b

crates/forge/tests/data/test_case/tests/with_deploy.cairo

@@ -0,0 +1,29 @@
+use snforge_std::{ContractClassTrait, DeclareResultTrait, declare};
+use test_case::{IValueStorageDispatcher, IValueStorageDispatcherTrait};
+
+#[test]
+#[test_case(100)]
+#[test_case(42)]
+#[test_case(0)]
+fn with_contract_deploy(value: u128) {
+    let contract = declare("ValueStorage").unwrap().contract_class();
+    let (contract_address, _) = contract.deploy(@array![]).unwrap();
+    let dispatcher = IValueStorageDispatcher { contract_address };
+
+    dispatcher.set_value(value);
+    assert!(dispatcher.get_value() == value, "Value mismatch");
+}
+
+#[test]
+#[fuzzer]
+#[test_case(123)]
+#[test_case(0)]
+fn with_fuzzer_and_contract_deploy(value: u128) {
+    let contract = declare("ValueStorage").unwrap().contract_class();
+    let (contract_address, _) = contract.deploy(@array![]).unwrap();
+    let dispatcher = IValueStorageDispatcher { contract_address };
+
+    dispatcher.set_value(value);
+    assert!(dispatcher.get_value() == value, "FAIL");
+}
+

crates/forge/tests/e2e/test_case.rs

@@ -144,3 +144,66 @@ fn addition_with_name_arg() {
         "},
     );
 }
+
+#[test]
+#[cfg_attr(
+    feature = "skip_test_for_only_latest_scarb",
+    ignore = "Plugin checks skipped"
+)]
+fn with_contract_deploy() {
+    let temp = setup_package("test_case");
+
+    let output = test_runner(&temp)
+        .arg("with_contract_deploy")
+        .assert()
+        .code(0);
+
+    assert_stdout_contains(
+        output,
+        indoc! {r"
+        [..]Compiling[..]
+        [..]Finished[..]
+
+
+        Collected 3 test(s) from test_case package
+        Running 3 test(s) from tests/
+        [PASS] test_case_integrationtest::with_deploy::with_contract_deploy_100 [..]
+        [PASS] test_case_integrationtest::with_deploy::with_contract_deploy_42 [..]
+        [PASS] test_case_integrationtest::with_deploy::with_contract_deploy_0 [..]
+        Running 0 test(s) from src/
+        Tests: 3 passed, 0 failed, 0 ignored, [..] filtered out
+        "},
+    );
+}
+
+#[test]
+#[cfg_attr(
+    feature = "skip_test_for_only_latest_scarb",
+    ignore = "Plugin checks skipped"
+)]
+fn with_fuzzer_and_contract_deploy() {
+    let temp = setup_package("test_case");
+
+    let output = test_runner(&temp)
+        .arg("with_fuzzer_and_contract_deploy")
+        .assert()
+        .code(0);
+
+    assert_stdout_contains(
+        output,
+        indoc! {r"
+        [..]Compiling[..]
+        [..]Finished[..]
+
+
+        Collected 3 test(s) from test_case package
+        Running 3 test(s) from tests/
+        [PASS] test_case_integrationtest::with_deploy::with_fuzzer_and_contract_deploy_123 [..]
+        [PASS] test_case_integrationtest::with_deploy::with_fuzzer_and_contract_deploy_0 [..]
+        [PASS] test_case_integrationtest::with_deploy::with_fuzzer_and_contract_deploy [..]
+        Running 0 test(s) from src/
+        Tests: 3 passed, 0 failed, 0 ignored, [..] filtered out
+        Fuzzer seed: [..]
+        "},
+    );
+}

crates/snforge-scarb-plugin/src/attributes/test_case.rs

@@ -1,11 +1,14 @@
 use crate::args::Arguments;
 use crate::args::unnamed::UnnamedArgs;
+use crate::attributes::internal_config_statement::InternalConfigStatementCollector;
 use crate::attributes::test::{TestCollector, test_func_with_attrs};
 use crate::attributes::test_case::name::test_case_name;
 use crate::attributes::{AttributeInfo, ErrorExt};
-use crate::common::{has_fuzzer_attribute, into_proc_macro_result, with_parsed_values};
-use crate::format_ident;
+use crate::common::{
+    has_fuzzer_attribute, has_test_attribute, into_proc_macro_result, with_parsed_values,
+};
 use crate::utils::SyntaxNodeUtils;
+use crate::{create_single_token, format_ident};
 use cairo_lang_macro::{Diagnostic, Diagnostics, ProcMacroResult, TokenStream, quote};
 use cairo_lang_parser::utils::SimpleParserDatabase;
 use cairo_lang_syntax::node::ast::FunctionWithBody;
@@ -40,7 +43,7 @@ fn test_case_internal(
 
     let func_name = func.declaration(db).name(db);
     let case_fn_name = test_case_name(&func_name.text(db), &args, args_db)?;
-    let filtered_fn_attrs = collect_attrs_excluding_test_without_fuzzer(func, db);
+    let filtered_fn_attrs = collect_preserved_attributes_for_test_case(func, db);
 
     let signature = func.declaration(db).signature(db).as_syntax_node();
     let signature = SyntaxNodeWithDb::new(&signature, db);
@@ -57,8 +60,20 @@ fn test_case_internal(
 
     let test_func_with_attrs = test_func_with_attrs(&case_fn_name, &func_name, &call_args);
 
+    // If the function has both `#[fuzzer]` and `#[test]` attributes, we do not need to add
+    // `#[__internal_config_statement]` attribute, since it will be handled by `#[test]`.
+    let skip_internal_config = has_fuzzer_attribute(db, func) && has_test_attribute(db, func);
+    let internal_config_attr = if skip_internal_config {
+        TokenStream::empty()
+    } else {
+        let internal_config = create_single_token(InternalConfigStatementCollector::ATTR_NAME);
+        quote!(#[#internal_config])
+    };
+
     let func_ident = quote!(
         #filtered_fn_attrs
+
+        #internal_config_attr
         fn #func_name #signature
         #func_body
     );
@@ -112,23 +127,27 @@ fn ensure_params_valid(
     Ok(())
 }
 
-fn collect_attrs_excluding_test_without_fuzzer(
+fn collect_preserved_attributes_for_test_case(
     func: &FunctionWithBody,
     func_db: &SimpleParserDatabase,
 ) -> TokenStream {
     let attr_list = func.attributes(func_db);
     let has_fuzzer = has_fuzzer_attribute(func_db, func);
 
-    // We do not want to copy the `#[test]` attribute if there is no `#[fuzzer]`
+    // We do not want to copy the `#[test]` attribute unless the function has `#[fuzzer]`.
+    // We also do not want to copy `#[__internal_config_statement]` because it will be added later.
     attr_list
         .elements(func_db)
         .filter(|attr| {
             let test_attr_text = format!("#[{}]", TestCollector::ATTR_NAME);
+            let internal_config_attr_text =
+                format!("#[{}]", InternalConfigStatementCollector::ATTR_NAME);
             let attr_text = attr.as_syntax_node().get_text(func_db);
             let attr_text = attr_text.trim();
             let is_test_attr = attr_text == test_attr_text;
+            let is_internal_config_attr = attr_text == internal_config_attr_text;
 
-            !is_test_attr || has_fuzzer
+            (!is_test_attr || has_fuzzer) && !is_internal_config_attr
         })
         .map(|attr| attr.to_token_stream(func_db))
         .fold(TokenStream::empty(), |mut acc, token| {

crates/snforge-scarb-plugin/src/common.rs

@@ -3,6 +3,7 @@ use crate::{
     attributes::{
         AttributeInfo,
         fuzzer::{FuzzerCollector, FuzzerConfigCollector, wrapper::FuzzerWrapperCollector},
+        test::TestCollector,
         test_case::TestCaseCollector,
     },
     parse::{parse, parse_args},
@@ -92,3 +93,8 @@ pub fn has_test_case_attribute(db: &SimpleParserDatabase, func: &FunctionWithBod
     const TEST_CASE_ATTRIBUTES: [&str; 1] = [TestCaseCollector::ATTR_NAME];
     has_any_attribute(db, func, &TEST_CASE_ATTRIBUTES)
 }
+
+pub fn has_test_attribute(db: &SimpleParserDatabase, func: &FunctionWithBody) -> bool {
+    const TEST_ATTRIBUTES: [&str; 1] = [TestCollector::ATTR_NAME];
+    has_any_attribute(db, func, &TEST_ATTRIBUTES)
+}

crates/snforge-scarb-plugin/tests/integration/multiple_attributes.rs

@@ -544,6 +544,7 @@ fn works_with_test_fuzzer_and_test_case() {
 
             #[__fuzzer_config]
             #[__fuzzer_wrapper]
+            #[__internal_config_statement]
             fn test_add(x: i128, y: i128, expected: i128) {}
         ",
     );

crates/snforge-scarb-plugin/tests/integration/single_attributes/test_case.rs

@@ -32,6 +32,7 @@ fn works_with_args() {
                 let mut arr = ArrayTrait::new();
                 core::array::ArrayTrait::span(@arr)
             }
+            #[__internal_config_statement]
             fn test_add(x: i128, y: i128, expected: i128) {}
         ",
     );
@@ -61,6 +62,7 @@ fn works_with_name_and_args() {
                 let mut arr = ArrayTrait::new();
                 core::array::ArrayTrait::span(@arr)
             }
+            #[__internal_config_statement]
             fn test_add(x: i128, y: i128, expected: i128) {}
         ",
     );