test(payments): add test utils

Author: MohammadNassar1

src/tests.cairo

@@ -1 +1,3 @@
+pub mod account_contract;
 pub mod test_payments;
+pub mod test_utils;

src/tests/account_contract.cairo

@@ -0,0 +1,69 @@
+#[starknet::contract(account)]
+pub mod SRC9AccountMock {
+    use openzeppelin::account::AccountComponent;
+    use openzeppelin::account::extensions::SRC9Component;
+    use openzeppelin::introspection::src5::SRC5Component;
+    use starknet::storage::StoragePointerWriteAccess;
+
+    component!(path: AccountComponent, storage: account, event: AccountEvent);
+    component!(path: SRC5Component, storage: src5, event: SRC5Event);
+    component!(path: SRC9Component, storage: src9, event: SRC9Event);
+
+    // Account
+    #[abi(embed_v0)]
+    impl SRC6Impl = AccountComponent::SRC6Impl<ContractState>;
+    #[abi(embed_v0)]
+    impl PublicKeyImpl = AccountComponent::PublicKeyImpl<ContractState>;
+    impl AccountInternalImpl = AccountComponent::InternalImpl<ContractState>;
+
+    // SRC9
+    #[abi(embed_v0)]
+    impl OutsideExecutionV2Impl =
+        SRC9Component::OutsideExecutionV2Impl<ContractState>;
+    impl OutsideExecutionInternalImpl = SRC9Component::InternalImpl<ContractState>;
+
+    // SCR5
+    #[abi(embed_v0)]
+    impl SRC5Impl = SRC5Component::SRC5Impl<ContractState>;
+
+    #[storage]
+    pub struct Storage {
+        pub value: felt252,
+        #[substorage(v0)]
+        pub account: AccountComponent::Storage,
+        #[substorage(v0)]
+        pub src9: SRC9Component::Storage,
+        #[substorage(v0)]
+        pub src5: SRC5Component::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        AccountEvent: AccountComponent::Event,
+        #[flat]
+        SRC9Event: SRC9Component::Event,
+        #[flat]
+        SRC5Event: SRC5Component::Event,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, public_key: felt252) {
+        self.account.initializer(public_key);
+        self.src9.initializer();
+    }
+
+    #[abi(per_item)]
+    #[generate_trait]
+    impl ExternalImpl of ExternalTrait {
+        #[external(v0)]
+        fn set_value(ref self: ContractState, value: felt252, panic: bool) {
+            self.account.assert_only_self();
+            if panic {
+                panic!("Some error");
+            }
+            self.value.write(value);
+        }
+    }
+}

src/tests/test_payments.cairo

@@ -1,6 +1,4 @@
 use core::num::traits::Zero;
-use openzeppelin::utils::serde::SerializedAppend;
-use openzeppelin_testing::deployment::declare_and_deploy;
 use snforge_std::{map_entry_address, store};
 use starknet::ContractAddress;
 use starknet_payments::errors;
@@ -9,37 +7,12 @@ use starknet_payments::interface::{
     IPaymentsSafeDispatcherTrait,
 };
 use starkware_utils::time::time::Timestamp;
+use starkware_utils_testing::constants as testing_constants;
 use starkware_utils_testing::test_utils::{
     assert_panic_with_error, assert_panic_with_felt_error, cheat_caller_address_once,
 };
-use starkware_utils_testing::{constants as testing_constants, test_utils};
 use crate::order::Order;
-
-pub mod constants {
-    use super::*;
-    pub const UPGRADE_DELAY: u64 = 0;
-    pub const FEE_LIMIT: u128 = 1000;
-    pub const FEE_RECIPIENT: ContractAddress = 'FEE_RECIPIENT'.try_into().unwrap();
-    pub const FEE: u128 = 0;
-}
-
-fn deploy_contract() -> ContractAddress {
-    let mut calldata = array![];
-    calldata.append_serde(testing_constants::GOVERNANCE_ADMIN);
-    calldata.append_serde(constants::UPGRADE_DELAY);
-    calldata.append_serde(constants::FEE_LIMIT);
-    calldata.append_serde(constants::FEE_RECIPIENT);
-    calldata.append_serde(constants::FEE);
-    declare_and_deploy("payments", calldata)
-}
-
-pub fn init_contract_with_roles() -> ContractAddress {
-    let contract_address = deploy_contract();
-    test_utils::set_default_roles(
-        contract: contract_address, governance_admin: testing_constants::GOVERNANCE_ADMIN,
-    );
-    contract_address
-}
+use crate::tests::test_utils::*;
 
 fn default_order() -> Order {
     Order {

src/tests/test_utils.cairo

@@ -0,0 +1,64 @@
+use openzeppelin::utils::serde::SerializedAppend;
+use openzeppelin_testing::deployment::declare_and_deploy;
+use snforge_std::signature::stark_curve::{StarkCurveKeyPairImpl, StarkCurveSignerImpl};
+use snforge_std::signature::{KeyPair, KeyPairTrait};
+use snforge_std::{Token, TokenImpl, TokenTrait, set_balance};
+use starknet::ContractAddress;
+use starkware_utils_testing::{constants as testing_constants, test_utils};
+use crate::payments::payments::SNIP12MetadataImpl;
+
+pub mod constants {
+    use super::*;
+    pub const UPGRADE_DELAY: u64 = 0;
+    pub const FEE_LIMIT: u128 = 1000;
+    pub const FEE_RECIPIENT: ContractAddress = 'FEE_RECIPIENT'.try_into().unwrap();
+    pub const FEE: u128 = 100;
+}
+
+fn deploy_contract() -> ContractAddress {
+    let mut calldata = array![];
+    calldata.append_serde(testing_constants::GOVERNANCE_ADMIN);
+    calldata.append_serde(constants::UPGRADE_DELAY);
+    calldata.append_serde(constants::FEE_LIMIT);
+    calldata.append_serde(constants::FEE_RECIPIENT);
+    calldata.append_serde(constants::FEE);
+    declare_and_deploy("payments", calldata)
+}
+
+pub fn init_contract_with_roles() -> ContractAddress {
+    let contract_address = deploy_contract();
+    test_utils::set_default_roles(
+        contract: contract_address, governance_admin: testing_constants::GOVERNANCE_ADMIN,
+    );
+    contract_address
+}
+
+pub fn test_setup() -> (
+    ContractAddress,
+    ContractAddress,
+    ContractAddress,
+    ContractAddress,
+    ContractAddress,
+    KeyPair<felt252, felt252>,
+    KeyPair<felt252, felt252>,
+) {
+    let contract_address = init_contract_with_roles();
+
+    let secret_key_a = 1;
+    let key_pair_a = KeyPairTrait::from_secret_key(secret_key_a);
+    let public_key_a = key_pair_a.public_key;
+    let user_a = declare_and_deploy("SRC9AccountMock", array![public_key_a]);
+
+    let secret_key_b = 1;
+    let key_pair_b = KeyPairTrait::from_secret_key(secret_key_b);
+    let public_key_b = key_pair_b.public_key;
+    let user_b = declare_and_deploy("SRC9AccountMock", array![public_key_b]);
+
+    let token_a = Token::STRK.contract_address();
+    let token_b = Token::ETH.contract_address();
+
+    set_balance(user_a, 10_000, Token::STRK);
+    set_balance(user_b, 10_000, Token::ETH);
+
+    (contract_address, token_a, token_b, user_a, user_b, key_pair_a, key_pair_b)
+}