aljaz/breez-sdk-liquid
1
0
Fork 0
mirror of https://github.com/aljazceru/breez-sdk-liquid.git synced 2025-12-19 06:54:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fix clippy test issues (#850)

Browse Source 
* Fix clippy test issues

* Address review feedback
This commit is contained in:
Ross Savage
2025-04-03 12:21:27 +02:00
committed by GitHub
parent 7a9aa02cf7
commit 3f94fd970a
8 changed files with 552 additions and 572 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.githooks/pre-commit
View File

@@ -5,5 +5,5 @@ set -e
# Cargo syntax checks # Cargo syntax checks
dirs=("lib" "cli") dirs=("lib" "cli")
for dir in ${dirs[@]}; do for dir in ${dirs[@]}; do
(cd $dir; exec cargo fmt; exec cargo clippy -- -D warnings) (cd $dir; exec cargo fmt; exec cargo clippy --all-targets -- -D warnings)
done done

4
.github/workflows/main.yml vendored
View File

@@ -48,11 +48,11 @@ jobs:
- name: Clippy bindings - name: Clippy bindings
working-directory: lib/bindings working-directory: lib/bindings
run: cargo clippy -- -D warnings run: cargo clippy --all-targets -- -D warnings
- name: Clippy core - name: Clippy core
working-directory: lib/core working-directory: lib/core
run: cargo clippy -- -D warnings run: cargo clippy --all-targets -- -D warnings
- name: Clippy cli - name: Clippy cli
working-directory: cli working-directory: cli

6
Makefile
View File

@@ -12,10 +12,8 @@ fmt:
clippy: cargo-clippy wasm-clippy clippy: cargo-clippy wasm-clippy
cargo-clippy: cargo-clippy:
cd lib/bindings && cargo clippy -- -D warnings cd lib/bindings && cargo clippy --all-targets -- -D warnings
cd lib/bindings && cargo clippy --tests -- -D warnings cd lib/core && cargo clippy --all-targets -- -D warnings
cd lib/core && cargo clippy -- -D warnings
cd lib/core && cargo clippy --tests -- -D warnings
cd cli && cargo clippy -- -D warnings cd cli && cargo clippy -- -D warnings
wasm-clippy: wasm-clippy:

4
lib/core/Makefile
View File

@@ -18,7 +18,7 @@ test: cargo-test wasm-test
regtest-test: cargo-regtest-test wasm-regtest-test regtest-test: cargo-regtest-test wasm-regtest-test
cargo-clippy: cargo-clippy:
cargo clippy -- -D warnings cargo clippy --all-targets -- -D warnings
cargo-test: cargo-test:
cargo test cargo test
@@ -40,7 +40,7 @@ cargo-regtest-test: check-regtest
$(REGTEST_PREFIX) cargo test $(REGTEST_TESTS) --features "regtest" $(REGTEST_PREFIX) cargo test $(REGTEST_TESTS) --features "regtest"
wasm-clippy: wasm-clippy:
$(CLANG_PREFIX) cargo clippy --target=wasm32-unknown-unknown -- -D warnings $(CLANG_PREFIX) cargo clippy --all-targets --target=wasm32-unknown-unknown -- -D warnings
BROWSER ?= firefox BROWSER ?= firefox

75
lib/core/src/payjoin/pset/tests.rs
View File

