Relicense as dual Apache-2.0 + MIT

[rust-lightning] / lightning / src / util / test_utils.rs

diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs
index e426ec2d340a6967955016352a6b78aa8e09569c..d684e9c07b5fce335d893e8b93ee5cdb698b7d7a 100644 (file)
--- a/lightning/src/util/test_utils.rs
+++ b/lightning/src/util/test_utils.rs
@@ -1,3 +1,12 @@
+// This file is Copyright its original authors, visible in version control
+// history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
 use chain::chaininterface;
 use chain::chaininterface::{ConfirmationTarget, ChainError, ChainWatchInterface};
 use chain::transaction::OutPoint;
@@ -5,6 +14,7 @@ use chain::keysinterface;
 use ln::channelmonitor;
 use ln::features::{ChannelFeatures, InitFeatures};
 use ln::msgs;
+use ln::msgs::OptionalField;
 use ln::channelmonitor::HTLCUpdate;
 use util::enforcing_trait_impls::EnforcingChannelKeys;
 use util::events;
@@ -22,7 +32,9 @@ use bitcoin::hash_types::{Txid, BlockHash};
 
 use bitcoin::secp256k1::{SecretKey, PublicKey, Secp256k1, Signature};
 
-use std::time::{SystemTime, UNIX_EPOCH};
+use regex;
+
+use std::time::Duration;
 use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::{cmp, mem};
@@ -40,10 +52,10 @@ impl Writer for TestVecWriter {
 }
 
 pub struct TestFeeEstimator {
-       pub sat_per_kw: u64,
+       pub sat_per_kw: u32,
 }
 impl chaininterface::FeeEstimator for TestFeeEstimator {
-       fn get_est_sat_per_1000_weight(&self, _confirmation_target: ConfirmationTarget) -> u64 {
+       fn get_est_sat_per_1000_weight(&self, _confirmation_target: ConfirmationTarget) -> u32 {
                self.sat_per_kw
        }
 }
@@ -214,6 +226,7 @@ fn get_dummy_channel_update(short_chan_id: u64) -> msgs::ChannelUpdate {
                        flags: 0,
                        cltv_expiry_delta: 0,
                        htlc_minimum_msat: 0,
+                       htlc_maximum_msat: OptionalField::Absent,
                        fee_base_msat: 0,
                        fee_proportional_millionths: 0,
                        excess_data: vec![],
@@ -240,15 +253,15 @@ impl TestRoutingMessageHandler {
 }
 impl msgs::RoutingMessageHandler for TestRoutingMessageHandler {
        fn handle_node_announcement(&self, _msg: &msgs::NodeAnnouncement) -> Result<bool, msgs::LightningError> {
-               Err(msgs::LightningError { err: "", action: msgs::ErrorAction::IgnoreError })
+               Err(msgs::LightningError { err: "".to_owned(), action: msgs::ErrorAction::IgnoreError })
        }
        fn handle_channel_announcement(&self, _msg: &msgs::ChannelAnnouncement) -> Result<bool, msgs::LightningError> {
                self.chan_anns_recvd.fetch_add(1, Ordering::AcqRel);
-               Err(msgs::LightningError { err: "", action: msgs::ErrorAction::IgnoreError })
+               Err(msgs::LightningError { err: "".to_owned(), action: msgs::ErrorAction::IgnoreError })
        }
        fn handle_channel_update(&self, _msg: &msgs::ChannelUpdate) -> Result<bool, msgs::LightningError> {
                self.chan_upds_recvd.fetch_add(1, Ordering::AcqRel);
-               Err(msgs::LightningError { err: "", action: msgs::ErrorAction::IgnoreError })
+               Err(msgs::LightningError { err: "".to_owned(), action: msgs::ErrorAction::IgnoreError })
        }
        fn handle_htlc_fail_channel_update(&self, _update: &msgs::HTLCFailChannelUpdate) {}
        fn get_next_channel_announcements(&self, starting_point: u64, batch_amount: u8) -> Vec<(msgs::ChannelAnnouncement, Option<msgs::ChannelUpdate>, Option<msgs::ChannelUpdate>)> {
@@ -300,6 +313,30 @@ impl TestLogger {
                let log_entries = self.lines.lock().unwrap();
                assert_eq!(log_entries.get(&(module, line)), Some(&count));
        }
+
+       /// Search for the number of occurrence of the logged lines which
+       /// 1. belongs to the specified module and
+       /// 2. contains `line` in it.
+       /// And asserts if the number of occurrences is the same with the given `count`
+       pub fn assert_log_contains(&self, module: String, line: String, count: usize) {
+               let log_entries = self.lines.lock().unwrap();
+               let l: usize = log_entries.iter().filter(|&(&(ref m, ref l), _c)| {
+                       m == &module && l.contains(line.as_str())
+               }).map(|(_, c) | { c }).sum();
+               assert_eq!(l, count)
+       }
+
+    /// Search for the number of occurrences of logged lines which
+    /// 1. belong to the specified module and
+    /// 2. match the given regex pattern.
+    /// Assert that the number of occurrences equals the given `count`
+       pub fn assert_log_regex(&self, module: String, pattern: regex::Regex, count: usize) {
+               let log_entries = self.lines.lock().unwrap();
+               let l: usize = log_entries.iter().filter(|&(&(ref m, ref l), _c)| {
+                       m == &module && pattern.is_match(&l)
+               }).map(|(_, c) | { c }).sum();
+               assert_eq!(l, count)
+       }
 }
 
 impl Logger for TestLogger {
@@ -344,13 +381,16 @@ impl keysinterface::KeysInterface for TestKeysInterface {
 
 impl TestKeysInterface {
        pub fn new(seed: &[u8; 32], network: Network) -> Self {
-               let now = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time went backwards");
+               let now = Duration::from_secs(genesis_block(network).header.time as u64);
                Self {
                        backing: keysinterface::KeysManager::new(seed, network, now.as_secs(), now.subsec_nanos()),
                        override_session_priv: Mutex::new(None),
                        override_channel_id_priv: Mutex::new(None),
                }
        }
+       pub fn derive_channel_keys(&self, channel_value_satoshis: u64, user_id_1: u64, user_id_2: u64) -> EnforcingChannelKeys {
+               EnforcingChannelKeys::new(self.backing.derive_channel_keys(channel_value_satoshis, user_id_1, user_id_2))
+       }
 }
 
 pub struct TestChainWatcher {
@@ -368,8 +408,8 @@ impl ChainWatchInterface for TestChainWatcher {
        fn install_watch_tx(&self, _txid: &Txid, _script_pub_key: &Script) { }
        fn install_watch_outpoint(&self, _outpoint: (Txid, u32), _out_script: &Script) { }
        fn watch_all_txn(&self) { }
-       fn filter_block<'a>(&self, _block: &'a Block) -> (Vec<&'a Transaction>, Vec<u32>) {
-               (Vec::new(), Vec::new())
+       fn filter_block<'a>(&self, _block: &'a Block) -> Vec<usize> {
+               Vec::new()
        }
        fn reentered(&self) -> usize { 0 }