Implement Clone, Hash, PartialEq for ClosingTransaction

[rust-lightning] / lightning / src / ln / functional_test_utils.rs

diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs
index e6b2467077422a974eff3657c1ae6a2d0c615f97..bf3e192b252b3d7fd14fbc542d16c313304279ad 100644 (file)
--- a/lightning/src/ln/functional_test_utils.rs
+++ b/lightning/src/ln/functional_test_utils.rs
@@ -707,6 +707,14 @@ pub fn update_nodes_with_chan_announce<'a, 'b, 'c, 'd>(nodes: &'a Vec<Node<'b, '
 macro_rules! check_spends {
        ($tx: expr, $($spends_txn: expr),*) => {
                {
+                       $(
+                       for outp in $spends_txn.output.iter() {
+                               assert!(outp.value >= outp.script_pubkey.dust_value().as_sat(), "Input tx output didn't meet dust limit");
+                       }
+                       )*
+                       for outp in $tx.output.iter() {
+                               assert!(outp.value >= outp.script_pubkey.dust_value().as_sat(), "Spending tx output didn't meet dust limit");
+                       }
                        let get_output = |out_point: &bitcoin::blockdata::transaction::OutPoint| {
                                $(
                                        if out_point.txid == $spends_txn.txid() {
@@ -999,7 +1007,7 @@ macro_rules! get_payment_preimage_hash {
                        let payment_preimage = PaymentPreimage([*payment_count; 32]);
                        *payment_count += 1;
                        let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner());
-                       let payment_secret = $dest_node.node.create_inbound_payment_for_hash(payment_hash, $min_value_msat, 7200, 0).unwrap();
+                       let payment_secret = $dest_node.node.create_inbound_payment_for_hash(payment_hash, $min_value_msat, 7200).unwrap();
                        (payment_preimage, payment_hash, payment_secret)
                }
        }
@@ -1079,24 +1087,65 @@ macro_rules! expect_payment_received {
        }
 }
 
+#[cfg(test)]
+macro_rules! expect_payment_sent_without_paths {
+       ($node: expr, $expected_payment_preimage: expr) => {
+               expect_payment_sent!($node, $expected_payment_preimage, None::<u64>, false);
+       };
+       ($node: expr, $expected_payment_preimage: expr, $expected_fee_msat_opt: expr) => {
+               expect_payment_sent!($node, $expected_payment_preimage, $expected_fee_msat_opt, false);
+       }
+}
+
 macro_rules! expect_payment_sent {
        ($node: expr, $expected_payment_preimage: expr) => {
-               expect_payment_sent!($node, $expected_payment_preimage, None::<u64>);
+               expect_payment_sent!($node, $expected_payment_preimage, None::<u64>, true);
        };
        ($node: expr, $expected_payment_preimage: expr, $expected_fee_msat_opt: expr) => {
+               expect_payment_sent!($node, $expected_payment_preimage, $expected_fee_msat_opt, true);
+       };
+       ($node: expr, $expected_payment_preimage: expr, $expected_fee_msat_opt: expr, $expect_paths: expr) => {
                let events = $node.node.get_and_clear_pending_events();
                let expected_payment_hash = PaymentHash(Sha256::hash(&$expected_payment_preimage.0).into_inner());
-               assert_eq!(events.len(), 1);
-               match events[0] {
-                       Event::PaymentSent { payment_id: _, ref payment_preimage, ref payment_hash, ref fee_paid_msat } => {
+               if $expect_paths {
+                       assert!(events.len() > 1);
+               } else {
+                       assert_eq!(events.len(), 1);
+               }
+               let expected_payment_id = match events[0] {
+                       Event::PaymentSent { ref payment_id, ref payment_preimage, ref payment_hash, ref fee_paid_msat } => {
                                assert_eq!($expected_payment_preimage, *payment_preimage);
                                assert_eq!(expected_payment_hash, *payment_hash);
                                assert!(fee_paid_msat.is_some());
                                if $expected_fee_msat_opt.is_some() {
                                        assert_eq!(*fee_paid_msat, $expected_fee_msat_opt);
                                }
+                               payment_id.unwrap()
                        },
                        _ => panic!("Unexpected event"),
+               };
+               if $expect_paths {
+                       for i in 1..events.len() {
+                               match events[i] {
+                                       Event::PaymentPathSuccessful { payment_id, payment_hash, .. } => {
+                                               assert_eq!(payment_id, expected_payment_id);
+                                               assert_eq!(payment_hash, Some(expected_payment_hash));
+                                       },
+                                       _ => panic!("Unexpected event"),
+                               }
+                       }
+               }
+       }
+}
+
+#[cfg(test)]
+macro_rules! expect_payment_path_successful {
+       ($node: expr) => {
+               let events = $node.node.get_and_clear_pending_events();
+               assert_eq!(events.len(), 1);
+               match events[0] {
+                       Event::PaymentPathSuccessful { .. } => {},
+                       _ => panic!("Unexpected event"),
                }
        }
 }
@@ -1737,7 +1786,7 @@ pub fn handle_announce_close_broadcast_events<'a, 'b, 'c>(nodes: &Vec<Node<'a, '
 }
 
 pub fn get_announce_close_broadcast_events<'a, 'b, 'c>(nodes: &Vec<Node<'a, 'b, 'c>>, a: usize, b: usize)  {
-       handle_announce_close_broadcast_events(nodes, a, b, false, "Commitment or closing transaction was confirmed on chain.");
+       handle_announce_close_broadcast_events(nodes, a, b, false, "Channel closed because commitment or closing transaction was confirmed on chain.");
 }
 
 #[cfg(test)]