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