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 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 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 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 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 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}