wowario
/
wow-btc-swap
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add reusable test function

Browse Source 
We introduce a reusable test function to make it easier to add new tests and make our existing tests more readable.
pull/144/head
rishflab 3 years ago
parent 9cbf6e9774
commit 537d05e01e
2 changed files with 177 additions and 117 deletions
Show Stats Download Patch File Download Diff File

161
swap/tests/happy_path.rs
Unescape View File

@ -1,21 +1,9 @@
use crate::testutils::{init_alice, init_bob};
use futures::{
future::{join, select},
FutureExt,
};
use get_port::get_port;
use libp2p::Multiaddr;
use rand::rngs::OsRng;
use swap::{
bitcoin,
config::Config,
monero,
protocol::{alice, bob},
seed::Seed,
protocol::{alice, alice::AliceState, bob, bob::BobState},
};
use testcontainers::clients::Cli;
use testutils::init_tracing;
use uuid::Uuid;
use tokio::join;
pub mod testutils;
@ -23,108 +11,47 @@ pub mod testutils;
#[tokio::test]
async fn happy_path() {
let _guard = init_tracing();
let cli = Cli::default();
let (
monero,
testutils::Containers {
bitcoind,
monerods: _monerods,
},
) = testutils::init_containers(&cli).await;
let btc_to_swap = bitcoin::Amount::from_sat(1_000_000);
let btc_alice = bitcoin::Amount::ZERO;
let btc_bob = btc_to_swap * 10;
// this xmr value matches the logic of alice::calculate_amounts i.e. btc *
// 10_000 * 100
let xmr_to_swap = monero::Amount::from_piconero(1_000_000_000_000);
let xmr_alice = xmr_to_swap * 10;
let xmr_bob = monero::Amount::ZERO;
let port = get_port().expect("Failed to find a free port");
let alice_multiaddr: Multiaddr = format!("/ip4/127.0.0.1/tcp/{}", port)
.parse()
.expect("failed to parse Alice's address");
let config = Config::regtest();
let (
alice_state,
mut alice_event_loop,
alice_event_loop_handle,
alice_btc_wallet,
alice_xmr_wallet,
alice_db,
) = init_alice(
&bitcoind,
&monero,
btc_to_swap,
xmr_to_swap,
xmr_alice,
alice_multiaddr.clone(),
config,
Seed::random().unwrap(),
)
testutils::test(|alice, bob, swap_amounts| async move {
let alice_swap_fut = alice::swap(
alice.state,
alice.event_loop_handle,
alice.bitcoin_wallet.clone(),
alice.monero_wallet.clone(),
alice.config,
alice.swap_id,
alice.db,
);
let bob_swap_fut = bob::swap(
bob.state,
bob.event_loop_handle,
bob.db,
bob.bitcoin_wallet.clone(),
bob.monero_wallet.clone(),
OsRng,
bob.swap_id,
);
let (alice_state, bob_state) = join!(alice_swap_fut, bob_swap_fut);
let btc_alice_final = alice.bitcoin_wallet.as_ref().balance().await.unwrap();
let btc_bob_final = bob.bitcoin_wallet.as_ref().balance().await.unwrap();
let xmr_alice_final = alice.monero_wallet.as_ref().get_balance().await.unwrap();
bob.monero_wallet.as_ref().inner.refresh().await.unwrap();
let xmr_bob_final = bob.monero_wallet.as_ref().get_balance().await.unwrap();
assert!(matches!(alice_state.unwrap(), AliceState::BtcRedeemed));
assert!(matches!(bob_state.unwrap(), BobState::XmrRedeemed));
assert_eq!(
btc_alice_final,
alice.btc_starting_balance + swap_amounts.btc
- bitcoin::Amount::from_sat(bitcoin::TX_FEE)
);
assert!(btc_bob_final <= bob.btc_starting_balance - swap_amounts.btc);
assert!(xmr_alice_final <= alice.xmr_starting_balance - swap_amounts.xmr);
assert_eq!(xmr_bob_final, bob.xmr_starting_balance + swap_amounts.xmr);
})
.await;
let (bob_state, bob_event_loop, bob_event_loop_handle, bob_btc_wallet, bob_xmr_wallet, bob_db) =
init_bob(
alice_multiaddr.clone(),
alice_event_loop.peer_id(),
&bitcoind,
&monero,
btc_to_swap,
btc_bob,
xmr_to_swap,
config,
)
.await;
let alice_swap_fut = alice::swap::swap(
alice_state,
alice_event_loop_handle,
alice_btc_wallet.clone(),
alice_xmr_wallet.clone(),
config,
Uuid::new_v4(),
alice_db,
)
.boxed();
let alice_fut = select(alice_swap_fut, alice_event_loop.run().boxed());
let bob_swap_fut = bob::swap::swap(
bob_state,
bob_event_loop_handle,
bob_db,
bob_btc_wallet.clone(),
bob_xmr_wallet.clone(),
OsRng,
Uuid::new_v4(),
)
.boxed();
let bob_fut = select(bob_swap_fut, bob_event_loop.run().boxed());
join(alice_fut, bob_fut).await;
let btc_alice_final = alice_btc_wallet.as_ref().balance().await.unwrap();
let btc_bob_final = bob_btc_wallet.as_ref().balance().await.unwrap();
let xmr_alice_final = alice_xmr_wallet.as_ref().get_balance().await.unwrap();
bob_xmr_wallet.as_ref().inner.refresh().await.unwrap();
let xmr_bob_final = bob_xmr_wallet.as_ref().get_balance().await.unwrap();
assert_eq!(
btc_alice_final,
btc_alice + btc_to_swap - bitcoin::Amount::from_sat(bitcoin::TX_FEE)
);
assert!(btc_bob_final <= btc_bob - btc_to_swap);
assert!(xmr_alice_final <= xmr_alice - xmr_to_swap);
assert_eq!(xmr_bob_final, xmr_bob + xmr_to_swap);
}

