fix(tests): adapt test infrastructure to corepc-node and ureq v3

After cherry-picking PR Blockstream#177 (202601-deps), fix test compilation issues
arising from API differences between our refactored tests and the new
dependencies:

- Replace `ureq::Response` (now private) with `ureq::Body` in get_body()
- Replace `impl bitcoincore_rpc::RpcApi for TestRunner` with a plain
  `call()` method (bitcoincore_rpc not available in non-liquid mode)
- Add TestRunner wrappers: invalidate_block, generate_to_address,
  get_block_hash, get_raw_transaction (all previously via RpcApi)
- Fix get_block_count() call to go through wrapper (returns u64 not
  corepc_node::vtype::GetBlockCount)

Author: philippem

tests/common.rs

@@ -295,15 +295,44 @@ impl TestRunner {
     }
 }
 
-// Make the RpcApi methods available directly on TestRunner,
-// without having to go through the node_client() getter
-impl bitcoincore_rpc::RpcApi for TestRunner {
-    fn call<T: for<'a> serde::de::Deserialize<'a>>(
+impl TestRunner {
+    // Make the node_client's call() available directly on TestRunner
+    pub fn call<T: for<'a> serde::de::Deserialize<'a>>(
         &self,
         cmd: &str,
         args: &[serde_json::Value],
-    ) -> bitcoincore_rpc::Result<T> {
-        self.node_client().call(cmd, args)
+    ) -> Result<T> {
+        Ok(self.node_client().call(cmd, args)?)
+    }
+
+    pub fn invalidate_block(&self, block_hash: &BlockHash) -> Result<()> {
+        self.call("invalidateblock", &[block_hash.to_string().into()])
+    }
+
+    pub fn generate_to_address(&self, count: u64, address: &Address) -> Result<Vec<BlockHash>> {
+        let hashes: Vec<String> =
+            self.call("generatetoaddress", &[count.into(), address.to_string().into()])?;
+        Ok(hashes
+            .into_iter()
+            .map(|h| h.parse().expect("valid block hash"))
+            .collect())
+    }
+
+    pub fn get_block_hash(&self, height: u64) -> Result<BlockHash> {
+        let hash: String = self.call("getblockhash", &[height.into()])?;
+        Ok(hash.parse().expect("valid block hash"))
+    }
+
+    #[cfg(not(feature = "liquid"))]
+    pub fn get_raw_transaction(
+        &self,
+        txid: &Txid,
+        _block_hash: Option<&BlockHash>,
+    ) -> Result<bitcoin::Transaction> {
+        use bitcoin::hex::FromHex;
+        let tx_hex: String = self.call("getrawtransaction", &[txid.to_string().into()])?;
+        let tx_bytes = Vec::<u8>::from_hex(&tx_hex).expect("valid hex");
+        Ok(bitcoin::consensus::deserialize(&tx_bytes).expect("valid transaction"))
     }
 }
 

tests/rest.rs

@@ -17,16 +17,16 @@ pub mod common;
 
 use common::Result;
 
-fn get(rest_addr: net::SocketAddr, path: &str) -> std::result::Result<ureq::Response, ureq::Error> {
-    ureq::get(&format!("http://{}{}", rest_addr, path)).call()
+fn get_body(rest_addr: net::SocketAddr, path: &str) -> std::result::Result<ureq::Body, ureq::Error> {
+    Ok(ureq::get(&format!("http://{}{}", rest_addr, path)).call()?.into_body())
 }
 
 fn get_json(rest_addr: net::SocketAddr, path: &str) -> Result<Value> {
-    Ok(get(rest_addr, path)?.into_body().read_json()?)
+    Ok(get_body(rest_addr, path)?.read_json()?)
 }
 
 fn get_plain(rest_addr: net::SocketAddr, path: &str) -> Result<String> {
-    Ok(get(rest_addr, path)?.into_body().read_to_string()?)
+    Ok(get_body(rest_addr, path)?.read_to_string()?)
 }
 
 #[test]
@@ -318,7 +318,7 @@ fn test_rest_block() -> Result<()> {
     }
 
     // Test GET /block/:hash/raw
-    let mut res = get(rest_addr, &format!("/block/{}/raw", blockhash))?.into_reader();
+    let mut res = get_body(rest_addr, &format!("/block/{}/raw", blockhash))?.into_reader();
     let mut rest_rawblock = Vec::new();
     res.read_to_end(&mut rest_rawblock).unwrap();
     let node_hexblock = // uses low-level call() to support Elements
@@ -826,7 +826,7 @@ fn test_rest_reorg() -> Result<()> {
         )
     };
 
-    let init_height = tester.node_client().get_block_count()?;
+    let init_height = tester.get_block_count()?;
 
     let address = tester.newaddress()?;
     let miner_address = tester.newaddress()?;