elementsd-tests: make bitcoind and elementsd paths configurable

Author: apoelstra

elementsd-tests/Cargo.toml

@@ -9,6 +9,6 @@ edition = "2018"
 [dependencies]
 base64 = "0.13.0"
 elements = {path = "../"}
-elementsd = { version = "0.6.0", features = ["0_21_0", "bitcoind_22_0"] }
+elementsd = "0.6.0"
 rand = "0.8"
 

elementsd-tests/src/lib.rs

@@ -137,6 +137,40 @@ impl Call for ElementsD {
 
 #[cfg(test)]
 fn setup(validate_pegin: bool) -> (ElementsD, Option<BitcoinD>) {
+    // Create env var BITCOIND_EXE_PATH to point to the ../bitcoind/bin/bitcoind binary
+    let key = "BITCOIND_EXE";
+    if std::env::var(key).is_err() {
+        let mut root_path = std::env::current_dir().unwrap();
+        while std::fs::metadata(root_path.join("LICENSE")).is_err() {
+            if !root_path.pop() {
+                panic!("Could not find LICENSE file; do not know where repo root is.");
+            }
+        }
+
+        let bitcoind_path = root_path
+            .join("elementsd-tests")
+            .join("bin")
+            .join("bitcoind");
+        std::env::set_var(key, bitcoind_path);
+    }
+
+    // Create env var BITCOIND_EXE_PATH to point to the ../bitcoind/bin/bitcoind binary
+    let key = "ELEMENTSD_EXE";
+    if std::env::var(key).is_err() {
+        let mut root_path = std::env::current_dir().unwrap();
+        while std::fs::metadata(root_path.join("LICENSE")).is_err() {
+            if !root_path.pop() {
+                panic!("Could not find LICENSE file; do not know where repo root is.");
+            }
+        }
+
+        let bitcoind_path = root_path
+            .join("elementsd-tests")
+            .join("bin")
+            .join("elementsd");
+        std::env::set_var(key, bitcoind_path);
+    }
+
     let mut bitcoind = None;
     if validate_pegin {
         let bitcoind_exe = bitcoind::exe_path().unwrap();

elementsd-tests/src/pset.rs

@@ -1,16 +1,13 @@
-#![cfg(all(test, feature = "integration"))]
 
 extern crate elements;
 
-extern crate bitcoin;
 extern crate elementsd;
 extern crate rand;
 
-use crate::setup;
+use crate::{setup, Call};
 
-use bitcoin::hashes::hex::ToHex;
-use bitcoin::{Address, Amount};
-use elements::bitcoin::hashes::hex::FromHex;
+use elements::bitcoin::{self, Address, Amount};
+use elements::bitcoin::hashes::hex::{FromHex, ToHex};
 use elements::bitcoin::hashes::Hash;
 use elements::encode::{deserialize, serialize};
 use elements::pset::PartiallySignedTransaction;
@@ -162,56 +159,6 @@ fn psbt_rtt(elementsd: &ElementsD, base64: &str) {
     }
 }
 
-impl Call for ElementsD {
-    fn call(&self, cmd: &str, args: &[Value]) -> Value {
-        self.client().call::<Value>(cmd, args).unwrap()
-    }
-
-    fn decode_psbt(&self, psbt: &str) -> Option<Value> {
-        self.client()
-            .call::<Value>("decodepsbt", &[psbt.into()])
-            .ok()
-    }
-
-    fn get_new_address(&self) -> String {
-        self.call("getnewaddress", &[])
-            .as_str()
-            .unwrap()
-            .to_string()
-    }
-
-    fn generate(&self, blocks: u32) {
-        let address = self.get_new_address();
-        let _value = self.call("generatetoaddress", &[blocks.into(), address.into()]);
-    }
-
-
-    fn expected_next(&self, base64: &str) -> String {
-        let value = self.call("analyzepsbt", &[base64.into()]);
-        value.get("next").unwrap().as_str().unwrap().to_string()
-    }
-
-    fn wallet_process_psbt(&self, base64: &str) -> String {
-        let value = self.call("walletprocesspsbt", &[base64.into()]);
-        value.get("psbt").unwrap().as_str().unwrap().to_string()
-    }
-
-    fn finalize_psbt(&self, base64: &str) -> String {
-        let value = self.call("finalizepsbt", &[base64.into()]);
-        value.get("hex").unwrap().as_str().unwrap().to_string()
-    }
-
-    fn get_balances(&self) -> Value {
-        self.call("getbalances", &[])
-    }
-
-    fn test_mempool_accept(&self, hex: &str) -> bool {
-        let result = self.call("testmempoolaccept", &[json!([hex])]);
-        let allowed = result.get(0).unwrap().get("allowed");
-        allowed.unwrap().as_bool().unwrap()
-    }
-}
-
 fn psbt_from_base64(base64: &str) -> PartiallySignedTransaction {
     let bytes = base64::decode(&base64).unwrap();
     deserialize(&bytes).unwrap()