Git-Mirrors/xmr-btc-swap
1
0
Fork 0
mirror of https://github.com/comit-network/xmr-btc-swap.git synced 2025-12-16 09:03:54 -05:00
Code Issues Projects Releases Packages Wiki Activity

fix rpc tests, only check for RPC errors and not returned values

Browse source
This commit is contained in:
Lorenzo Tucci 2023-09-01 17:15:24 +03:00
parent ccf9b0c31f
commit a6f2180b1b
No known key found for this signature in database
GPG key ID: D98C4FA2CDF590A0
2 changed files with 102 additions and 249 deletions
Download patch file Download diff file Expand all files Collapse all files

3
swap/src/cli/command.rs
View file

@ -507,7 +507,6 @@ mod tests {
const ARGS_DATA_DIR: &str = "/tmp/dir/"; const ARGS_DATA_DIR: &str = "/tmp/dir/";
#[tokio::test] #[tokio::test]
#[serial]
async fn given_buy_xmr_on_mainnet_then_defaults_to_mainnet() { async fn given_buy_xmr_on_mainnet_then_defaults_to_mainnet() {
let raw_ars = vec![ let raw_ars = vec![
BINARY_NAME, BINARY_NAME,
@ -538,7 +537,6 @@ mod tests {
} }
#[tokio::test] #[tokio::test]
#[serial]
async fn given_buy_xmr_on_testnet_then_defaults_to_testnet() { async fn given_buy_xmr_on_testnet_then_defaults_to_testnet() {
let raw_ars = vec![ let raw_ars = vec![
BINARY_NAME, BINARY_NAME,
@ -1016,7 +1014,6 @@ mod tests {
let args = parse_args_and_apply_defaults(raw_ars).await.unwrap(); let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
let (is_testnet, debug, json) = (false, false, true); let (is_testnet, debug, json) = (false, false, true);
let data_dir = data_dir_path_cli(is_testnet);
let (expected_config, expected_request) = ( let (expected_config, expected_request) = (
Config::default(is_testnet, None, debug, json), Config::default(is_testnet, None, debug, json),

348
swap/tests/rpc.rs
View file

@ -1,11 +1,8 @@
use anyhow::Result;
use jsonrpsee::rpc_params;
use jsonrpsee::ws_client::WsClientBuilder; use jsonrpsee::ws_client::WsClientBuilder;
use jsonrpsee_core::client::ClientT; use jsonrpsee_core::client::ClientT;
use jsonrpsee_core::params::ObjectParams; use jsonrpsee_core::params::ObjectParams;
use serial_test::serial;
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::Arc; use std::sync::Arc;
@ -13,24 +10,20 @@ use std::time::Duration;
use swap::api::request::{Method, Request }; use swap::api::request::{Method, Request };
use swap::api::Context; use swap::api::Context;
use swap::cli::command::{Bitcoin, Monero}; use swap::cli::command::{Bitcoin, Monero};
use tokio::sync::OnceCell;
use uuid::Uuid; use uuid::Uuid;
#[cfg(test)] #[cfg(test)]
// to be replaced with actual "real" testing values
// need to create some kind of swap database and bitcoin environment with some
// funds
const SERVER_ADDRESS: &str = "127.0.0.1:1234"; const SERVER_ADDRESS: &str = "127.0.0.1:1234";
const BITCOIN_ADDR: &str = "tb1qr3em6k3gfnyl8r7q0v7t4tlnyxzgxma3lressv"; const BITCOIN_ADDR: &str = "tb1qr3em6k3gfnyl8r7q0v7t4tlnyxzgxma3lressv";
const MONERO_ADDR: &str = "53gEuGZUhP9JMEBZoGaFNzhwEgiG7hwQdMCqFxiyiTeFPmkbt1mAoNybEUvYBKHcnrSgxnVWgZsTvRBaHBNXPa8tHiCU51a"; const MONERO_ADDR: &str = "53gEuGZUhP9JMEBZoGaFNzhwEgiG7hwQdMCqFxiyiTeFPmkbt1mAoNybEUvYBKHcnrSgxnVWgZsTvRBaHBNXPa8tHiCU51a";
const SELLER: &str = const SELLER: &str =
"/ip4/127.0.0.1/tcp/9939/p2p/12D3KooWCdMKjesXMJz1SiZ7HgotrxuqhQJbP5sgBm2BwP1cqThi"; "/ip4/127.0.0.1/tcp/9939/p2p/12D3KooWCdMKjesXMJz1SiZ7HgotrxuqhQJbP5sgBm2BwP1cqThi";
const SWAP_ID: &str = "ea030832-3be9-454f-bb98-5ea9a788406b";
pub async fn initialize_context() -> (Arc<Context>, Request) { pub async fn initialize_context() -> Arc<Context> {
let (is_testnet, debug, json) = (true, false, false); let (is_testnet, debug, json) = (true, false, false);
// let data_dir = data::data_dir_from(None, is_testnet).unwrap();
let server_address = None; let server_address = None;
let bitcoin = Bitcoin { let bitcoin = Bitcoin {
@ -42,7 +35,6 @@ pub async fn initialize_context() -> (Arc<Context>, Request) {
monero_daemon_address: None, monero_daemon_address: None,
}; };
let request = Request::new(Method::StartDaemon { server_address: None });
let context = Context::build( let context = Context::build(
Some(bitcoin), Some(bitcoin),
@ -57,388 +49,252 @@ pub async fn initialize_context() -> (Arc<Context>, Request) {
.await .await
.unwrap(); .unwrap();
(Arc::new(context), request) Arc::new(context)
} }
#[tokio::test] pub async fn start_server() {
#[serial] ONCE.get_or_init(|| async {
pub async fn can_start_server() { let ctx = initialize_context().await;
let (ctx, mut request) = initialize_context().await; ctx
let move_ctx = Arc::clone(&ctx); }).await;
let request = Request::new(Method::StartDaemon { server_address: None });
tokio::spawn(async move { tokio::spawn(async move {
request.call(Arc::clone(&move_ctx)).await; request.call(Arc::clone(ONCE.get().unwrap())).await
}); });
tokio::time::sleep(Duration::from_secs(3)).await;
assert!(true);
} }
static ONCE: OnceCell<Arc<Context>> = OnceCell::const_new();
#[tokio::test] #[tokio::test]
#[serial]
pub async fn get_bitcoin_balance() { pub async fn get_bitcoin_balance() {
let (ctx, mut request) = initialize_context().await; start_server().await;
let move_ctx = Arc::clone(&ctx);
tokio::spawn(async move {
request.call(Arc::clone(&move_ctx)).await;
});
let url = format!("ws://{}", SERVER_ADDRESS);
tokio::time::sleep(Duration::from_secs(3)).await; tokio::time::sleep(Duration::from_secs(3)).await;
let url = format!("ws://{}", SERVER_ADDRESS);
let mut params = ObjectParams::new();
params.insert("", "").unwrap();
let client = WsClientBuilder::default().build(&url).await.unwrap(); let client = WsClientBuilder::default().build(&url).await.unwrap();
let response: HashMap<String, i32> = client let response: Result<HashMap<String, i32>, jsonrpsee_core::Error> = client
.request("get_bitcoin_balance", rpc_params!["id"]) .request("get_bitcoin_balance", params)
.await .await;
.unwrap();
assert_eq!(response, HashMap::from([("balance".to_string(), 0)])); match response {
Ok(_) => (),
Err(e) => panic!("Expected a HashMap, got an error: {}", e),
}
} }
#[tokio::test] #[tokio::test]
#[serial]
pub async fn get_history() { pub async fn get_history() {
let (ctx, mut request) = initialize_context().await; start_server().await;
let move_ctx = Arc::clone(&ctx);
tokio::spawn(async move {
request.call(Arc::clone(&move_ctx)).await;
});
let url = format!("ws://{}", SERVER_ADDRESS); let url = format!("ws://{}", SERVER_ADDRESS);
tokio::time::sleep(Duration::from_secs(3)).await;
tokio::time::sleep(Duration::from_secs(3)).await;
let client = WsClientBuilder::default().build(&url).await.unwrap(); let client = WsClientBuilder::default().build(&url).await.unwrap();
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("", "").unwrap();
let response: HashMap<String, Vec<(Uuid, String)>> = let response: Result<HashMap<String, Vec<(Uuid, String)>>, jsonrpsee_core::Error> =
client.request("get_history", params).await.unwrap(); client.request("get_history", params).await;
let swaps: Vec<(Uuid, String)> = Vec::new();
assert_eq!(response, HashMap::from([("swaps".to_string(), swaps)])); match response {
Ok(_) => (),
Err(e) => panic!("Expected a HashMap, got an error: {}", e),
}
} }
#[tokio::test] #[tokio::test]
#[serial]
pub async fn get_raw_history() { pub async fn get_raw_history() {
let (ctx, mut request) = initialize_context().await; start_server().await;
let move_ctx = Arc::clone(&ctx);
tokio::spawn(async move {
request.call(Arc::clone(&move_ctx)).await;
});
let url = format!("ws://{}", SERVER_ADDRESS); let url = format!("ws://{}", SERVER_ADDRESS);
tokio::time::sleep(Duration::from_secs(3)).await;
tokio::time::sleep(Duration::from_secs(3)).await;
let client = WsClientBuilder::default().build(&url).await.unwrap(); let client = WsClientBuilder::default().build(&url).await.unwrap();
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
let raw_history: HashMap<Uuid, String> = HashMap::new(); params.insert("", "").unwrap();
let response: HashMap<String, HashMap<Uuid, String>> = let response: Result<HashMap<String, HashMap<Uuid, String>>, jsonrpsee_core::Error> =
client.request("get_raw_history", params).await.unwrap(); client.request("get_raw_history", params).await;
assert_eq!(
response,
HashMap::from([("raw_history".to_string(), raw_history)])
);
}
#[tokio::test]
#[serial]
pub async fn get_seller() {
let (ctx, mut request) = initialize_context().await;
let move_ctx = Arc::clone(&ctx);
tokio::spawn(async move {
request.call(Arc::clone(&move_ctx)).await;
});
let url = format!("ws://{}", SERVER_ADDRESS);
tokio::time::sleep(Duration::from_secs(3)).await;
let client = WsClientBuilder::default().build(&url).await.unwrap();
let mut params = ObjectParams::new();
let response: Result<HashMap<String, String>, _> = client.request("get_seller", params).await;
// We should ideally match the expected error and panic if it's different one,
// but the request returns a custom error (to investigate)
// Err(jsonrpsee_core::Error::Call(CallError::InvalidParams(e))) => (),
// Err(e) => panic!("ErrorType was not ParseError but {e:?}"),
match response { match response {
Err(e) => (), Ok(_) => (),
_ => panic!("Expected an error when swap_id is missing"),
}
let mut params = ObjectParams::new();
params.insert("swap_id", "invalid_swap");
let response: Result<HashMap<String, String>, _> = client.request("get_seller", params).await;
match response {
Err(e) => (),
_ => panic!("Expected an error swap_id is malformed"),
}
let mut params = ObjectParams::new();
params.insert("swap_id", SWAP_ID);
let response: Result<HashMap<String, String>, _> = client.request("get_seller", params).await;
match response {
Ok(hash) => (),
Err(e) => panic!(
"Expected a HashMap with correct params, got an error: {}",
e
),
}
}
#[tokio::test]
#[serial]
pub async fn get_swap_start_date() {
let (ctx, mut request) = initialize_context().await;
let move_ctx = Arc::clone(&ctx);
tokio::spawn(async move {
request.call(Arc::clone(&move_ctx)).await;
});
let url = format!("ws://{}", SERVER_ADDRESS);
tokio::time::sleep(Duration::from_secs(3)).await;
let client = WsClientBuilder::default().build(&url).await.unwrap();
let mut params = ObjectParams::new();
let response: Result<HashMap<String, String>, _> =
client.request("get_swap_start_date", params).await;
match response {
Err(e) => (),
_ => panic!("Expected an error when swap_id is missing"),
}
let mut params = ObjectParams::new();
params.insert("swap_id", "invalid_swap");
let response: Result<HashMap<String, String>, _> =
client.request("get_swap_start_date", params).await;
match response {
Err(e) => (),
_ => panic!("Expected an error when swap_id is malformed"),
}
let mut params = ObjectParams::new();
params.insert("swap_id", SWAP_ID);
let response: Result<HashMap<String, String>, _> =
client.request("get_swap_start_date", params).await;
match response {
Ok(hash) => (),
Err(e) => panic!("Expected a HashMap, got an error: {}", e), Err(e) => panic!("Expected a HashMap, got an error: {}", e),
} }
} }
#[tokio::test] #[tokio::test]
#[serial] pub async fn get_swap_info() {
pub async fn resume_swap() { start_server().await;
let (ctx, mut request) = initialize_context().await;
let move_ctx = Arc::clone(&ctx);
tokio::spawn(async move {
request.call(Arc::clone(&move_ctx)).await;
});
let url = format!("ws://{}", SERVER_ADDRESS); let url = format!("ws://{}", SERVER_ADDRESS);
tokio::time::sleep(Duration::from_secs(3)).await;
tokio::time::sleep(Duration::from_secs(3)).await;
let client = WsClientBuilder::default().build(&url).await.unwrap(); let client = WsClientBuilder::default().build(&url).await.unwrap();
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("", "").unwrap();
let response: Result<HashMap<String, String>, _> = let response: Result<HashMap<String, String>, jsonrpsee_core::Error> =
client.request("get_swap_start_date", params).await; client.request("get_swap_info", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when swap_id is missing"), _ => panic!("Expected an error when swap_id is missing"),
} }
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("swap_id", "invalid_swap"); params.insert("swap_id", "invalid_swap").unwrap();
let response: Result<HashMap<String, String>, _> = let response: Result<HashMap<String, String>, jsonrpsee_core::Error> =
client.request("get_swap_start_date", params).await; client.request("get_swap_info", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when swap_id is malformed"), _ => panic!("Expected an error when swap_id is malformed"),
} }
let mut params = ObjectParams::new();
params.insert("swap_id", SWAP_ID);
let response: Result<HashMap<String, String>, _> =
client.request("get_swap_start_date", params).await;
match response {
Ok(hash) => (),
Err(e) => panic!("Expected a HashMap, got an error: {}", e),
}
} }
#[tokio::test] #[tokio::test]
#[serial]
pub async fn withdraw_btc() { pub async fn withdraw_btc() {
let (ctx, mut request) = initialize_context().await; start_server().await;
let move_ctx = Arc::clone(&ctx);
tokio::spawn(async move {
request.call(Arc::clone(&move_ctx)).await;
});
let url = format!("ws://{}", SERVER_ADDRESS); let url = format!("ws://{}", SERVER_ADDRESS);
tokio::time::sleep(Duration::from_secs(3)).await; tokio::time::sleep(Duration::from_secs(3)).await;
let client = WsClientBuilder::default().build(&url).await.unwrap(); let client = WsClientBuilder::default().build(&url).await.unwrap();
let mut params = ObjectParams::new(); let params = ObjectParams::new();
let response: Result<HashMap<String, String>, _> = client.request("withdraw_btc", params).await; let response: Result<HashMap<String, String>, jsonrpsee_core::Error> = client.request("withdraw_btc", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when withdraw_address is missing"), _ => panic!("Expected an error when withdraw_address is missing"),
} }
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("address", "invalid_address"); params.insert("address", "invalid_address").unwrap();
let response: Result<HashMap<String, String>, _> = client.request("withdraw_btc", params).await; let response: Result<HashMap<String, String>, jsonrpsee_core::Error> = client.request("withdraw_btc", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when withdraw_address is malformed"), _ => panic!("Expected an error when withdraw_address is malformed"),
} }
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("address", BITCOIN_ADDR); params.insert("address", BITCOIN_ADDR).unwrap();
params.insert("amount", "0"); params.insert("amount", "0").unwrap();
let response: Result<HashMap<String, String>, _> = client.request("withdraw_btc", params).await; let response: Result<HashMap<String, String>, jsonrpsee_core::Error> = client.request("withdraw_btc", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when amount is 0"), _ => panic!("Expected an error when amount is 0"),
} }
let mut params = ObjectParams::new();
params.insert("address", BITCOIN_ADDR);
params.insert("amount", "0.1");
let response: Result<HashMap<String, String>, _> = client.request("withdraw_btc", params).await;
match response {
Ok(hash) => (),
Err(e) => panic!("Expected a HashMap, got an error: {}", e),
}
} }
#[tokio::test] #[tokio::test]
#[serial]
pub async fn buy_xmr() { pub async fn buy_xmr() {
let (ctx, mut request) = initialize_context().await; start_server().await;
let move_ctx = Arc::clone(&ctx);
tokio::spawn(async move {
request.call(Arc::clone(&move_ctx)).await;
});
let url = format!("ws://{}", SERVER_ADDRESS); let url = format!("ws://{}", SERVER_ADDRESS);
tokio::time::sleep(Duration::from_secs(3)).await; tokio::time::sleep(Duration::from_secs(3)).await;
let client = WsClientBuilder::default().build(&url).await.unwrap(); let client = WsClientBuilder::default().build(&url).await.unwrap();
let mut params = ObjectParams::new(); let params = ObjectParams::new();
let response: Result<HashMap<String, String>, _> = client.request("buy_xmr", params).await; let response: Result<HashMap<String, String>, jsonrpsee_core::Error> = client.request("buy_xmr", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when no params are given"), _ => panic!("Expected an error when no params are given"),
} }
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("bitcoin_change_address", BITCOIN_ADDR); params.insert("bitcoin_change_address", BITCOIN_ADDR).unwrap();
params.insert("monero_receive_address", MONERO_ADDR); params.insert("monero_receive_address", MONERO_ADDR).unwrap();
let response: Result<HashMap<String, String>, _> = client.request("buy_xmr", params).await; let response: Result<HashMap<String, String>, jsonrpsee_core::Error> = client.request("buy_xmr", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when seller is missing"), _ => panic!("Expected an error when seller is missing"),
} }
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("bitcoin_change_address", BITCOIN_ADDR); params.insert("bitcoin_change_address", BITCOIN_ADDR).unwrap();
params.insert("seller", SELLER); params.insert("seller", SELLER).unwrap();
let response: Result<HashMap<String, String>, _> = client.request("buy_xmr", params).await; let response: Result<HashMap<String, String>, jsonrpsee_core::Error> = client.request("buy_xmr", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when monero_receive_address is missing"), _ => panic!("Expected an error when monero_receive_address is missing"),
} }
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("monero_receive_address", MONERO_ADDR); params.insert("monero_receive_address", MONERO_ADDR).unwrap();
params.insert("seller", SELLER); params.insert("seller", SELLER).unwrap();
let response: Result<HashMap<String, String>, _> = client.request("buy_xmr", params).await; let response: Result<HashMap<String, String>, jsonrpsee_core::Error> = client.request("buy_xmr", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when bitcoin_change_address is missing"), _ => panic!("Expected an error when bitcoin_change_address is missing"),
} }
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("bitcoin_change_address", "invalid_address"); params.insert("bitcoin_change_address", "invalid_address").unwrap();
params.insert("monero_receive_address", MONERO_ADDR); params.insert("monero_receive_address", MONERO_ADDR).unwrap();
params.insert("seller", SELLER); params.insert("seller", SELLER).unwrap();
let response: Result<HashMap<String, String>, _> = client.request("buy_xmr", params).await; let response: Result<HashMap<String, String>, jsonrpsee_core::Error> = client.request("buy_xmr", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when bitcoin_change_address is malformed"), _ => panic!("Expected an error when bitcoin_change_address is malformed"),
} }
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("bitcoin_change_address", BITCOIN_ADDR); params.insert("bitcoin_change_address", BITCOIN_ADDR).unwrap();
params.insert("monero_receive_address", "invalid_address"); params.insert("monero_receive_address", "invalid_address").unwrap();
params.insert("seller", SELLER); params.insert("seller", SELLER).unwrap();
let response: Result<HashMap<String, String>, _> = client.request("buy_xmr", params).await; let response: Result<HashMap<String, String>, jsonrpsee_core::Error> = client.request("buy_xmr", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when monero_receive_address is malformed"), _ => panic!("Expected an error when monero_receive_address is malformed"),
} }
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("bitcoin_change_address", BITCOIN_ADDR); params.insert("bitcoin_change_address", BITCOIN_ADDR).unwrap();
params.insert("monero_receive_address", MONERO_ADDR); params.insert("monero_receive_address", MONERO_ADDR).unwrap();
params.insert("seller", "invalid_seller"); params.insert("seller", "invalid_seller").unwrap();
let response: Result<HashMap<String, String>, _> = client.request("buy_xmr", params).await; let response: Result<HashMap<String, String>, jsonrpsee_core::Error> = client.request("buy_xmr", params).await;
match response { match response {
Err(e) => (), Err(_) => (),
_ => panic!("Expected an error when seller is malformed"), _ => panic!("Expected an error when seller is malformed"),
} }
let mut params = ObjectParams::new(); let mut params = ObjectParams::new();
params.insert("bitcoin_change_address", BITCOIN_ADDR); params.insert("bitcoin_change_address", BITCOIN_ADDR).unwrap();
params.insert("monero_receive_address", MONERO_ADDR); params.insert("monero_receive_address", MONERO_ADDR).unwrap();
params.insert("seller", SELLER); params.insert("seller", SELLER).unwrap();
let response: Result<HashMap<String, String>, _> = client.request("buy_xmr", params).await; let response: Result<HashMap<String, String>, jsonrpsee_core::Error> = client.request("buy_xmr", params).await;
match response { match response {
Ok(hash) => (), Ok(_) => (),
Err(e) => panic!("Expected a HashMap, got an error: {}", e), Err(e) => panic!("Expected a HashMap, got an error: {}", e),
} }