Update existing tests

Author: buffrr

Cargo.lock

@@ -1,4 +1,4 @@
 [workspace]
 
 resolver = "2"
-members = [ "node", "protocol", "wallet"]
+members = [ "node", "protocol", "testutil", "wallet"]

Cargo.toml

@@ -39,5 +39,5 @@ threadpool = "1.8.1"
 
 [dev-dependencies]
 assert_cmd = "2.0.16"
-bitcoind = { version = "0.36.0", features = ["26_0"] }
 predicates = "3.1.2"
+testutil = { path = "../testutil" }

node/Cargo.toml

@@ -1,71 +1,60 @@
-pub mod utils;
+use std::{
+    sync::mpsc::TryRecvError,
+    time::{Duration, Instant},
+};
 
-#[cfg(test)]
-mod tests {
-    use std::{
-        sync::mpsc::TryRecvError,
-        time::{Duration, Instant},
-    };
+use anyhow::Result;
+use protocol::{bitcoin::BlockHash, constants::ChainAnchor};
+use reqwest::blocking::Client;
+use spaced::source::{BitcoinRpc, BitcoinRpcAuth, BlockEvent, BlockFetcher};
+use testutil::TestRig;
 
-    use crate::utils::SpaceD;
-    use anyhow::Result;
-    use bitcoind::bitcoincore_rpc::RpcApi;
-    use protocol::constants::ChainAnchor;
-    use reqwest::blocking::Client;
-    use spaced::source::{BitcoinRpc, BitcoinRpcAuth, BlockEvent, BlockFetcher};
-    use wallet::bitcoin::Network;
+async fn setup(blocks: u64) -> Result<(TestRig, u64, BlockHash)> {
+    let rig = TestRig::new().await?;
+    rig.mine_blocks(blocks as _, None).await?;
+    let height = 0;
+    let hash = rig.get_block_hash(height).await?;
+    Ok((rig, height, hash))
+}
 
-    #[test]
-    fn test_block_fetching_from_bitcoin_rpc() -> Result<()> {
-        let spaced = SpaceD::new()?;
-        let fetcher_rpc = BitcoinRpc::new(
-            &spaced.bitcoind.rpc_url(),
-            BitcoinRpcAuth::UserPass("user".to_string(), "password".to_string()),
-        );
-        let miner_addr = spaced
-            .bitcoind
-            .client
-            .get_new_address(None, None)?
-            .require_network(Network::Regtest)?;
-        const GENERATED_BLOCKS: u32 = 10;
-        spaced
-            .bitcoind
-            .client
-            .generate_to_address(GENERATED_BLOCKS as u64, &miner_addr)?;
+#[test]
+fn test_block_fetching_from_bitcoin_rpc() -> Result<()> {
+    const GENERATED_BLOCKS: u64 = 10;
 
-        let client = Client::new();
-        let (fetcher, receiver) = BlockFetcher::new(fetcher_rpc.clone(), client.clone(), 8);
-        fetcher.start(ChainAnchor {
-            hash: fetcher_rpc.send_json_blocking(&client, &fetcher_rpc.get_block_hash(0))?,
-            height: 0,
-        });
+    let (rig, mut height, hash) = tokio::runtime::Runtime::new()?
+        .block_on(setup(GENERATED_BLOCKS))?;
+    let fetcher_rpc = BitcoinRpc::new(
+        &rig.bitcoind.rpc_url(),
+        BitcoinRpcAuth::UserPass("user".to_string(), "password".to_string()),
+    );
 
-        let mut start_block = 0;
-        let timeout = Duration::from_secs(5);
-        let start_time = Instant::now();
+    let client = Client::new();
+    let (fetcher, receiver) = BlockFetcher::new(fetcher_rpc.clone(), client.clone(), 8);
 
-        loop {
-            if start_time.elapsed() > timeout {
-                panic!("Test timed out after {:?}", timeout);
-            }
-            match receiver.try_recv() {
-                Ok(BlockEvent::Block(id, _)) => {
-                    start_block += 1;
-                    if id.height == GENERATED_BLOCKS {
-                        break;
-                    }
-                }
-                Ok(BlockEvent::Error(e)) => panic!("Unexpected error: {}", e),
-                Err(TryRecvError::Empty) => {
-                    std::thread::sleep(Duration::from_millis(10));
+    fetcher.start(ChainAnchor { hash, height: 0 });
+
+    let timeout = Duration::from_secs(5);
+    let start_time = Instant::now();
+
+    loop {
+        if start_time.elapsed() > timeout {
+            panic!("Test timed out after {:?}", timeout);
+        }
+        match receiver.try_recv() {
+            Ok(BlockEvent::Block(id, _)) => {
+                height += 1;
+                if id.height == GENERATED_BLOCKS as u32 {
+                    break;
                 }
-                Err(TryRecvError::Disconnected) => panic!("Disconnected unexpectedly"),
             }
+            Ok(BlockEvent::Error(e)) => panic!("Unexpected error: {}", e),
+            Err(TryRecvError::Empty) => {
+                std::thread::sleep(Duration::from_millis(10));
+            }
+            Err(TryRecvError::Disconnected) => panic!("Disconnected unexpectedly"),
         }
-        assert_eq!(
-            start_block, GENERATED_BLOCKS,
-            "Not all blocks were received"
-        );
-        Ok(())
     }
+
+    assert_eq!(height, GENERATED_BLOCKS, "Not all blocks were received");
+    Ok(())
 }

node/tests/fetcher_tests.rs

@@ -1,34 +1,29 @@
-pub mod utils;
+use std::process::Command;
 
-#[cfg(test)]
-mod tests {
-    use crate::utils::SpaceD;
-    use anyhow::Result;
-    use assert_cmd::prelude::*;
-    use predicates::prelude::*;
-    use serde_json::from_str;
-    use spaced::config::ExtendedNetwork;
-    use spaced::rpc::ServerInfo;
-    use std::process::Command;
+use anyhow::Result;
+use assert_cmd::prelude::*;
+use predicates::prelude::*;
+use serde_json::from_str;
+use spaced::{config::ExtendedNetwork, rpc::ServerInfo};
+use testutil::TestRig;
 
-    #[tokio::test]
-    async fn test_get_server_info() -> Result<()> {
-        env_logger::init();
-        let spaced = SpaceD::new()?;
+#[tokio::test]
+async fn test_get_server_info() -> Result<()> {
+    env_logger::init();
+    let rig = TestRig::new().await?;
 
-        Command::cargo_bin("space-cli")?
-            .arg("--chain")
-            .arg("regtest")
-            .arg("--spaced-rpc-url")
-            .arg(spaced.spaced_rpc_url())
-            .arg("getserverinfo")
-            .assert()
-            .success()
-            .stdout(predicate::function(|x: &str| {
-                let info: ServerInfo = from_str(x).unwrap();
-                return info.chain == ExtendedNetwork::Regtest;
-            }));
+    Command::cargo_bin("space-cli")?
+        .arg("--chain")
+        .arg("regtest")
+        .arg("--spaced-rpc-url")
+        .arg(rig.spaced.rpc_url())
+        .arg("getserverinfo")
+        .assert()
+        .success()
+        .stdout(predicate::function(|x: &str| {
+            let info: ServerInfo = from_str(x).unwrap();
+            return info.chain == ExtendedNetwork::Regtest;
+        }));
 
-        Ok(())
-    }
+    Ok(())
 }