wow-btc-swap/swap/tests/happy_path.rs

pub mod testutils;

use swap::protocol::{alice, bob};
use testutils::SlowCancelConfig;
use tokio::join;

/// Run the following tests with RUST_MIN_STACK=10000000

#[tokio::test]
async fn happy_path() {
    testutils::setup_test(SlowCancelConfig, |mut ctx| async move {
        let (bob_swap, _) = ctx.bob_swap().await;
        let bob_swap = tokio::spawn(bob::run(bob_swap));

        let alice_swap = ctx.alice_next_swap().await;
        let alice_swap = tokio::spawn(alice::run(alice_swap));

        let (bob_state, alice_state) = join!(bob_swap, alice_swap);

        ctx.assert_alice_redeemed(alice_state??).await;
        ctx.assert_bob_redeemed(bob_state??).await;

        Ok(())
    })
    .await;
}
Top to bottom `pub mod` then `mod` then `pub use` then `use` (incl. `use crate` and `use self`) 3 years ago			`pub mod testutils;`

Alice spawns swaps outside the event loop Instead of spawning the swap inside the event loop we send the swap back to the caller to be spawned. This means we no longer need the remote handle that was only used in the tests. This now properly logs the swap results in production. It also gives us more control over Alice's swap in the tests. 3 years ago			`use swap::protocol::{alice, bob};`
Change expiries depending on the test goal 3 years ago			`use testutils::SlowCancelConfig;`
Alice spawns swaps outside the event loop Instead of spawning the swap inside the event loop we send the swap back to the caller to be spawned. This means we no longer need the remote handle that was only used in the tests. This now properly logs the swap results in production. It also gives us more control over Alice's swap in the tests. 3 years ago			`use tokio::join;`
Add recovery function for Alice 4 years ago
			`/// Run the following tests with RUST_MIN_STACK=10000000`

			`#[tokio::test]`
			`async fn happy_path() {`
Use trait instead of passing struct 3 years ago			`testutils::setup_test(SlowCancelConfig, \|mut ctx\| async move {`
Alice spawns swaps outside the event loop Instead of spawning the swap inside the event loop we send the swap back to the caller to be spawned. This means we no longer need the remote handle that was only used in the tests. This now properly logs the swap results in production. It also gives us more control over Alice's swap in the tests. 3 years ago			`let (bob_swap, _) = ctx.bob_swap().await;`
			`let bob_swap = tokio::spawn(bob::run(bob_swap));`
Harmonize names and structure Simple renames and structure changes, no logical changes. 3 years ago
Alice spawns swaps outside the event loop Instead of spawning the swap inside the event loop we send the swap back to the caller to be spawned. This means we no longer need the remote handle that was only used in the tests. This now properly logs the swap results in production. It also gives us more control over Alice's swap in the tests. 3 years ago			`let alice_swap = ctx.alice_next_swap().await;`
			`let alice_swap = tokio::spawn(alice::run(alice_swap));`
Restart event loop in tests Alice was attempting to create a new event loop using the same listen addr as the old one which was still running. This commit aborts the event loop before creating a new one. 3 years ago
Alice spawns swaps outside the event loop Instead of spawning the swap inside the event loop we send the swap back to the caller to be spawned. This means we no longer need the remote handle that was only used in the tests. This now properly logs the swap results in production. It also gives us more control over Alice's swap in the tests. 3 years ago			`let (bob_state, alice_state) = join!(bob_swap, alice_swap);`

			`ctx.assert_alice_redeemed(alice_state??).await;`
			`ctx.assert_bob_redeemed(bob_state??).await;`

			`Ok(())`
Add reusable test function We introduce a reusable test function to make it easier to add new tests and make our existing tests more readable. 3 years ago			`})`
Add recovery function for Alice 4 years ago			`.await;`
			`}`