chore(esplora): updated esplora tests to use TestEnv

Updated the test cases in the `esplora` crate to use the `TestEnv`
crate.

Author: LagginTimes

crates/bitcoind_rpc/tests/test_emitter.rs

@@ -88,7 +88,7 @@ pub fn test_sync_local_chain() -> anyhow::Result<()> {
     );
 
     // perform reorg
-    let reorged_blocks = env.reorg(6)?;
+    let reorged_blocks = env.reorg(6, &env.bitcoind)?;
     let exp_hashes = exp_hashes
         .iter()
         .take(exp_hashes.len() - reorged_blocks.len())

crates/esplora/Cargo.toml

@@ -21,6 +21,9 @@ futures = { version = "0.3.26", optional = true }
 bitcoin = { version = "0.30.0", optional = true, default-features = false }
 miniscript = { version = "10.0.0", optional = true, default-features = false }
 
+[dev-dependencies]
+testenv = { path = "../testenv", version = "0.1.0", default_features = false }
+
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 electrsd = { version= "0.25.0", features = ["bitcoind_25_0", "esplora_a33e97e1", "legacy"] }
 tokio = { version = "1", features = ["rt", "rt-multi-thread", "macros"] }

crates/esplora/tests/async_ext.rs

@@ -1,67 +1,20 @@
 use bdk_esplora::EsploraAsyncExt;
+use electrsd::bitcoind::anyhow;
 use electrsd::bitcoind::bitcoincore_rpc::RpcApi;
-use electrsd::bitcoind::{self, anyhow, BitcoinD};
-use electrsd::{Conf, ElectrsD};
-use esplora_client::{self, AsyncClient, Builder};
+use esplora_client::{self, Builder};
 use std::str::FromStr;
 use std::thread::sleep;
 use std::time::Duration;
 
-use bdk_chain::bitcoin::{Address, Amount, BlockHash, Txid};
-
-struct TestEnv {
-    bitcoind: BitcoinD,
-    #[allow(dead_code)]
-    electrsd: ElectrsD,
-    client: AsyncClient,
-}
-
-impl TestEnv {
-    fn new() -> Result<Self, anyhow::Error> {
-        let bitcoind_exe =
-            bitcoind::downloaded_exe_path().expect("bitcoind version feature must be enabled");
-        let bitcoind = BitcoinD::new(bitcoind_exe).unwrap();
-
-        let mut electrs_conf = Conf::default();
-        electrs_conf.http_enabled = true;
-        let electrs_exe =
-            electrsd::downloaded_exe_path().expect("electrs version feature must be enabled");
-        let electrsd = ElectrsD::with_conf(electrs_exe, &bitcoind, &electrs_conf)?;
-
-        let base_url = format!("http://{}", &electrsd.esplora_url.clone().unwrap());
-        let client = Builder::new(base_url.as_str()).build_async()?;
-
-        Ok(Self {
-            bitcoind,
-            electrsd,
-            client,
-        })
-    }
-
-    fn mine_blocks(
-        &self,
-        count: usize,
-        address: Option<Address>,
-    ) -> anyhow::Result<Vec<BlockHash>> {
-        let coinbase_address = match address {
-            Some(address) => address,
-            None => self
-                .bitcoind
-                .client
-                .get_new_address(None, None)?
-                .assume_checked(),
-        };
-        let block_hashes = self
-            .bitcoind
-            .client
-            .generate_to_address(count as _, &coinbase_address)?;
-        Ok(block_hashes)
-    }
-}
+use bdk_chain::bitcoin::{Address, Amount, Txid};
+use testenv::TestEnv;
 
 #[tokio::test]
 pub async fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
     let env = TestEnv::new()?;
+    let base_url = format!("http://{}", &env.electrsd.esplora_url.clone().unwrap());
+    let client = Builder::new(base_url.as_str()).build_async()?;
+
     let receive_address0 =
         Address::from_str("bcrt1qc6fweuf4xjvz4x3gx3t9e0fh4hvqyu2qw4wvxm")?.assume_checked();
     let receive_address1 =
@@ -72,7 +25,7 @@ pub async fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
         receive_address1.script_pubkey(),
     ];
 
-    let _block_hashes = env.mine_blocks(101, None)?;
+    let _block_hashes = env.mine_blocks(101, None, &env.bitcoind)?;
     let txid1 = env.bitcoind.client.send_to_address(
         &receive_address1,
         Amount::from_sat(10000),
@@ -93,13 +46,12 @@ pub async fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
         Some(1),
         None,
     )?;
