tests: refactor for better readability

listings/getting-started/constructor/src/constructor.cairo

@@ -19,32 +19,27 @@ pub mod ExampleConstructor {
 
 #[cfg(test)]
 mod tests {
-    use starknet::testing::set_contract_address;
-    use starknet::{ContractAddress, contract_address_const};
-    use starknet::SyscallResultTrait;
-    use starknet::syscalls::deploy_syscall;
-
     use super::{ExampleConstructor, ExampleConstructor::namesContractMemberStateTrait};
+    use starknet::{ContractAddress, SyscallResultTrait, syscalls::deploy_syscall};
+    use starknet::{contract_address_const, testing::{set_contract_address}};
 
     #[test]
     fn should_deploy_with_constructor_init_value() {
         let name: felt252 = 'bob';
         let address: ContractAddress = contract_address_const::<'caller'>();
 
-        let mut calldata: Array::<felt252> = array![];
-        calldata.append(name);
-        calldata.append(address.into());
-
-        let (address_0, _) = deploy_syscall(
-            ExampleConstructor::TEST_CLASS_HASH.try_into().unwrap(), 0, calldata.span(), false
+        let (contract_address, _) = deploy_syscall(
+            ExampleConstructor::TEST_CLASS_HASH.try_into().unwrap(),
+            0,
+            array![name, address.into()].span(),
+            false
         )
             .unwrap_syscall();
 
-        let state = ExampleConstructor::unsafe_new_contract_state();
-        set_contract_address(address_0);
+        let state = ExampleConstructor::contract_state_for_testing();
+        set_contract_address(contract_address);
 
         let name = state.names.read(address);
-
-        assert(name == 'bob', 'name should be bob');
+        assert_eq!(name, 'bob');
     }
 }

listings/getting-started/counter/src/counter.cairo

@@ -44,17 +44,17 @@ pub mod SimpleCounter {
 #[cfg(test)]
 mod test {
     use super::{SimpleCounter, ISimpleCounterDispatcher, ISimpleCounterDispatcherTrait};
-    use starknet::ContractAddress;
-    use starknet::syscalls::deploy_syscall;
-    use starknet::SyscallResultTrait;
+    use starknet::{ContractAddress, SyscallResultTrait, syscalls::deploy_syscall};
 
     fn deploy(init_value: u128) -> ISimpleCounterDispatcher {
-        let calldata: Array<felt252> = array![init_value.into()];
-        let (address0, _) = deploy_syscall(
-            SimpleCounter::TEST_CLASS_HASH.try_into().unwrap(), 0, calldata.span(), false
+        let (contract_address, _) = deploy_syscall(
+            SimpleCounter::TEST_CLASS_HASH.try_into().unwrap(),
+            0,
+            array![init_value.into()].span(),
+            false
         )
             .unwrap_syscall();
-        ISimpleCounterDispatcher { contract_address: address0 }
+        ISimpleCounterDispatcher { contract_address }
     }
 
     #[test]
@@ -63,49 +63,46 @@ mod test {
         let contract = deploy(init_value);
 
         let read_value = contract.get_current_count();
-        assert(read_value == init_value, 'wrong init value');
+        assert_eq!(read_value, init_value);
     }
 
     #[test]
-    #[available_gas(2000000000)]
     fn should_increment() {
         let init_value = 10;
         let contract = deploy(init_value);
 
         contract.increment();
-        assert(contract.get_current_count() == init_value + 1, 'wrong increment value');
+        assert_eq!(contract.get_current_count(), init_value + 1);
 
         contract.increment();
         contract.increment();
-        assert(contract.get_current_count() == init_value + 3, 'wrong increment value');
+        assert_eq!(contract.get_current_count(), init_value + 3);
     }
 
     #[test]
-    #[available_gas(2000000000)]
     fn should_decrement() {
         let init_value = 10;
         let contract = deploy(init_value);
 
         contract.decrement();
-        assert(contract.get_current_count() == init_value - 1, 'wrong decrement value');
+        assert_eq!(contract.get_current_count(), init_value - 1);
 
         contract.decrement();
         contract.decrement();
-        assert(contract.get_current_count() == init_value - 3, 'wrong decrement value');
+        assert_eq!(contract.get_current_count(), init_value - 3);
     }
 
     #[test]
-    #[available_gas(2000000000)]
     fn should_increment_and_decrement() {
         let init_value = 10;
         let contract = deploy(init_value);
 
         contract.increment();
         contract.decrement();
-        assert(contract.get_current_count() == init_value, 'wrong value');
+        assert_eq!(contract.get_current_count(), init_value);
 
         contract.decrement();
         contract.increment();
-        assert(contract.get_current_count() == init_value, 'wrong value');
+        assert_eq!(contract.get_current_count(), init_value);
     }
 }

listings/getting-started/mappings/src/mappings.cairo

@@ -33,24 +33,18 @@ pub mod MapContract {
 #[cfg(test)]
 mod test {
     use super::{MapContract, IMapContractDispatcher, IMapContractDispatcherTrait};
-    use starknet::ContractAddress;
-    use starknet::SyscallResultTrait;
-    use starknet::syscalls::deploy_syscall;
+    use starknet::{ContractAddress, SyscallResultTrait, syscalls::deploy_syscall};
 
     #[test]
     fn test_deploy_and_set_get() {
-        let mut calldata: Array<felt252> = array![];
-        let (address0, _) = deploy_syscall(
-            MapContract::TEST_CLASS_HASH.try_into().unwrap(), 0, calldata.span(), false
+        let (contract_address, _) = deploy_syscall(
+            MapContract::TEST_CLASS_HASH.try_into().unwrap(), 0, array![].span(), false
         )
             .unwrap_syscall();
-
-        let mut contract = IMapContractDispatcher { contract_address: address0 };
+        let mut contract = IMapContractDispatcher { contract_address };
 
         // Write to map.
         let value: felt252 = 1;
-        let contract_address: ContractAddress = address0;
-
         contract.set(key: contract_address, value: value);
 
         // Read from map.

listings/getting-started/storage/src/contract.cairo

@@ -13,11 +13,10 @@ pub mod Contract {
 #[cfg(test)]
 mod test {
     use super::Contract;
-    use starknet::SyscallResultTrait;
-    use starknet::syscalls::deploy_syscall;
-    use storage::contract::Contract::__member_module_a::InternalContractMemberStateTrait as InternalA;
-    use storage::contract::Contract::__member_module_b::InternalContractMemberStateTrait as InternalB;
-    use storage::contract::Contract::__member_module_c::InternalContractMemberStateTrait as InternalC;
+    use starknet::{SyscallResultTrait, syscalls::deploy_syscall};
+    use storage::contract::Contract::{
+        aContractMemberStateTrait, bContractMemberStateTrait, cContractMemberStateTrait
+    };
 
     #[starknet::interface]
     trait ITestContract<T> {}

listings/getting-started/storage/src/minimal_contract.cairo

@@ -9,8 +9,7 @@ pub mod Contract {
 #[cfg(test)]
 mod test {
     use super::Contract;
-    use starknet::SyscallResultTrait;
-    use starknet::syscalls::deploy_syscall;
+    use starknet::{SyscallResultTrait, syscalls::deploy_syscall};
 
     #[test]
     fn test_can_deploy() {

listings/getting-started/variables/src/global_variables.cairo

@@ -26,8 +26,7 @@ pub mod GlobalExample {
 #[cfg(test)]
 mod test {
     use super::GlobalExample;
-    use starknet::SyscallResultTrait;
-    use starknet::syscalls::deploy_syscall;
+    use starknet::{SyscallResultTrait, syscalls::deploy_syscall};
 
     #[test]
     fn test_can_deploy() {

listings/getting-started/variables/src/local_variables.cairo

@@ -34,8 +34,7 @@ mod test {
         LocalVariablesExample, ILocalVariablesExampleDispatcher,
         ILocalVariablesExampleDispatcherTrait
     };
-    use starknet::SyscallResultTrait;
-    use starknet::syscalls::deploy_syscall;
+    use starknet::{SyscallResultTrait, syscalls::deploy_syscall};
 
     #[test]
     fn test_can_deploy_and_do_something() {

listings/getting-started/variables/src/storage_variables.cairo

@@ -37,8 +37,7 @@ mod test {
         StorageVariablesExample, StorageVariablesExample::valueContractMemberStateTrait,
         IStorageVariableExampleDispatcher, IStorageVariableExampleDispatcherTrait
     };
-    use starknet::SyscallResultTrait;
-    use starknet::syscalls::deploy_syscall;
+    use starknet::{SyscallResultTrait, syscalls::deploy_syscall};
     use starknet::testing::set_contract_address;
 
     #[test]

listings/getting-started/visibility/src/visibility.cairo

@@ -39,7 +39,7 @@ pub mod ExampleContract {
     // We name the trait `PrivateFunctionsTrait` to indicate that it is an
     // internal trait allowing us to call internal functions.
     #[generate_trait]
-    impl PrivateFunctions of PrivateFunctionsTrait {
+    pub impl PrivateFunctions of PrivateFunctionsTrait {
         // The `_read_value` function is outside the implementation that is
         // marked as `#[abi(embed_v0)]`, so it's an _internal_ function
         // and can only be called from within the contract.
@@ -54,28 +54,49 @@ pub mod ExampleContract {
 
 #[cfg(test)]
 mod test {
-    use visibility::visibility::{IExampleContract, ExampleContract};
+    use super::{ExampleContract, IExampleContractDispatcher, IExampleContractDispatcherTrait};
+    use starknet::{ContractAddress, SyscallResultTrait, syscalls::deploy_syscall};
 
-    use starknet::{
-        ContractAddress, get_contract_address, contract_address_const,
-        testing::{set_contract_address}
-    };
+    // These imports will allow us to directly access and set the contract state:
+    // - for `value` storage variable access
+    use super::ExampleContract::valueContractMemberStateTrait;
+    // - for `PrivateFunctionsTrait` internal functions access
+    //   implementation need to be public to be able to access it
+    use super::ExampleContract::PrivateFunctionsTrait;
+    // to set the contract address for the state
+    // and also be able to use the dispatcher on the same contract
+    use starknet::testing::set_contract_address;
 
-    fn setup() -> ExampleContract::ContractState {
+    #[test]
+    fn can_call_set_and_get() {
+        let (contract_address, _) = deploy_syscall(
+            ExampleContract::TEST_CLASS_HASH.try_into().unwrap(), 0, array![].span(), false
+        )
+            .unwrap_syscall();
+
+        // You can interact with the external entrypoints of the contract using the dispatcher.
+        let contract = IExampleContractDispatcher { contract_address };
+        // But for internal functions, you need to use the contract state.
         let mut state = ExampleContract::contract_state_for_testing();
-        let contract_address = contract_address_const::<0x1>();
         set_contract_address(contract_address);
-        state
-    }
 
-    #[test]
-    #[available_gas(2000000000)]
-    fn can_call_set_and_get() {
-        let mut state = setup();
-        let init_value: u32 = 42;
-        state.set(init_value);
-        let received_value = state.get();
+        // The contract dispatcher and state refer to the same contract.
+        assert_eq!(contract.get(), state.value.read());
+
+        // We can set from the dispatcher
+        contract.set(42);
+        assert_eq!(contract.get(), state.value.read());
+        assert_eq!(42, state.value.read());
+        assert_eq!(42, contract.get());
+
+        // Or directly from the state for more complex operations
+        state.value.write(24);
+        assert_eq!(contract.get(), state.value.read());
+        assert_eq!(24, state.value.read());
+        assert_eq!(24, contract.get());
 
-        assert(received_value == init_value, 'wrong value received');
+        // We can also acces internal functions from the state
+        assert_eq!(state._read_value(), state.value.read());
+        assert_eq!(state._read_value(), contract.get());
     }
 }