133
swap/tests/testutils/mod.rs
Unescape View File

@ -1,4 +1,7 @@
use crate::testutils;
use bitcoin_harness::Bitcoind;
use futures::Future;
use get_port::get_port;
use libp2p::{core::Multiaddr, PeerId};
use monero_harness::{image, Monero};
use rand::rngs::OsRng;
@ -17,6 +20,136 @@ use tempfile::tempdir;
use testcontainers::{clients::Cli, Container};
use tracing_core::dispatcher::DefaultGuard;
use tracing_log::LogTracer;
use uuid::Uuid;
pub struct Alice {
pub state: AliceState,
pub event_loop_handle: alice::EventLoopHandle,
pub bitcoin_wallet: Arc<bitcoin::Wallet>,
pub monero_wallet: Arc<monero::Wallet>,
pub config: Config,
pub swap_id: Uuid,
pub db: Database,
pub xmr_starting_balance: monero::Amount,
pub btc_starting_balance: bitcoin::Amount,
}
pub struct Bob {
pub state: BobState,
pub event_loop_handle: bob::EventLoopHandle,
pub db: Database,
pub bitcoin_wallet: Arc<bitcoin::Wallet>,
pub monero_wallet: Arc<monero::Wallet>,
pub swap_id: Uuid,
pub btc_starting_balance: bitcoin::Amount,
pub xmr_starting_balance: monero::Amount,
}
pub async fn test<T, F>(testfn: T)
where
T: Fn(Alice, Bob, SwapAmounts) -> F,
F: Future<Output = ()>,
{
let cli = Cli::default();
let _guard = init_tracing();
let (monero, containers) = testutils::init_containers(&cli).await;
let swap_amounts = SwapAmounts {
btc: bitcoin::Amount::from_sat(1_000_000),
xmr: monero::Amount::from_piconero(1_000_000_000_000),
};
let bob_btc_starting_balance = swap_amounts.btc * 10;
let alice_xmr_starting_balance = swap_amounts.xmr * 10;
let port = get_port().expect("Failed to find a free port");
let alice_multiaddr: Multiaddr = format!("/ip4/127.0.0.1/tcp/{}", port)
.parse()
.expect("failed to parse Alice's address");
let config = Config::regtest();
let alice_seed = Seed::random().unwrap();
let (alice_btc_wallet, alice_xmr_wallet) = init_wallets(
"alice",
&containers.bitcoind,
&monero,
None,
Some(alice_xmr_starting_balance),
config,
)
.await;
let alice_state = init_alice_state(
swap_amounts.btc,
swap_amounts.xmr,
alice_btc_wallet.clone(),
config,
)
.await;
let (mut alice_event_loop, alice_event_loop_handle) =
init_alice_event_loop(alice_multiaddr.clone(), alice_seed);
let alice_db_datadir = tempdir().unwrap();
let alice_db = Database::open(alice_db_datadir.path()).unwrap();
let (bob_btc_wallet, bob_xmr_wallet) = init_wallets(
"bob",
&containers.bitcoind,
&monero,
Some(bob_btc_starting_balance),
None,
config,
)
.await;
let bob_state = init_bob_state(
swap_amounts.btc,
swap_amounts.xmr,
bob_btc_wallet.clone(),
config,
)
.await;
let (bob_event_loop, bob_event_loop_handle) =
init_bob_event_loop(alice_event_loop.peer_id(), alice_multiaddr);
let bob_db_dir = tempdir().unwrap();
let bob_db = Database::open(bob_db_dir.path()).unwrap();
tokio::spawn(async move { alice_event_loop.run().await });
tokio::spawn(async move { bob_event_loop.run().await });
let alice = Alice {
state: alice_state,
event_loop_handle: alice_event_loop_handle,
bitcoin_wallet: alice_btc_wallet,
monero_wallet: alice_xmr_wallet,
config,
swap_id: Uuid::new_v4(),
db: alice_db,
xmr_starting_balance: alice_xmr_starting_balance,
btc_starting_balance: bitcoin::Amount::ZERO,
};
let bob = Bob {
state: bob_state,
event_loop_handle: bob_event_loop_handle,
db: bob_db,
bitcoin_wallet: bob_btc_wallet,
monero_wallet: bob_xmr_wallet,
swap_id: Uuid::new_v4(),
xmr_starting_balance: monero::Amount::ZERO,
btc_starting_balance: bob_btc_starting_balance,
};
testfn(alice, bob, swap_amounts).await
}
pub async fn init_containers(cli: &Cli) -> (Monero, Containers<'_>) {
let bitcoind = Bitcoind::new(&cli, "0.19.1").unwrap();

Write Preview
Loading…
Cancel
Save