Refactor Alice restart test by introducing factory for creating Alices

The factory keeps all static state of Alice to be able to simulate a restart.

swap/tests/happy_path.rs

@@ -11,12 +11,13 @@ pub mod testutils;
 
 #[tokio::test]
 async fn happy_path() {
-    testutils::test(|alice, bob, swap_amounts| async move {
+    testutils::test(|alice_factory, bob, swap_amounts| async move {
+        let alice = alice_factory.new_alice().await;
         let alice_swap_fut = alice::swap(
             alice.state,
             alice.event_loop_handle,
-            alice.bitcoin_wallet.clone(),
+            alice.btc_wallet.clone(),
-            alice.monero_wallet.clone(),
+            alice.xmr_wallet.clone(),
             alice.config,
             alice.swap_id,
             alice.db,
@@ -32,10 +33,10 @@ async fn happy_path() {
         );
         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_alice_final = alice.btc_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();
+        let xmr_alice_final = alice.xmr_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();

swap/tests/happy_path_restart_alice.rs

@@ -1,166 +1,78 @@
-use crate::testutils::{init_alice, init_bob};
-use get_port::get_port;
-use libp2p::Multiaddr;
 use rand::rngs::OsRng;
 use swap::{
     bitcoin,
-    config::Config,
+    protocol::{alice, alice::AliceState, bob, bob::BobState},
-    database::Database,
-    monero,
-    protocol::{alice, alice::AliceState, bob},
-    seed::Seed,
 };
-use tempfile::tempdir;
-use testcontainers::clients::Cli;
-use testutils::init_tracing;
-use uuid::Uuid;
 
 pub mod testutils;
 
 #[tokio::test]
 async fn given_alice_restarts_after_encsig_is_learned_resume_swap() {
-    let _guard = init_tracing();
+    testutils::test(|alice_factory, bob, swap_amounts| async move {
+        let alice = alice_factory.new_alice().await;
 
-    let cli = Cli::default();
+        let bob_swap_fut = bob::swap(
-    let (
+            bob.state,
-        monero,
+            bob.event_loop_handle,
-        testutils::Containers {
+            bob.db,
-            bitcoind,
+            bob.bitcoin_wallet.clone(),
-            monerods: _monerods,
+            bob.monero_wallet.clone(),
-        },
+            OsRng,
-    ) = testutils::init_containers(&cli).await;
+            bob.swap_id,
+        );
+        let bob_swap_handle = tokio::spawn(bob_swap_fut);
 
-    let btc_to_swap = bitcoin::Amount::from_sat(1_000_000);
+        let alice_state = alice::run_until(
-    let xmr_to_swap = monero::Amount::from_piconero(1_000_000_000_000);
+            alice.state,
-
+            alice::swap::is_encsig_learned,
-    let bob_btc_starting_balance = btc_to_swap * 10;
+            alice.event_loop_handle,
-    let alice_xmr_starting_balance = xmr_to_swap * 10;
+            alice.btc_wallet.clone(),
-
+            alice.xmr_wallet.clone(),
-    let port = get_port().expect("Failed to find a free port");
+            alice.config,
-    let alice_multiaddr: Multiaddr = format!("/ip4/127.0.0.1/tcp/{}", port)
+            alice.swap_id,
-        .parse()
+            alice.db,
-        .expect("failed to parse Alice's address");
-
-    let config = Config::regtest();
-
-    let alice_seed = Seed::random().unwrap();
-    let (
-        start_state,
-        mut alice_event_loop,
-        alice_event_loop_handle,
-        alice_btc_wallet,
-        alice_xmr_wallet,
-        _,
-    ) = init_alice(
-        &bitcoind,
-        &monero,
-        btc_to_swap,
-        xmr_to_swap,
-        alice_xmr_starting_balance,
-        alice_multiaddr.clone(),
-        config,
-        alice_seed,
-    )
-    .await;
-
-    let alice_peer_id = alice_event_loop.peer_id();
-
-    let (bob_state, bob_event_loop, bob_event_loop_handle, bob_btc_wallet, bob_xmr_wallet, bob_db) =
-        init_bob(
-            alice_multiaddr.clone(),
-            alice_peer_id.clone(),
-            &bitcoind,
-            &monero,
-            btc_to_swap,
-            bob_btc_starting_balance,
-            xmr_to_swap,
-            config,
         )
-        .await;
+        .await
+        .unwrap();
+        assert!(matches!(alice_state, AliceState::EncSigLearned {..}));
 
-    // TODO: we are making a clone of Bob's wallets here to keep them in scope after
+        let alice = alice_factory.recover_alice_from_db().await;
-    // Bob's wallets are moved into an async task.
+        assert!(matches!(alice.state, AliceState::EncSigLearned {..}));
-    let bob_btc_wallet_clone = bob_btc_wallet.clone();
-    let bob_xmr_wallet_clone = bob_xmr_wallet.clone();
 
-    let bob_fut = bob::swap::swap(
+        let alice_state = alice::swap(
-        bob_state,
+            alice.state,
-        bob_event_loop_handle,
+            alice.event_loop_handle,
-        bob_db,
+            alice.btc_wallet.clone(),
-        bob_btc_wallet.clone(),
+            alice.xmr_wallet.clone(),
-        bob_xmr_wallet.clone(),
+            alice.config,
-        OsRng,
+            alice.swap_id,
-        Uuid::new_v4(),
+            alice.db,
-    );
+        )
+        .await
+        .unwrap();
 
-    let alice_db_datadir = tempdir().unwrap();
+        let bob_state = bob_swap_handle.await.unwrap();
-    let alice_db = Database::open(alice_db_datadir.path()).unwrap();
 
-    tokio::spawn(async move { alice_event_loop.run().await });
+        let btc_alice_final = alice.btc_wallet.as_ref().balance().await.unwrap();
-    let bob_swap_handle = tokio::spawn(bob_fut);
+        let btc_bob_final = bob.bitcoin_wallet.as_ref().balance().await.unwrap();
-    tokio::spawn(bob_event_loop.run());
 
-    let alice_swap_id = Uuid::new_v4();
+        let xmr_alice_final = alice.xmr_wallet.as_ref().get_balance().await.unwrap();
 
-    let alice_state = alice::swap::run_until(
+        bob.monero_wallet.as_ref().inner.refresh().await.unwrap();
-        start_state,
+        let xmr_bob_final = bob.monero_wallet.as_ref().get_balance().await.unwrap();
-        alice::swap::is_encsig_learned,
-        alice_event_loop_handle,
-        alice_btc_wallet.clone(),
-        alice_xmr_wallet.clone(),
-        config,
-        alice_swap_id,
-        alice_db,
-    )
-    .await
-    .unwrap();
 
-    assert!(matches!(alice_state, AliceState::EncSigLearned {..}));
+        assert!(matches!(alice_state, AliceState::BtcRedeemed));
+        assert!(matches!(bob_state.unwrap(), BobState::XmrRedeemed));
 
-    let alice_db = Database::open(alice_db_datadir.path()).unwrap();
+        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);
 
-    let resume_state =
+        assert!(xmr_alice_final <= alice.xmr_starting_balance - swap_amounts.xmr);
-        if let swap::database::Swap::Alice(state) = alice_db.get_state(alice_swap_id).unwrap() {
+        assert_eq!(xmr_bob_final, bob.xmr_starting_balance + swap_amounts.xmr);
-            assert!(matches!(state, swap::database::Alice::EncSigLearned {..}));
+    })
-            state.into()
+    .await;
-        } else {
-            unreachable!()
-        };
-
-    let (mut event_loop_after_restart, event_loop_handle_after_restart) =
-        testutils::init_alice_event_loop(alice_multiaddr, alice_seed);
-    tokio::spawn(async move { event_loop_after_restart.run().await });
-
-    let alice_state = alice::swap::swap(
-        resume_state,
-        event_loop_handle_after_restart,
-        alice_btc_wallet.clone(),
-        alice_xmr_wallet.clone(),
-        config,
-        alice_swap_id,
-        alice_db,
-    )
-    .await
-    .unwrap();
-
-    // Wait for Bob to finish
-    bob_swap_handle.await.unwrap().unwrap();
-
-    assert!(matches!(alice_state, AliceState::BtcRedeemed {..}));
-
-    let btc_alice_final = alice_btc_wallet.as_ref().balance().await.unwrap();
-    let btc_bob_final = bob_btc_wallet_clone.as_ref().balance().await.unwrap();
-
-    assert_eq!(
-        btc_alice_final,
-        btc_to_swap - bitcoin::Amount::from_sat(bitcoin::TX_FEE)
-    );
-    assert!(btc_bob_final <= bob_btc_starting_balance - btc_to_swap);
-
-    let xmr_alice_final = alice_xmr_wallet.as_ref().get_balance().await.unwrap();
-    bob_xmr_wallet_clone.as_ref().inner.refresh().await.unwrap();
-    let xmr_bob_final = bob_xmr_wallet_clone.as_ref().get_balance().await.unwrap();
-
-    assert!(xmr_alice_final <= alice_xmr_starting_balance - xmr_to_swap);
-    assert_eq!(xmr_bob_final, xmr_to_swap);
 }

swap/tests/testutils/mod.rs

@@ -5,7 +5,7 @@ use get_port::get_port;
 use libp2p::{core::Multiaddr, PeerId};
 use monero_harness::{image, Monero};
 use rand::rngs::OsRng;
-use std::sync::Arc;
+use std::{path::PathBuf, sync::Arc};
 use swap::{
     bitcoin,
     config::Config,
@@ -23,15 +23,19 @@ 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 btc_wallet: Arc<bitcoin::Wallet>,
-    pub monero_wallet: Arc<monero::Wallet>,
+    pub xmr_wallet: Arc<monero::Wallet>,
     pub config: Config,
-    pub swap_id: Uuid,
     pub db: Database,
+
+    pub state: AliceState,
+
     pub xmr_starting_balance: monero::Amount,
     pub btc_starting_balance: bitcoin::Amount,
+
+    // test context (state we have to keep to simulate restart)
+    pub swap_id: Uuid,
 }
 
 pub struct Bob {
@@ -45,9 +49,149 @@ pub struct Bob {
     pub xmr_starting_balance: monero::Amount,
 }
 
+pub struct AliceFactory {
+    listen_address: Multiaddr,
+    peer_id: PeerId,
+
+    seed: Seed,
+    db_path: PathBuf,
+    swap_id: Uuid,
+
+    // Stuff that should probably not be in here...
+    swap_amounts: SwapAmounts,
+    btc_wallet: Arc<bitcoin::Wallet>,
+    xmr_wallet: Arc<monero::Wallet>,
+    config: Config,
+    xmr_starting_balance: monero::Amount,
+    btc_starting_balance: bitcoin::Amount,
+}
+
+impl AliceFactory {
+    pub fn peer_id(&self) -> PeerId {
+        self.peer_id.clone()
+    }
+
+    pub fn listen_address(&self) -> Multiaddr {
+        self.listen_address.clone()
+    }
+
+    pub async fn new(
+        config: Config,
+        swap_amounts: SwapAmounts,
+        swap_id: Uuid,
+        monero: &Monero,
+        bitcoind: &Bitcoind<'_>,
+        xmr_starting_balance: monero::Amount,
+        btc_starting_balance: bitcoin::Amount,
+    ) -> Self {
+        let port = get_port().expect("Failed to find a free port");
+
+        let listen_address: Multiaddr = format!("/ip4/127.0.0.1/tcp/{}", port)
+            .parse()
+            .expect("failed to parse Alice's address");
+
+        let seed = Seed::random().unwrap();
+
+        let db_path = tempdir().unwrap().path().to_path_buf();
+
+        let alice_xmr_starting_balance = swap_amounts.xmr * 10;
+        let (btc_wallet, xmr_wallet) = init_wallets(
+            "alice",
+            bitcoind,
+            monero,
+            None,
+            Some(alice_xmr_starting_balance),
+            config,
+        )
+        .await;
+
+        // TODO: This should be done by changing the production code
+        let network_seed = network::Seed::new(seed);
+        let identity = network_seed.derive_libp2p_identity();
+        let peer_id = PeerId::from(identity.public());
+
+        Self {
+            seed,
+            db_path,
+            listen_address,
+            peer_id,
+            swap_id,
+            swap_amounts,
+            btc_wallet,
+            xmr_wallet,
+            config,
+            xmr_starting_balance,
+            btc_starting_balance,
+        }
+    }
+
+    pub async fn new_alice(&self) -> Alice {
+        let initial_state = init_alice_state(
+            self.swap_amounts.btc,
+            self.swap_amounts.xmr,
+            self.btc_wallet.clone(),
+            self.config,
+        )
+        .await;
+
+        let (mut event_loop, event_loop_handle) =
+            init_alice_event_loop(self.listen_address.clone(), self.seed);
+
+        tokio::spawn(async move { event_loop.run().await });
+
+        let db = Database::open(self.db_path.as_path()).unwrap();
+
+        Alice {
+            event_loop_handle,
+            btc_wallet: self.btc_wallet.clone(),
+            xmr_wallet: self.xmr_wallet.clone(),
+            config: self.config,
+            db,
+            state: initial_state,
+            xmr_starting_balance: self.xmr_starting_balance,
+            btc_starting_balance: self.btc_starting_balance,
+            swap_id: self.swap_id,
+        }
+    }
+
+    pub async fn recover_alice_from_db(&self) -> Alice {
+        // TODO: "simulated restart" issues:
+        //  - create new wallets instead of reusing (hard because of container
+        //    lifetimes)
+        //  - consider aborting the old event loop (currently just keeps running)
+
+        // reopen the existing database
+        let db = Database::open(self.db_path.clone().as_path()).unwrap();
+
+        let resume_state =
+            if let swap::database::Swap::Alice(state) = db.get_state(self.swap_id).unwrap() {
+                state.into()
+            } else {
+                unreachable!()
+            };
+
+        let (mut event_loop, event_loop_handle) =
+            init_alice_event_loop(self.listen_address.clone(), self.seed);
+
+        tokio::spawn(async move { event_loop.run().await });
+
+        Alice {
+            state: resume_state,
+            event_loop_handle,
+            btc_wallet: self.btc_wallet.clone(),
+            xmr_wallet: self.xmr_wallet.clone(),
+            config: self.config,
+            swap_id: self.swap_id,
+            db,
+            xmr_starting_balance: self.xmr_starting_balance,
+            btc_starting_balance: self.btc_starting_balance,
+        }
+    }
+}
+
 pub async fn test<T, F>(testfn: T)
 where
-    T: Fn(Alice, Bob, SwapAmounts) -> F,
+    T: Fn(AliceFactory, Bob, SwapAmounts) -> F,
     F: Future<Output = ()>,
 {
     let cli = Cli::default();
@@ -61,42 +205,20 @@ where
         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_factory = AliceFactory::new(
-
+        config,
-    let (alice_btc_wallet, alice_xmr_wallet) = init_wallets(
+        swap_amounts,
-        "alice",
+        Uuid::new_v4(),
-        &containers.bitcoind,
         &monero,
-        None,
+        &containers.bitcoind,
-        Some(alice_xmr_starting_balance),
+        swap_amounts.xmr * 10,
-        config,
+        bitcoin::Amount::ZERO,
     )
     .await;
 
-    let alice_state = init_alice_state(
+    let bob_btc_starting_balance = swap_amounts.btc * 10;
-        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",
@@ -117,26 +239,13 @@ where
     .await;
 
     let (bob_event_loop, bob_event_loop_handle) =
-        init_bob_event_loop(alice_event_loop.peer_id(), alice_multiaddr);
+        init_bob_event_loop(alice_factory.peer_id(), alice_factory.listen_address());
 
     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,
@@ -148,7 +257,7 @@ where
         btc_starting_balance: bob_btc_starting_balance,
     };
 
-    testfn(alice, bob, swap_amounts).await
+    testfn(alice_factory, bob, swap_amounts).await
 }
 
 pub async fn init_containers(cli: &Cli) -> (Monero, Containers<'_>) {