X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Ftest_utils.rs;h=5e6b5fff53c7de5f8282694364f696df293245f3;hb=a8e82cb3fbd40e6d3c23ad633205c2e6376d564a;hp=295636e33a222555f8aa273ced12718dac2131e5;hpb=801b775a7d17eff165ea5e8a4d11a966e0ef29d0;p=rust-lightning diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs index 295636e3..5e6b5fff 100644 --- a/lightning/src/util/test_utils.rs +++ b/lightning/src/util/test_utils.rs @@ -10,13 +10,14 @@ use chain; use chain::chaininterface; use chain::chaininterface::ConfirmationTarget; +use chain::chainmonitor; +use chain::channelmonitor; +use chain::channelmonitor::MonitorEvent; use chain::transaction::OutPoint; use chain::keysinterface; -use ln::channelmonitor; use ln::features::{ChannelFeatures, InitFeatures}; use ln::msgs; use ln::msgs::OptionalField; -use ln::channelmonitor::MonitorEvent; use util::enforcing_trait_impls::EnforcingChannelKeys; use util::events; use util::logger::{Logger, Level, Record}; @@ -27,7 +28,7 @@ use bitcoin::blockdata::transaction::{Transaction, TxOut}; use bitcoin::blockdata::script::{Builder, Script}; use bitcoin::blockdata::opcodes; use bitcoin::network::constants::Network; -use bitcoin::hash_types::BlockHash; +use bitcoin::hash_types::{BlockHash, Txid}; use bitcoin::secp256k1::{SecretKey, PublicKey, Secp256k1, Signature}; @@ -37,7 +38,7 @@ use std::time::Duration; use std::sync::Mutex; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use std::{cmp, mem}; -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; pub struct TestVecWriter(pub Vec); impl Writer for TestVecWriter { @@ -59,27 +60,27 @@ impl chaininterface::FeeEstimator for TestFeeEstimator { } } -pub struct TestChannelMonitor<'a> { +pub struct TestChainMonitor<'a> { pub added_monitors: Mutex)>>, pub latest_monitor_update_id: Mutex>, - pub simple_monitor: channelmonitor::SimpleManyChannelMonitor, - pub update_ret: Mutex>, + pub chain_monitor: chainmonitor::ChainMonitor>, + pub update_ret: Mutex>>, // If this is set to Some(), after the next return, we'll always return this until update_ret // is changed: pub next_update_ret: Mutex>>, } -impl<'a> TestChannelMonitor<'a> { - pub fn new(broadcaster: &'a chaininterface::BroadcasterInterface, logger: &'a TestLogger, fee_estimator: &'a TestFeeEstimator) -> Self { +impl<'a> TestChainMonitor<'a> { + pub fn new(chain_source: Option<&'a TestChainSource>, broadcaster: &'a chaininterface::BroadcasterInterface, logger: &'a TestLogger, fee_estimator: &'a TestFeeEstimator, persister: &'a channelmonitor::Persist) -> Self { Self { added_monitors: Mutex::new(Vec::new()), latest_monitor_update_id: Mutex::new(HashMap::new()), - simple_monitor: channelmonitor::SimpleManyChannelMonitor::new(broadcaster, logger, fee_estimator), - update_ret: Mutex::new(Ok(())), + chain_monitor: chainmonitor::ChainMonitor::new(chain_source, broadcaster, logger, fee_estimator, persister), + update_ret: Mutex::new(None), next_update_ret: Mutex::new(None), } } } -impl<'a> chain::Watch for TestChannelMonitor<'a> { +impl<'a> chain::Watch for TestChainMonitor<'a> { type Keys = EnforcingChannelKeys; fn watch_channel(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> { @@ -92,13 +93,17 @@ impl<'a> chain::Watch for TestChannelMonitor<'a> { assert!(new_monitor == monitor); self.latest_monitor_update_id.lock().unwrap().insert(funding_txo.to_channel_id(), (funding_txo, monitor.get_latest_update_id())); self.added_monitors.lock().unwrap().push((funding_txo, monitor)); - assert!(self.simple_monitor.watch_channel(funding_txo, new_monitor).is_ok()); + let watch_res = self.chain_monitor.watch_channel(funding_txo, new_monitor); let ret = self.update_ret.lock().unwrap().clone(); if let Some(next_ret) = self.next_update_ret.lock().unwrap().take() { - *self.update_ret.lock().unwrap() = next_ret; + *self.update_ret.lock().unwrap() = Some(next_ret); } - ret + if ret.is_some() { + assert!(watch_res.is_ok()); + return ret.unwrap(); + } + watch_res } fn update_channel(&self, funding_txo: OutPoint, update: channelmonitor::ChannelMonitorUpdate) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> { @@ -109,27 +114,55 @@ impl<'a> chain::Watch for TestChannelMonitor<'a> { &mut ::std::io::Cursor::new(&w.0)).unwrap() == update); self.latest_monitor_update_id.lock().unwrap().insert(funding_txo.to_channel_id(), (funding_txo, update.update_id)); - assert!(self.simple_monitor.update_channel(funding_txo, update).is_ok()); + let update_res = self.chain_monitor.update_channel(funding_txo, update); // At every point where we get a monitor update, we should be able to send a useful monitor // to a watchtower and disk... - let monitors = self.simple_monitor.monitors.lock().unwrap(); + let monitors = self.chain_monitor.monitors.lock().unwrap(); let monitor = monitors.get(&funding_txo).unwrap(); w.0.clear(); monitor.write_for_disk(&mut w).unwrap(); let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor)>::read( - &mut ::std::io::Cursor::new(&w.0)).unwrap().1; + &mut ::std::io::Cursor::new(&w.0)).unwrap().1; assert!(new_monitor == *monitor); self.added_monitors.lock().unwrap().push((funding_txo, new_monitor)); let ret = self.update_ret.lock().unwrap().clone(); if let Some(next_ret) = self.next_update_ret.lock().unwrap().take() { - *self.update_ret.lock().unwrap() = next_ret; + *self.update_ret.lock().unwrap() = Some(next_ret); } - ret + if ret.is_some() { + assert!(update_res.is_ok()); + return ret.unwrap(); + } + update_res } fn release_pending_monitor_events(&self) -> Vec { - return self.simple_monitor.release_pending_monitor_events(); + return self.chain_monitor.release_pending_monitor_events(); + } +} + +pub struct TestPersister { + pub update_ret: Mutex> +} +impl TestPersister { + pub fn new() -> Self { + Self { + update_ret: Mutex::new(Ok(())) + } + } + + pub fn set_update_ret(&self, ret: Result<(), channelmonitor::ChannelMonitorUpdateErr>) { + *self.update_ret.lock().unwrap() = ret; + } +} +impl channelmonitor::Persist for TestPersister { + fn persist_new_channel(&self, _funding_txo: OutPoint, _data: &channelmonitor::ChannelMonitor) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> { + self.update_ret.lock().unwrap().clone() + } + + fn update_persisted_channel(&self, _funding_txo: OutPoint, _update: &channelmonitor::ChannelMonitorUpdate, _data: &channelmonitor::ChannelMonitor) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> { + self.update_ret.lock().unwrap().clone() } } @@ -396,6 +429,8 @@ impl TestKeysInterface { pub struct TestChainSource { pub genesis_hash: BlockHash, pub utxo_ret: Mutex>, + pub watched_txn: Mutex>, + pub watched_outputs: Mutex>, } impl TestChainSource { @@ -404,6 +439,8 @@ impl TestChainSource { Self { genesis_hash: genesis_block(network).block_hash(), utxo_ret: Mutex::new(Ok(TxOut { value: u64::max_value(), script_pubkey })), + watched_txn: Mutex::new(HashSet::new()), + watched_outputs: Mutex::new(HashSet::new()), } } } @@ -417,3 +454,13 @@ impl chain::Access for TestChainSource { self.utxo_ret.lock().unwrap().clone() } } + +impl chain::Filter for TestChainSource { + fn register_tx(&self, txid: &Txid, script_pubkey: &Script) { + self.watched_txn.lock().unwrap().insert((*txid, script_pubkey.clone())); + } + + fn register_output(&self, outpoint: &OutPoint, script_pubkey: &Script) { + self.watched_outputs.lock().unwrap().insert((*outpoint, script_pubkey.clone())); + } +}