-    let _block_hashes = env.mine_blocks(1, None)?;
-    while env.client.get_height().await.unwrap() < 102 {
+    let _block_hashes = env.mine_blocks(1, None, &env.bitcoind)?;
+    while client.get_height().await.unwrap() < 102 {
         sleep(Duration::from_millis(10))
     }
 
-    let graph_update = env
-        .client
+    let graph_update = client
         .scan_txs(
             misc_spks.into_iter(),
             vec![].into_iter(),

crates/esplora/tests/blocking_ext.rs

@@ -1,67 +1,20 @@
 use bdk_esplora::EsploraExt;
+use electrsd::bitcoind::anyhow;
 use electrsd::bitcoind::bitcoincore_rpc::RpcApi;
-use electrsd::bitcoind::{self, anyhow, BitcoinD};
-use electrsd::{Conf, ElectrsD};
-use esplora_client::{self, BlockingClient, Builder};
+use esplora_client::{self, Builder};
 use std::str::FromStr;
 use std::thread::sleep;
 use std::time::Duration;
 
-use bdk_chain::bitcoin::{Address, Amount, BlockHash, Txid};
-
-struct TestEnv {
-    bitcoind: BitcoinD,
-    #[allow(dead_code)]
-    electrsd: ElectrsD,
-    client: BlockingClient,
-}
-
-impl TestEnv {
-    fn new() -> Result<Self, anyhow::Error> {
-        let bitcoind_exe =
-            bitcoind::downloaded_exe_path().expect("bitcoind version feature must be enabled");
-        let bitcoind = BitcoinD::new(bitcoind_exe).unwrap();
-
-        let mut electrs_conf = Conf::default();
-        electrs_conf.http_enabled = true;
-        let electrs_exe =
-            electrsd::downloaded_exe_path().expect("electrs version feature must be enabled");
-        let electrsd = ElectrsD::with_conf(electrs_exe, &bitcoind, &electrs_conf)?;
-
-        let base_url = format!("http://{}", &electrsd.esplora_url.clone().unwrap());
-        let client = Builder::new(base_url.as_str()).build_blocking()?;
-
-        Ok(Self {
-            bitcoind,
-            electrsd,
-            client,
-        })
-    }
-
-    fn mine_blocks(
-        &self,
-        count: usize,
-        address: Option<Address>,
-    ) -> anyhow::Result<Vec<BlockHash>> {
-        let coinbase_address = match address {
-            Some(address) => address,
-            None => self
-                .bitcoind
-                .client
-                .get_new_address(None, None)?
-                .assume_checked(),
-        };
-        let block_hashes = self
-            .bitcoind
-            .client
-            .generate_to_address(count as _, &coinbase_address)?;
-        Ok(block_hashes)
-    }
-}
+use bdk_chain::bitcoin::{Address, Amount, Txid};
+use testenv::TestEnv;
 
 #[test]
 pub fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
     let env = TestEnv::new()?;
+    let base_url = format!("http://{}", &env.electrsd.esplora_url.clone().unwrap());
+    let client = Builder::new(base_url.as_str()).build_blocking()?;
+
     let receive_address0 =
         Address::from_str("bcrt1qc6fweuf4xjvz4x3gx3t9e0fh4hvqyu2qw4wvxm")?.assume_checked();
     let receive_address1 =
@@ -72,7 +25,7 @@ pub fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
         receive_address1.script_pubkey(),
     ];
 
-    let _block_hashes = env.mine_blocks(101, None)?;
+    let _block_hashes = env.mine_blocks(101, None, &env.bitcoind)?;
     let txid1 = env.bitcoind.client.send_to_address(
         &receive_address1,
         Amount::from_sat(10000),
@@ -93,12 +46,12 @@ pub fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
         Some(1),
         None,
     )?;
-    let _block_hashes = env.mine_blocks(1, None)?;
-    while env.client.get_height().unwrap() < 102 {
+    let _block_hashes = env.mine_blocks(1, None, &env.bitcoind)?;
+    while client.get_height().unwrap() < 102 {
         sleep(Duration::from_millis(10))
     }
 
-    let graph_update = env.client.scan_txs(
+    let graph_update = client.scan_txs(
         misc_spks.into_iter(),
         vec![].into_iter(),
         vec![].into_iter(),

crates/testenv/src/lib.rs

@@ -19,17 +19,27 @@ impl TestEnv {
     pub fn new() -> anyhow::Result<Self> {
         let bitcoind = match std::env::var_os("TEST_BITCOIND") {
             Some(bitcoind_path) => electrsd::bitcoind::BitcoinD::new(bitcoind_path),
-            None => electrsd::bitcoind::BitcoinD::from_downloaded(),
+            None => {
+                let bitcoind_exe = std::env::var("BITCOIND_EXE")
+                    .ok()
+                    .or_else(|| electrsd::bitcoind::downloaded_exe_path().ok())
+                    .expect(
+                "you need to provide an env var BITCOIND_EXE or specify a bitcoind version feature",
+                );
+                let mut bitcoind_conf = electrsd::bitcoind::Conf::default();
+                bitcoind_conf.p2p = electrsd::bitcoind::P2P::Yes;
+                electrsd::bitcoind::BitcoinD::with_conf(bitcoind_exe, &bitcoind_conf)
+            }
         }?;
 
         let electrsd = match std::env::var_os("ELECTRS_EXE") {
             Some(env_electrs_exe) => electrsd::ElectrsD::new(env_electrs_exe, &bitcoind),
             None => {
-                let mut electrs_conf = electrsd::Conf::default();
-                electrs_conf.http_enabled = true;
+                let mut electrsd_conf = electrsd::Conf::default();
+                electrsd_conf.http_enabled = true;
                 let electrs_exe = electrsd::downloaded_exe_path()
                     .expect("electrs version feature must be enabled");
-                electrsd::ElectrsD::with_conf(electrs_exe, &bitcoind, &electrs_conf)
+                electrsd::ElectrsD::with_conf(electrs_exe, &bitcoind, &electrsd_conf)
             }
         }?;
 
@@ -137,13 +147,17 @@ impl TestEnv {
         Ok(())
     }
 
-    pub fn reorg(&self, count: usize) -> anyhow::Result<Vec<BlockHash>> {
-        let start_height = self.bitcoind.client.get_block_count()?;
-        self.invalidate_blocks(count, &self.bitcoind)?;
+    pub fn reorg(
+        &self,
+        count: usize,
+        bitcoind: &electrsd::bitcoind::BitcoinD,
+    ) -> anyhow::Result<Vec<BlockHash>> {
+        let start_height = bitcoind.client.get_block_count()?;
+        self.invalidate_blocks(count, bitcoind)?;
 
-        let res = self.mine_blocks(count, None, &self.bitcoind);
+        let res = self.mine_blocks(count, None, bitcoind);
         assert_eq!(
-            self.bitcoind.client.get_block_count()?,
+            bitcoind.client.get_block_count()?,
             start_height,
             "reorg should not result in height change"
         );