@@ -1,33 +1,29 @@
#[cfg(test)] #![cfg(test)]
mod tests { use anyhow::Result;
use anyhow::Result; use bip39::rand::{self, RngCore};
use bip39::rand::{self, RngCore}; use lwk_wollet::bitcoin;
use lwk_wollet::bitcoin; use lwk_wollet::elements::address::AddressParams;
use lwk_wollet::elements::address::AddressParams; use lwk_wollet::elements::confidential::{Asset, AssetBlindingFactor, Value, ValueBlindingFactor};
use lwk_wollet::elements::confidential::{ use lwk_wollet::elements::secp256k1_zkp::SecretKey;
Asset, AssetBlindingFactor, Value, ValueBlindingFactor, use lwk_wollet::elements::{secp256k1_zkp, Address, AssetId, Script, TxOutSecrets, Txid};
}; use std::str::FromStr;
use lwk_wollet::elements::secp256k1_zkp::SecretKey;
use lwk_wollet::elements::{secp256k1_zkp, Address, AssetId, Script, TxOutSecrets, Txid};
use std::str::FromStr;
use crate::payjoin::pset::{construct_pset, ConstructPsetRequest, PsetInput, PsetOutput}; use crate::payjoin::pset::{construct_pset, ConstructPsetRequest, PsetInput, PsetOutput};
#[cfg(all(target_family = "wasm", target_os = "unknown"))] #[cfg(all(target_family = "wasm", target_os = "unknown"))]
wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser); wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
fn create_test_secret_key() -> SecretKey { fn create_test_secret_key() -> SecretKey {
let mut rng = rand::thread_rng(); let mut rng = rand::thread_rng();
let mut buf = [0u8; 32]; let mut buf = [0u8; 32];
rng.fill_bytes(&mut buf); rng.fill_bytes(&mut buf);
SecretKey::from_slice(&buf).expect("Expected valid secret key") SecretKey::from_slice(&buf).expect("Expected valid secret key")
} }
fn create_test_input(asset_id: AssetId, sk: &SecretKey) -> PsetInput { fn create_test_input(asset_id: AssetId, sk: &SecretKey) -> PsetInput {
// Create a dummy txid // Create a dummy txid
let txid = let txid =
Txid::from_str("0000000000000000000000000000000000000000000000000000000000000001") Txid::from_str("0000000000000000000000000000000000000000000000000000000000000001").unwrap();
.unwrap();
// Create a dummy script pubkey // Create a dummy script pubkey
let script_pub_key = let script_pub_key =
@@ -37,11 +33,8 @@ mod tests {
let secp = secp256k1_zkp::Secp256k1::new(); let secp = secp256k1_zkp::Secp256k1::new();
let asset_bf = AssetBlindingFactor::from_slice(&sk.secret_bytes()).unwrap(); let asset_bf = AssetBlindingFactor::from_slice(&sk.secret_bytes()).unwrap();
let asset_gen = secp256k1_zkp::Generator::new_blinded( let asset_gen =
&secp, secp256k1_zkp::Generator::new_blinded(&secp, asset_id.into_tag(), asset_bf.into_inner());
asset_id.into_tag(),
asset_bf.into_inner(),
);
let asset_commitment = Asset::Confidential(asset_gen); let asset_commitment = Asset::Confidential(asset_gen);
// Create a Pedersen commitment for the value // Create a Pedersen commitment for the value
@@ -66,15 +59,14 @@ mod tests {
value_commitment, value_commitment,
tx_out_sec, tx_out_sec,
} }
} }
fn create_test_output(asset_id: AssetId, sk: &SecretKey) -> PsetOutput { fn create_test_output(asset_id: AssetId, sk: &SecretKey) -> PsetOutput {
// Create a dummy blinded address // Create a dummy blinded address
let secp = secp256k1_zkp::Secp256k1::new(); let secp = secp256k1_zkp::Secp256k1::new();
let blinding_key = let blinding_key =
bitcoin::PublicKey::new(secp256k1_zkp::PublicKey::from_secret_key(&secp, sk)); bitcoin::PublicKey::new(secp256k1_zkp::PublicKey::from_secret_key(&secp, sk));
let address_pk = let address_pk = bitcoin::PublicKey::new(secp256k1_zkp::PublicKey::from_secret_key(&secp, sk));
bitcoin::PublicKey::new(secp256k1_zkp::PublicKey::from_secret_key(&secp, sk));
let address = Address::p2pkh( let address = Address::p2pkh(
&address_pk, &address_pk,
@@ -87,10 +79,10 @@ mod tests {
asset_id, asset_id,
amount: 5000, amount: 5000,
} }
} }
#[sdk_macros::test_all] #[sdk_macros::test_all]
fn test_construct_pset_basic() -> Result<()> { fn test_construct_pset_basic() -> Result<()> {
// Create test data // Create test data
let asset_id = AssetId::from_slice(&[2; 32]).unwrap(); let asset_id = AssetId::from_slice(&[2; 32]).unwrap();
let secret_key = create_test_secret_key(); let secret_key = create_test_secret_key();
@@ -118,10 +110,10 @@ mod tests {
assert_eq!(pset.outputs().len(), 2); // 1 regular output + 1 fee output assert_eq!(pset.outputs().len(), 2); // 1 regular output + 1 fee output
Ok(()) Ok(())
} }
#[sdk_macros::test_all] #[sdk_macros::test_all]
fn test_construct_pset_multiple_outputs() -> Result<()> { fn test_construct_pset_multiple_outputs() -> Result<()> {
// Create test data // Create test data
let asset_id = AssetId::from_slice(&[3; 32]).unwrap(); let asset_id = AssetId::from_slice(&[3; 32]).unwrap();
let secret_key = create_test_secret_key(); let secret_key = create_test_secret_key();
@@ -150,10 +142,10 @@ mod tests {
assert_eq!(pset.outputs().len(), 4); // 3 regular outputs + 1 fee output assert_eq!(pset.outputs().len(), 4); // 3 regular outputs + 1 fee output
Ok(()) Ok(())
} }
#[sdk_macros::test_all] #[sdk_macros::test_all]
fn test_construct_pset_empty_inputs() { fn test_construct_pset_empty_inputs() {
// Create test data // Create test data
let asset_id = AssetId::from_slice(&[4; 32]).unwrap(); let asset_id = AssetId::from_slice(&[4; 32]).unwrap();
let secret_key = create_test_secret_key(); let secret_key = create_test_secret_key();
@@ -173,10 +165,10 @@ mod tests {
// Blinding should fail with empty inputs // Blinding should fail with empty inputs
let result = construct_pset(request); let result = construct_pset(request);
assert!(result.is_err()); assert!(result.is_err());
} }
#[sdk_macros::test_all] #[sdk_macros::test_all]
fn test_construct_pset_empty_outputs() { fn test_construct_pset_empty_outputs() {
// Create test data // Create test data
let asset_id = AssetId::from_slice(&[5; 32]).unwrap(); let asset_id = AssetId::from_slice(&[5; 32]).unwrap();
let secret_key = create_test_secret_key(); let secret_key = create_test_secret_key();
@@ -196,5 +188,4 @@ mod tests {
// Call the function // Call the function
let result = construct_pset(request); let result = construct_pset(request);
assert!(result.is_err()); assert!(result.is_err());
}
} }

60
lib/core/src/payjoin/utxo_select/tests.rs
View File

@@ -1,22 +1,21 @@
#[cfg(test)] #![cfg(test)]
mod tests { use std::collections::BTreeMap;
use std::collections::BTreeMap;
use lwk_wollet::elements::AssetId; use lwk_wollet::elements::AssetId;
use crate::payjoin::{ use crate::payjoin::{
model::InOut, model::InOut,
utxo_select::{ utxo_select::{
utxo_select, utxo_select_basic, utxo_select_best, utxo_select_fixed, utxo_select, utxo_select_basic, utxo_select_best, utxo_select_fixed, utxo_select_in_range,
utxo_select_in_range, UtxoSelectRequest, UtxoSelectRequest,
}, },
}; };
#[cfg(all(target_family = "wasm", target_os = "unknown"))] #[cfg(all(target_family = "wasm", target_os = "unknown"))]
wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser); wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
#[sdk_macros::test_all] #[sdk_macros::test_all]
fn test_utxo_select_basic() { fn test_utxo_select_basic() {
// Basic case - should select UTXOs in order until target is met // Basic case - should select UTXOs in order until target is met
let utxos = vec![100, 200, 300, 400]; let utxos = vec![100, 200, 300, 400];
let selected = utxo_select_basic(300, &utxos); let selected = utxo_select_basic(300, &utxos);
@@ -61,10 +60,10 @@ mod tests {
let utxos = vec![100, 200, 300, 400]; let utxos = vec![100, 200, 300, 400];
let selected = utxo_select_basic(1000, &utxos); let selected = utxo_select_basic(1000, &utxos);
assert_eq!(selected, Some(vec![100, 200, 300, 400])); assert_eq!(selected, Some(vec![100, 200, 300, 400]));
} }
#[sdk_macros::test_all] #[sdk_macros::test_all]
fn test_utxo_select_fixed() { fn test_utxo_select_fixed() {
let utxos = vec![100, 200, 300, 400]; let utxos = vec![100, 200, 300, 400];
// Should take first two UTXOs (100 + 200 = 300) // Should take first two UTXOs (100 + 200 = 300)
@@ -108,10 +107,10 @@ mod tests {
let utxos = vec![large_value, large_value / 2]; let utxos = vec![large_value, large_value / 2];
let selected = utxo_select_fixed(large_value, 1, &utxos); let selected = utxo_select_fixed(large_value, 1, &utxos);
assert_eq!(selected, Some(vec![large_value])); assert_eq!(selected, Some(vec![large_value]));
} }
#[sdk_macros::test_all] #[sdk_macros::test_all]
fn test_utxo_select_best() { fn test_utxo_select_best() {
let utxos = vec![100, 200, 300, 400]; let utxos = vec![100, 200, 300, 400];
// Should find optimal solution // Should find optimal solution
@@ -126,10 +125,10 @@ mod tests {
// Should use all UTXOs as fallback when needed // Should use all UTXOs as fallback when needed
let selected = utxo_select_best(950, &utxos); let selected = utxo_select_best(950, &utxos);
assert_eq!(selected, Some(vec![100, 200, 300, 400])); assert_eq!(selected, Some(vec![100, 200, 300, 400]));
} }
#[sdk_macros::test_all] #[sdk_macros::test_all]
fn test_utxo_select_in_range() { fn test_utxo_select_in_range() {
let utxos = vec![50, 100, 200, 300, 400]; let utxos = vec![50, 100, 200, 300, 400];
// Exact match // Exact match
@@ -147,10 +146,10 @@ mod tests {
// With target count // With target count
let selected = utxo_select_in_range(250, 0, 2, &utxos); let selected = utxo_select_in_range(250, 0, 2, &utxos);
assert_eq!(selected, Some(vec![200, 50])); assert_eq!(selected, Some(vec![200, 50]));
} }
#[sdk_macros::test_all] #[sdk_macros::test_all]
fn test_utxo_select_success() { fn test_utxo_select_success() {
let policy_asset = AssetId::from_slice(&[1; 32]).unwrap(); let policy_asset = AssetId::from_slice(&[1; 32]).unwrap();
let fee_asset = AssetId::from_slice(&[2; 32]).unwrap(); let fee_asset = AssetId::from_slice(&[2; 32]).unwrap();
@@ -253,10 +252,10 @@ mod tests {
// Input and output sums should match for each asset // Input and output sums should match for each asset
assert_eq!(input_sum_by_asset, output_sum_by_asset); assert_eq!(input_sum_by_asset, output_sum_by_asset);
} }
#[sdk_macros::test_all] #[sdk_macros::test_all]
fn test_utxo_select_error_cases() { fn test_utxo_select_error_cases() {
let policy_asset = AssetId::from_slice(&[1; 32]).unwrap(); let policy_asset = AssetId::from_slice(&[1; 32]).unwrap();
let fee_asset = AssetId::from_slice(&[2; 32]).unwrap(); let fee_asset = AssetId::from_slice(&[2; 32]).unwrap();
@@ -323,10 +322,10 @@ mod tests {
]; ];
let result = utxo_select(bad_req); let result = utxo_select(bad_req);
assert!(result.is_err()); assert!(result.is_err());
} }
#[sdk_macros::test_all] #[sdk_macros::test_all]
fn test_utxo_select_with_change() { fn test_utxo_select_with_change() {
let policy_asset = AssetId::from_slice(&[1; 32]).unwrap(); let policy_asset = AssetId::from_slice(&[1; 32]).unwrap();
let fee_asset = AssetId::from_slice(&[2; 32]).unwrap(); let fee_asset = AssetId::from_slice(&[2; 32]).unwrap();
@@ -384,5 +383,4 @@ mod tests {
// Check that we're not wasting fees unnecessarily // Check that we're not wasting fees unnecessarily
assert!(selection.cost <= selection.server_fee.value); assert!(selection.cost <= selection.server_fee.value);
}
} }

11
lib/core/src/test_utils/chain.rs
View File

@@ -68,7 +68,7 @@ impl LiquidChainService for MockLiquidChainService {
_script: &ElementsScript, _script: &ElementsScript,
_retries: u64, _retries: u64,
) -> Result<Vec<LBtcHistory>> { ) -> Result<Vec<LBtcHistory>> {
Ok(self.get_history().into_iter().map(Into::into).collect()) Ok(self.get_history().into_iter().collect())
} }
async fn get_script_history(&self, _script: &ElementsScript) -> Result<Vec<LBtcHistory>> { async fn get_script_history(&self, _script: &ElementsScript) -> Result<Vec<LBtcHistory>> {
@@ -156,14 +156,7 @@ impl BitcoinChainService for MockBitcoinChainService {
_script: &Script, _script: &Script,
_retries: u64, _retries: u64,
) -> Result<Vec<BtcHistory>> { ) -> Result<Vec<BtcHistory>> {
Ok(self Ok(self.history.lock().unwrap().clone().into_iter().collect())
.history
.lock()
.unwrap()
.clone()
.into_iter()
.map(Into::into)
.collect())
} }
async fn get_script_history(&self, _scripts: &Script) -> Result<Vec<BtcHistory>> { async fn get_script_history(&self, _scripts: &Script) -> Result<Vec<BtcHistory>> {

2
lib/wasm/Makefile
View File

@@ -9,7 +9,7 @@ init:
rustup target add wasm32-unknown-unknown rustup target add wasm32-unknown-unknown
clippy: clippy:
$(CLANG_PREFIX) cargo clippy --target=wasm32-unknown-unknown -- -D warnings $(CLANG_PREFIX) cargo clippy --all-targets --target=wasm32-unknown-unknown -- -D warnings
build: build-bundle build-deno build-node build-web build: build-bundle build-deno build-node build-web