soroban_rs/macros/
mod.rs

1pub use soroban_rs_macros::soroban;
2
3#[cfg(test)]
4pub mod test {
5    use stellar_xdr::curr::{ScAddress, ScVal};
6
7    use super::*;
8    use crate::{
9        self as soroban_rs,
10        mock::{
11            account::mock_signer2, mock_account_entry, mock_contract_id, mock_env, mock_signer1,
12            mock_simulate_tx_response, mock_transaction_response,
13        },
14        Account, ClientContractConfigs,
15    };
16
17    soroban!(
18        r#"
19        pub struct Token;
20    
21        impl Token {
22            pub fn __constructor(env: Env, value: u32) {
23                env.storage().instance().set(&KEY, &value);
24            }
25    
26            pub fn send(env: &Env, from: Address, to: Address) -> Vec<String> {
27                let from_str = from.to_string();
28                let to_str = to.to_string();
29                vec![&env, from_str, to_str]
30            }
31        }
32    "#
33    );
34
35    #[tokio::test]
36    async fn test_token_contract() {
37        let simulate_transaction_envelope_result = mock_simulate_tx_response(None);
38
39        let signer_1_account_id = mock_signer1().account_id().0.to_string();
40        let get_account_result = mock_account_entry(&signer_1_account_id);
41
42        let send_transaction_result = Ok(mock_transaction_response());
43
44        let env = mock_env(
45            Some(Ok(get_account_result)),
46            Some(Ok(simulate_transaction_envelope_result)),
47            Some(send_transaction_result),
48        );
49        let account = Account::single(mock_signer1());
50        let client_configs = ClientContractConfigs {
51            contract_id: mock_contract_id(account.clone(), &env),
52            env: env.clone(),
53            source_account: account.clone(),
54        };
55
56        // uses autogenerated TokenClient
57        let mut token_contract = TokenClient::new(&client_configs);
58
59        let alice = ScVal::Address(ScAddress::Account(mock_signer1().account_id()));
60        let bob = ScVal::Address(ScAddress::Account(mock_signer2().account_id()));
61
62        let res = token_contract.send(alice, bob).await;
63        assert!(res.is_ok());
64        assert_eq!(
65            res.unwrap().response.result_meta,
66            mock_transaction_response().response.result_meta
67        );
68    }
69
70    // Genarates Token2Client
71    soroban!(
72        r#"
73        pub struct Token2;
74    
75        impl Token2 {
76            pub fn __constructor(env: Env, value: u32) {
77                env.storage().instance().set(&KEY, &value);
78            }
79    
80            pub fn transfer(env: &Env) -> Vec<String> {
81                vec![&env]
82            }
83        }
84    "#
85    );
86    #[tokio::test]
87    async fn test_token_contract_no_inputs() {
88        let simulate_transaction_envelope_result = mock_simulate_tx_response(None);
89
90        let signer_1_account_id = mock_signer1().account_id().0.to_string();
91        let get_account_result = mock_account_entry(&signer_1_account_id);
92
93        let send_transaction_result = Ok(mock_transaction_response());
94
95        let env = mock_env(
96            Some(Ok(get_account_result)),
97            Some(Ok(simulate_transaction_envelope_result)),
98            Some(send_transaction_result),
99        );
100        let account = Account::single(mock_signer1());
101        let client_configs = ClientContractConfigs {
102            contract_id: mock_contract_id(account.clone(), &env),
103            env: env.clone(),
104            source_account: account.clone(),
105        };
106
107        // uses autogenerated TokenClient
108        let mut token_contract = Token2Client::new(&client_configs);
109
110        let res: Result<_, crate::SorobanHelperError> = token_contract.transfer().await;
111        assert!(res.is_ok());
112        assert_eq!(
113            res.unwrap().response.result_meta,
114            mock_transaction_response().response.result_meta
115        );
116    }
117
118    // Genarates TokenMockClient
119    soroban!("fixtures/lib.rs");
120
121    #[tokio::test]
122    async fn test_token_load_from_path() {
123        let simulate_transaction_envelope_result = mock_simulate_tx_response(None);
124
125        let signer_1_account_id = mock_signer1().account_id().0.to_string();
126        let get_account_result = mock_account_entry(&signer_1_account_id);
127
128        let send_transaction_result = Ok(mock_transaction_response());
129
130        let env = mock_env(
131            Some(Ok(get_account_result)),
132            Some(Ok(simulate_transaction_envelope_result)),
133            Some(send_transaction_result),
134        );
135        let account = Account::single(mock_signer1());
136        let client_configs = ClientContractConfigs {
137            contract_id: mock_contract_id(account.clone(), &env),
138            env: env.clone(),
139            source_account: account.clone(),
140        };
141
142        // uses autogenerated TokenMockClient
143        let mut token_mock_contract = TokenMockClient::new(&client_configs);
144
145        let alice = ScVal::Address(ScAddress::Account(mock_signer1().account_id()));
146        let bob = ScVal::Address(ScAddress::Account(mock_signer2().account_id()));
147
148        let res = token_mock_contract.send(alice, bob).await;
149        assert!(res.is_ok());
150        assert_eq!(
151            res.unwrap().response.result_meta,
152            mock_transaction_response().response.result_meta
153        );
154    }
155}