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