Add assert_log method to TestLogger to harden test

[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 2745bae1dbfe39d4008b7b5c997cc50bbfdd038c..e99e96097aade150ee0ffed542ef7ce5ec72098b 100644 (file)
--- a/lightning/src/ln/functional_test_utils.rs
+++ b/lightning/src/ln/functional_test_utils.rs
@@ -8,6 +8,7 @@ use ln::channelmanager::{ChannelManager,RAACommitmentOrder, PaymentPreimage, Pay
 use ln::router::{Route, Router};
 use ln::msgs;
 use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler, LocalFeatures};
+use util::enforcing_trait_impls::EnforcingChannelKeys;
 use util::test_utils;
 use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
 use util::errors::APIError;
@@ -55,16 +56,17 @@ pub fn connect_blocks(notifier: &chaininterface::BlockNotifier, depth: u32, heig
 }
 
 pub struct Node {
-       pub block_notifier: Arc<chaininterface::BlockNotifier<'a, 'b>>,
+       pub block_notifier: Arc<chaininterface::BlockNotifier>,
        pub chain_monitor: Arc<chaininterface::ChainWatchInterfaceUtil>,
        pub tx_broadcaster: Arc<test_utils::TestBroadcaster>,
        pub chan_monitor: Arc<test_utils::TestChannelMonitor>,
        pub keys_manager: Arc<test_utils::TestKeysInterface>,
-       pub node: Arc<ChannelManager>,
+       pub node: Arc<ChannelManager<EnforcingChannelKeys>>,
        pub router: Router,
        pub node_seed: [u8; 32],
        pub network_payment_count: Rc<RefCell<u8>>,
        pub network_chan_count: Rc<RefCell<u32>>,
+       pub logger: Arc<test_utils::TestLogger>
 }
 impl Drop for Node {
        fn drop(&mut self) {
@@ -834,7 +836,8 @@ pub fn create_network(node_count: usize, node_config: &[Option<UserConfig>]) ->
        let payment_count = Rc::new(RefCell::new(0));
 
        for i in 0..node_count {
-               let logger: Arc<Logger> = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i)));
+               let test_logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i)));
+               let logger = &(Arc::clone(&test_logger) as Arc<Logger>);
                let feeest = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 });
                let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&logger)));
                let block_notifier = Arc::new(chaininterface::BlockNotifier::new(chain_monitor.clone()));
@@ -845,7 +848,7 @@ pub fn create_network(node_count: usize, node_config: &[Option<UserConfig>]) ->
                let chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor.clone(), tx_broadcaster.clone(), logger.clone(), feeest.clone()));
                let weak_res = Arc::downgrade(&chan_monitor.simple_monitor);
                block_notifier.register_listener(weak_res);
-               let mut default_config = UserConfig::new();
+               let mut default_config = UserConfig::default();
                default_config.channel_options.announced_channel = true;
                default_config.peer_channel_config_limits.force_announced_channel_preference = false;
                let node = ChannelManager::new(Network::Testnet, feeest.clone(), chan_monitor.clone(), tx_broadcaster.clone(), Arc::clone(&logger), keys_manager.clone(), if node_config[i].is_some() { node_config[i].clone().unwrap() } else { default_config }, 0).unwrap();
@@ -856,6 +859,7 @@ pub fn create_network(node_count: usize, node_config: &[Option<UserConfig>]) ->
                        network_payment_count: payment_count.clone(),
                        network_chan_count: chan_count.clone(),
                        block_notifier,
+                       logger: test_logger
                });
        }
 
@@ -920,15 +924,21 @@ pub fn test_txn_broadcast(node: &Node, chan: &(msgs::ChannelUpdate, msgs::Channe
 
 /// Tests that the given node has broadcast a claim transaction against the provided revoked
 /// HTLC transaction.
-pub fn test_revoked_htlc_claim_txn_broadcast(node: &Node, revoked_tx: Transaction) {
+pub fn test_revoked_htlc_claim_txn_broadcast(node: &Node, revoked_tx: Transaction, commitment_revoked_tx: Transaction) {
        let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap();
-       assert_eq!(node_txn.len(), 1);
+       // We should issue a 2nd transaction if one htlc is dropped from initial claiming tx
+       // but sometimes not as feerate is too-low
+       if node_txn.len() != 1 && node_txn.len() != 2 { assert!(false); }
        node_txn.retain(|tx| {
                if tx.input.len() == 1 && tx.input[0].previous_output.txid == revoked_tx.txid() {
-                       check_spends!(tx, revoked_tx.clone());
+                       check_spends!(tx, revoked_tx);
                        false
                } else { true }
        });
+       node_txn.retain(|tx| {
+               check_spends!(tx, commitment_revoked_tx);
+               false
+       });
        assert!(node_txn.is_empty());
 }