Add constructors

Reduce code reuse by adding constructors

Author: yancyribbens

src/branch_and_bound.rs

@@ -341,39 +341,24 @@ mod tests {
         weighted_utxos: Vec<&'a str>,
     }
 
-    fn build_pool(fee: Amount) -> Vec<Utxo> {
-        let amts = [
-            Amount::from_str("1 cBTC").unwrap() + fee,
-            Amount::from_str("2 cBTC").unwrap() + fee,
-            Amount::from_str("3 cBTC").unwrap() + fee,
-            Amount::from_str("4 cBTC").unwrap() + fee,
-        ];
-
-        let mut pool = vec![];
-
-        for a in amts {
-            let utxo = Utxo::new(a, Weight::ZERO);
-            pool.push(utxo);
-        }
-
-        pool
+    fn build_pool() -> UtxoPool {
+        let utxo_str_list = vec!["1 cBTC", "2 cBTC", "3 cBTC", "4 cBTC"];
+        UtxoPool::from_str_list(&utxo_str_list)
     }
 
     fn assert_coin_select(target_str: &str, expected_inputs_str: &[&str]) {
-        let fee = Amount::ZERO;
         let target = Amount::from_str(target_str).unwrap();
-        let utxos = build_pool(fee);
+        let pool = build_pool();
         let inputs: Vec<Utxo> =
-            select_coins_bnb(target, Amount::ZERO, FeeRate::ZERO, FeeRate::ZERO, &utxos)
+            select_coins_bnb(target, Amount::ZERO, FeeRate::ZERO, FeeRate::ZERO, &pool.utxos)
                 .unwrap()
                 .cloned()
                 .collect();
-        let expected_inputs: Vec<Utxo> =
-            expected_inputs_str.iter().map(|s| Utxo::from_str(s).unwrap()).collect();
-        assert_eq!(expected_inputs, inputs);
+        let expected_inputs: UtxoPool = UtxoPool::from_str_list(expected_inputs_str);
+        assert_eq!(expected_inputs.utxos, inputs);
     }
 
-    fn assert_coin_select_params(p: &ParamsStr, expected_inputs: Option<&[&str]>) {
+    fn assert_coin_select_params(p: &ParamsStr, expected_inputs_str: Option<&[&str]>) {
         let fee_rate = p.fee_rate.parse::<u64>().unwrap(); // would be nice if  FeeRate had
                                                            // from_str like Amount::from_str()
         let lt_fee_rate = p.lt_fee_rate.parse::<u64>().unwrap();
@@ -383,20 +368,13 @@ mod tests {
         let fee_rate = FeeRate::from_sat_per_kwu(fee_rate);
         let lt_fee_rate = FeeRate::from_sat_per_kwu(lt_fee_rate);
 
-        let w_utxos: Vec<_> = p
-            .weighted_utxos
-            .iter()
-            .map(|s| Amount::from_str(s).unwrap())
-            .map(|a| Utxo::new(a, Weight::ZERO))
-            .collect();
-
-        let iter = select_coins_bnb(target, cost_of_change, fee_rate, lt_fee_rate, &w_utxos);
+        let pool: UtxoPool = UtxoPool::from_str_list(&p.weighted_utxos);
+        let iter = select_coins_bnb(target, cost_of_change, fee_rate, lt_fee_rate, &pool.utxos);
 
         if let Some(i) = iter {
             let inputs: Vec<Utxo> = i.cloned().collect();
-            let expected_inputs: Vec<Utxo> =
-                expected_inputs.unwrap().iter().map(|s| Utxo::from_str(s).unwrap()).collect();
-            assert_eq!(expected_inputs, inputs);
+            let expected_inputs: UtxoPool = UtxoPool::from_str_list(expected_inputs_str.unwrap());
+            assert_eq!(expected_inputs.utxos, inputs);
         }
     }
 

src/lib.rs

@@ -161,6 +161,15 @@ mod tests {
         pub utxos: Vec<Utxo>,
     }
 
+    impl UtxoPool {
+        pub fn new(utxos: Vec<Utxo>) -> UtxoPool { UtxoPool { utxos } }
+
+        pub fn from_str_list(list: &[&str]) -> UtxoPool {
+            let utxos: Vec<Utxo> = list.iter().map(|s| Utxo::from_str(s).unwrap()).collect();
+            Self::new(utxos)
+        }
+    }
+
     impl WeightedUtxo for Utxo {
         fn satisfaction_weight(&self) -> Weight { self.satisfaction_weight }
         fn value(&self) -> Amount { self.output.value }

src/single_random_draw.rs

@@ -86,15 +86,14 @@ mod tests {
 
     use arbitrary::Arbitrary;
     use arbtest::arbtest;
-    use bitcoin::{Amount, Weight};
+    use bitcoin::Amount;
     use rand::rngs::mock::StepRng;
 
     use super::*;
     use crate::single_random_draw::select_coins_srd;
     use crate::tests::{assert_proptest_srd, Utxo, UtxoPool};
 
     const FEE_RATE: FeeRate = FeeRate::from_sat_per_kwu(10);
-    const SATISFACTION_WEIGHT: Weight = Weight::from_wu(204);
 
     #[derive(Debug)]
     pub struct ParamsStr<'a> {
@@ -103,17 +102,9 @@ mod tests {
         weighted_utxos: Vec<&'a str>,
     }
 
-    fn build_pool() -> Vec<Utxo> {
-        let amts = vec![Amount::from_str("1 cBTC").unwrap(), Amount::from_str("2 cBTC").unwrap()];
-
-        let mut pool = vec![];
-
-        for a in amts {
-            let utxo = Utxo::new(a, SATISFACTION_WEIGHT);
-            pool.push(utxo);
-        }
-
-        pool
+    fn build_pool() -> UtxoPool {
+        let utxo_str_list = vec!["1 cBTC/204 wu", "2 cBTC/204 wu"];
+        UtxoPool::from_str_list(&utxo_str_list)
     }
 
     fn get_rng() -> StepRng {
@@ -135,30 +126,28 @@ mod tests {
                                                            // from_str like Amount::from_str()
         let target = Amount::from_str(p.target).unwrap();
         let fee_rate = FeeRate::from_sat_per_kwu(fee_rate);
-        let w_utxos: Vec<Utxo> =
-            p.weighted_utxos.iter().map(|s| Utxo::from_str(s).unwrap()).collect();
-        let result = select_coins_srd(target, fee_rate, &w_utxos, &mut get_rng());
+
+        let pool: UtxoPool = UtxoPool::from_str_list(&p.weighted_utxos);
+        let result = select_coins_srd(target, fee_rate, &pool.utxos, &mut get_rng());
 
         if let Some(r) = result {
             let inputs: Vec<Utxo> = r.cloned().collect();
-            let expected_inputs: Vec<Utxo> =
-                expected_inputs_str.unwrap().iter().map(|s| Utxo::from_str(s).unwrap()).collect();
-            assert_eq!(inputs, expected_inputs);
+            let expected_pool: UtxoPool = UtxoPool::from_str_list(expected_inputs_str.unwrap());
+            assert_eq!(inputs, expected_pool.utxos);
         }
     }
 
     fn assert_coin_select(target_str: &str, expected_inputs_str: &[&str]) {
         let target = Amount::from_str(target_str).unwrap();
         let pool = build_pool();
 
-        let inputs: Vec<Utxo> = select_coins_srd(target, FEE_RATE, &pool, &mut get_rng())
+        let inputs: Vec<Utxo> = select_coins_srd(target, FEE_RATE, &pool.utxos, &mut get_rng())
             .expect("unexpected error")
             .cloned()
             .collect();
 
-        let expected_inputs: Vec<_> =
-            expected_inputs_str.iter().map(|s| Utxo::from_str(s).unwrap()).collect();
-        assert_eq!(expected_inputs, inputs);
+        let expected_pool: UtxoPool = UtxoPool::from_str_list(expected_inputs_str);
+        assert_eq!(inputs, expected_pool.utxos);
     }
 
     #[test]