Skip to content

Commit ee8aee0

Browse files
tnulltnull
committed
Fix clippy warnings
1 parent 37e2142 commit ee8aee0

File tree

3 files changed

+62
-48
lines changed

3 files changed

+62
-48
lines changed

‎src/async.rs

Lines changed: 1 addition & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -87,12 +87,7 @@ impl AsyncClient {
8787
) -> Result<Option<Txid>, Error> {
8888
let resp = self
8989
.client
90-
.get(&format!(
91-
"{}/block/{}/txid/{}",
92-
self.url,
93-
block_hash.to_string(),
94-
index
95-
))
90+
.get(&format!("{}/block/{}/txid/{}", self.url, block_hash, index))
9691
.send()
9792
.await?;
9893

‎src/blocking.rs

Lines changed: 1 addition & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -92,12 +92,7 @@ impl BlockingClient {
9292
) -> Result<Option<Txid>, Error> {
9393
let resp = self
9494
.agent
95-
.get(&format!(
96-
"{}/block/{}/txid/{}",
97-
self.url,
98-
block_hash.to_string(),
99-
index
100-
))
95+
.get(&format!("{}/block/{}/txid/{}", self.url, block_hash, index))
10196
.call();
10297

10398
match resp {

‎src/lib.rs

Lines changed: 60 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -198,34 +198,39 @@ impl_error!(bitcoin::hashes::hex::Error, Hex, Error);
198198
#[cfg(test)]
199199
mod test {
200200
use super::*;
201-
use bitcoin::Amount;
202-
use electrsd::{
203-
bitcoind, bitcoind::bitcoincore_rpc::bitcoincore_rpc_json::AddressType,
204-
bitcoind::bitcoincore_rpc::RpcApi, bitcoind::BitcoinD, ElectrsD,
205-
};
206-
use electrum_client::ElectrumApi;
201+
use electrsd::{bitcoind, bitcoind::BitcoinD, ElectrsD};
207202
use lazy_static::lazy_static;
208203
use std::env;
209-
use std::sync::{Mutex, Once};
210-
use std::time::Duration;
204+
use tokio::sync::Mutex;
205+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
206+
use {
207+
bitcoin::Amount,
208+
electrsd::{
209+
bitcoind::bitcoincore_rpc::bitcoincore_rpc_json::AddressType,
210+
bitcoind::bitcoincore_rpc::RpcApi,
211+
},
212+
electrum_client::ElectrumApi,
213+
std::time::Duration,
214+
tokio::sync::OnceCell,
215+
};
211216

212217
lazy_static! {
213218
static ref BITCOIND: BitcoinD = {
214219
let bitcoind_exe = env::var("BITCOIND_EXE")
215220
.ok()
216-
.or(bitcoind::downloaded_exe_path().ok())
221+
.or_else(|| bitcoind::downloaded_exe_path().ok())
217222
.expect(
218-
"you should provide env var BITCOIND_EXE or specifiy a bitcoind version feature",
223+
"you need to provide an env var BITCOIND_EXE or specify a bitcoind version feature",
219224
);
220225
let conf = bitcoind::Conf::default();
221226
BitcoinD::with_conf(bitcoind_exe, &conf).unwrap()
222227
};
223228
static ref ELECTRSD: ElectrsD = {
224229
let electrs_exe = env::var("ELECTRS_EXE")
225230
.ok()
226-
.or(electrsd::downloaded_exe_path())
231+
.or_else(electrsd::downloaded_exe_path)
227232
.expect(
228-
"you should provide env var ELECTRS_EXE or specifiy a electrsd version feature",
233+
"you need to provide env var ELECTRS_EXE or specify an electrsd version feature",
229234
);
230235
let mut conf = electrsd::Conf::default();
231236
conf.http_enabled = true;
@@ -234,13 +239,17 @@ mod test {
234239
static ref MINER: Mutex<()> = Mutex::new(());
235240
}
236241

237-
static PREMINE: Once = Once::new();
242+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
243+
static PREMINE: OnceCell<()> = OnceCell::const_new();
238244

239-
fn setup_clients() -> (BlockingClient, AsyncClient) {
240-
PREMINE.call_once(|| {
241-
let _miner = MINER.lock().unwrap();
242-
generate_blocks_and_wait(101);
243-
});
245+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
246+
async fn setup_clients() -> (BlockingClient, AsyncClient) {
247+
PREMINE
248+
.get_or_init(|| async {
249+
let _miner = MINER.lock().await;
250+
generate_blocks_and_wait(101);
251+
})
252+
.await;
244253

245254
let esplora_url = ELECTRSD.esplora_url.as_ref().unwrap();
246255

@@ -253,12 +262,14 @@ mod test {
253262
(blocking_client, async_client)
254263
}
255264

265+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
256266
fn generate_blocks_and_wait(num: usize) {
257267
let cur_height = BITCOIND.client.get_block_count().unwrap();
258268
generate_blocks(num);
259269
wait_for_block(cur_height as usize + num);
260270
}
261271

272+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
262273
fn generate_blocks(num: usize) {
263274
let address = BITCOIND
264275
.client
@@ -270,6 +281,7 @@ mod test {
270281
.unwrap();
271282
}
272283

284+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
273285
fn wait_for_block(min_height: usize) {
274286
let mut header = ELECTRSD.client.block_headers_subscribe().unwrap();
275287
loop {
@@ -284,6 +296,7 @@ mod test {
284296
}
285297
}
286298

299+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
287300
fn exponential_backoff_poll<T, F>(mut poll: F) -> T
288301
where
289302
F: FnMut() -> Option<T>,
@@ -344,9 +357,10 @@ mod test {
344357
);
345358
}
346359

360+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
347361
#[tokio::test]
348362
async fn test_get_tx() {
349-
let (blocking_client, async_client) = setup_clients();
363+
let (blocking_client, async_client) = setup_clients().await;
350364

351365
let address = BITCOIND
352366
.client
@@ -365,17 +379,18 @@ mod test {
365379
None,
366380
)
367381
.unwrap();
368-
let _miner = MINER.lock().unwrap();
382+
let _miner = MINER.lock().await;
369383
generate_blocks_and_wait(1);
370384

371385
let tx = blocking_client.get_tx(&txid).unwrap();
372386
let tx_async = async_client.get_tx(&txid).await.unwrap();
373387
assert_eq!(tx, tx_async);
374388
}
375389

390+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
376391
#[tokio::test]
377392
async fn test_get_tx_no_opt() {
378-
let (blocking_client, async_client) = setup_clients();
393+
let (blocking_client, async_client) = setup_clients().await;
379394

380395
let address = BITCOIND
381396
.client
@@ -394,17 +409,18 @@ mod test {
394409
None,
395410
)
396411
.unwrap();
397-
let _miner = MINER.lock().unwrap();
412+
let _miner = MINER.lock().await;
398413
generate_blocks_and_wait(1);
399414

400415
let tx_no_opt = blocking_client.get_tx_no_opt(&txid).unwrap();
401416
let tx_no_opt_async = async_client.get_tx_no_opt(&txid).await.unwrap();
402417
assert_eq!(tx_no_opt, tx_no_opt_async);
403418
}
404419

420+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
405421
#[tokio::test]
406422
async fn test_get_tx_status() {
407-
let (blocking_client, async_client) = setup_clients();
423+
let (blocking_client, async_client) = setup_clients().await;
408424

409425
let address = BITCOIND
410426
.client
@@ -423,26 +439,28 @@ mod test {
423439
None,
424440
)
425441
.unwrap();
426-
let _miner = MINER.lock().unwrap();
442+
let _miner = MINER.lock().await;
427443
generate_blocks_and_wait(1);
428444

429445
let tx_status = blocking_client.get_tx_status(&txid).unwrap().unwrap();
430446
let tx_status_async = async_client.get_tx_status(&txid).await.unwrap().unwrap();
431447
assert_eq!(tx_status, tx_status_async);
432-
assert_eq!(tx_status.confirmed, true);
448+
assert!(tx_status.confirmed);
433449
}
434450

451+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
435452
#[tokio::test]
436453
async fn test_get_header() {
437-
let (blocking_client, async_client) = setup_clients();
454+
let (blocking_client, async_client) = setup_clients().await;
438455
let block_header = blocking_client.get_header(53).unwrap();
439456
let block_header_async = async_client.get_header(53).await.unwrap();
440457
assert_eq!(block_header, block_header_async);
441458
}
442459

460+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
443461
#[tokio::test]
444462
async fn test_get_merkle_proof() {
445-
let (blocking_client, async_client) = setup_clients();
463+
let (blocking_client, async_client) = setup_clients().await;
446464

447465
let address = BITCOIND
448466
.client
@@ -461,7 +479,7 @@ mod test {
461479
None,
462480
)
463481
.unwrap();
464-
let _miner = MINER.lock().unwrap();
482+
let _miner = MINER.lock().await;
465483
generate_blocks_and_wait(1);
466484

467485
let merkle_proof = blocking_client.get_merkle_proof(&txid).unwrap().unwrap();
@@ -470,9 +488,10 @@ mod test {
470488
assert!(merkle_proof.pos > 0);
471489
}
472490

491+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
473492
#[tokio::test]
474493
async fn test_get_output_status() {
475-
let (blocking_client, async_client) = setup_clients();
494+
let (blocking_client, async_client) = setup_clients().await;
476495

477496
let address = BITCOIND
478497
.client
@@ -491,7 +510,7 @@ mod test {
491510
None,
492511
)
493512
.unwrap();
494-
let _miner = MINER.lock().unwrap();
513+
let _miner = MINER.lock().await;
495514
generate_blocks_and_wait(1);
496515

497516
let output_status = blocking_client
@@ -507,26 +526,29 @@ mod test {
507526
assert_eq!(output_status, output_status_async);
508527
}
509528

529+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
510530
#[tokio::test]
511531
async fn test_get_height() {
512-
let (blocking_client, async_client) = setup_clients();
532+
let (blocking_client, async_client) = setup_clients().await;
513533
let block_height = blocking_client.get_height().unwrap();
514534
let block_height_async = async_client.get_height().await.unwrap();
515535
assert!(block_height > 0);
516536
assert_eq!(block_height, block_height_async);
517537
}
518538

539+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
519540
#[tokio::test]
520541
async fn test_get_tip_hash() {
521-
let (blocking_client, async_client) = setup_clients();
542+
let (blocking_client, async_client) = setup_clients().await;
522543
let tip_hash = blocking_client.get_tip_hash().unwrap();
523544
let tip_hash_async = async_client.get_tip_hash().await.unwrap();
524545
assert_eq!(tip_hash, tip_hash_async);
525546
}
526547

548+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
527549
#[tokio::test]
528550
async fn test_get_txid_at_block_index() {
529-
let (blocking_client, async_client) = setup_clients();
551+
let (blocking_client, async_client) = setup_clients().await;
530552

531553
let block_hash = BITCOIND.client.get_block_hash(23).unwrap();
532554

@@ -542,17 +564,19 @@ mod test {
542564
assert_eq!(txid_at_block_index, txid_at_block_index_async);
543565
}
544566

567+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
545568
#[tokio::test]
546569
async fn test_get_fee_estimates() {
547-
let (blocking_client, async_client) = setup_clients();
570+
let (blocking_client, async_client) = setup_clients().await;
548571
let fee_estimates = blocking_client.get_fee_estimates().unwrap();
549572
let fee_estimates_async = async_client.get_fee_estimates().await.unwrap();
550573
assert_eq!(fee_estimates.len(), fee_estimates_async.len());
551574
}
552575

576+
#[cfg(all(feature = "blocking", any(feature = "async", feature = "async-https")))]
553577
#[tokio::test]
554578
async fn test_scripthash_txs() {
555-
let (blocking_client, async_client) = setup_clients();
579+
let (blocking_client, async_client) = setup_clients().await;
556580

557581
let address = BITCOIND
558582
.client
@@ -571,7 +595,7 @@ mod test {
571595
None,
572596
)
573597
.unwrap();
574-
let _miner = MINER.lock().unwrap();
598+
let _miner = MINER.lock().await;
575599
generate_blocks_and_wait(1);
576600

577601
let expected_tx = BITCOIND

0 commit comments

Comments
 (0)