X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Ftest_utils.rs;h=9af8d5cf2f3d92db21ab81a775ae4b1b03ad8860;hb=8829d1b80f99aa9bb34a5132a380b1d5dc7e303a;hp=c3884d345eebc3a013bff303cf7cdbd9fb83d80a;hpb=126b514168ff8294f6ee7b9573797c6759512b9c;p=rust-lightning diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs index c3884d34..9af8d5cf 100644 --- a/lightning/src/util/test_utils.rs +++ b/lightning/src/util/test_utils.rs @@ -3,13 +3,14 @@ use chain::chaininterface::ConfirmationTarget; use chain::transaction::OutPoint; use chain::keysinterface; use ln::channelmonitor; +use ln::features::InitFeatures; use ln::msgs; -use ln::msgs::LocalFeatures; -use ln::msgs::{LightningError}; +use ln::msgs::LightningError; use ln::channelmonitor::HTLCUpdate; +use util::enforcing_trait_impls::EnforcingChannelKeys; use util::events; use util::logger::{Logger, Level, Record}; -use util::ser::{ReadableArgs, Writer}; +use util::ser::{Readable, ReadableArgs, Writer, Writeable}; use bitcoin::blockdata::transaction::Transaction; use bitcoin::blockdata::script::Script; @@ -21,6 +22,7 @@ use secp256k1::{SecretKey, PublicKey}; use std::time::{SystemTime, UNIX_EPOCH}; use std::sync::{Arc,Mutex}; use std::{mem}; +use std::collections::{HashMap, HashSet}; pub struct TestVecWriter(pub Vec); impl Writer for TestVecWriter { @@ -42,45 +44,83 @@ impl chaininterface::FeeEstimator for TestFeeEstimator { } } -pub struct TestChannelMonitor { - pub added_monitors: Mutex>, - pub simple_monitor: Arc>, +pub struct TestChannelMonitor<'a> { + pub added_monitors: Mutex)>>, + pub latest_monitor_update_id: Mutex>, + pub simple_monitor: channelmonitor::SimpleManyChannelMonitor, pub update_ret: Mutex>, } -impl TestChannelMonitor { - pub fn new(chain_monitor: Arc, broadcaster: Arc, logger: Arc, fee_estimator: Arc) -> Self { +impl<'a> TestChannelMonitor<'a> { + pub fn new(chain_monitor: Arc, broadcaster: &'a chaininterface::BroadcasterInterface, logger: Arc, fee_estimator: &'a TestFeeEstimator) -> Self { Self { added_monitors: Mutex::new(Vec::new()), + latest_monitor_update_id: Mutex::new(HashMap::new()), simple_monitor: channelmonitor::SimpleManyChannelMonitor::new(chain_monitor, broadcaster, logger, fee_estimator), update_ret: Mutex::new(Ok(())), } } } -impl channelmonitor::ManyChannelMonitor for TestChannelMonitor { - fn add_update_monitor(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> { +impl<'a> channelmonitor::ManyChannelMonitor for TestChannelMonitor<'a> { + fn add_monitor(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> { // At every point where we get a monitor update, we should be able to send a useful monitor // to a watchtower and disk... let mut w = TestVecWriter(Vec::new()); monitor.write_for_disk(&mut w).unwrap(); - assert!(<(Sha256dHash, channelmonitor::ChannelMonitor)>::read( - &mut ::std::io::Cursor::new(&w.0), Arc::new(TestLogger::new())).unwrap().1 == monitor); + let new_monitor = <(Sha256dHash, channelmonitor::ChannelMonitor)>::read( + &mut ::std::io::Cursor::new(&w.0), Arc::new(TestLogger::new())).unwrap().1; + assert!(new_monitor == monitor); w.0.clear(); monitor.write_for_watchtower(&mut w).unwrap(); // This at least shouldn't crash... - self.added_monitors.lock().unwrap().push((funding_txo, monitor.clone())); - assert!(self.simple_monitor.add_update_monitor(funding_txo, monitor).is_ok()); + 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.add_monitor(funding_txo, new_monitor).is_ok()); self.update_ret.lock().unwrap().clone() } - fn fetch_pending_htlc_updated(&self) -> Vec { - return self.simple_monitor.fetch_pending_htlc_updated(); + fn update_monitor(&self, funding_txo: OutPoint, update: channelmonitor::ChannelMonitorUpdate) -> Result<(), channelmonitor::ChannelMonitorUpdateErr> { + // Every monitor update should survive roundtrip + let mut w = TestVecWriter(Vec::new()); + update.write(&mut w).unwrap(); + assert!(channelmonitor::ChannelMonitorUpdate::read( + &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_monitor(funding_txo, update).is_ok()); + // 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 monitor = monitors.get(&funding_txo).unwrap(); + w.0.clear(); + monitor.write_for_disk(&mut w).unwrap(); + let new_monitor = <(Sha256dHash, channelmonitor::ChannelMonitor)>::read( + &mut ::std::io::Cursor::new(&w.0), Arc::new(TestLogger::new())).unwrap().1; + assert!(new_monitor == *monitor); + w.0.clear(); + monitor.write_for_watchtower(&mut w).unwrap(); // This at least shouldn't crash... + self.added_monitors.lock().unwrap().push((funding_txo, new_monitor)); + self.update_ret.lock().unwrap().clone() + } + + fn get_and_clear_pending_htlcs_updated(&self) -> Vec { + return self.simple_monitor.get_and_clear_pending_htlcs_updated(); } } pub struct TestBroadcaster { pub txn_broadcasted: Mutex>, + pub broadcasted_txn: Mutex> // Temporary field while refactoring out tx duplication } impl chaininterface::BroadcasterInterface for TestBroadcaster { fn broadcast_transaction(&self, tx: &Transaction) { + { + if let Some(_) = self.broadcasted_txn.lock().unwrap().get(&tx.txid()) { + // If commitment tx, HTLC-timeout or HTLC-Success, duplicate broadcast are still ok + if tx.input[0].sequence == 0xfffffffd { + return; + } + } + } + self.broadcasted_txn.lock().unwrap().insert(tx.txid()); self.txn_broadcasted.lock().unwrap().push(tx.clone()); } } @@ -98,56 +138,24 @@ impl TestChannelMessageHandler { } impl msgs::ChannelMessageHandler for TestChannelMessageHandler { - fn handle_open_channel(&self, _their_node_id: &PublicKey, _their_local_features: LocalFeatures, _msg: &msgs::OpenChannel) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_accept_channel(&self, _their_node_id: &PublicKey, _their_local_features: LocalFeatures, _msg: &msgs::AcceptChannel) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_funding_created(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingCreated) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_funding_signed(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingSigned) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_funding_locked(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingLocked) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_shutdown(&self, _their_node_id: &PublicKey, _msg: &msgs::Shutdown) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_closing_signed(&self, _their_node_id: &PublicKey, _msg: &msgs::ClosingSigned) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_update_add_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateAddHTLC) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_update_fulfill_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFulfillHTLC) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_update_fail_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFailHTLC) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_update_fail_malformed_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFailMalformedHTLC) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_commitment_signed(&self, _their_node_id: &PublicKey, _msg: &msgs::CommitmentSigned) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_revoke_and_ack(&self, _their_node_id: &PublicKey, _msg: &msgs::RevokeAndACK) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_update_fee(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFee) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_announcement_signatures(&self, _their_node_id: &PublicKey, _msg: &msgs::AnnouncementSignatures) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } - fn handle_channel_reestablish(&self, _their_node_id: &PublicKey, _msg: &msgs::ChannelReestablish) -> Result<(), LightningError> { - Err(LightningError { err: "", action: msgs::ErrorAction::IgnoreError }) - } + fn handle_open_channel(&self, _their_node_id: &PublicKey, _their_features: InitFeatures, _msg: &msgs::OpenChannel) {} + fn handle_accept_channel(&self, _their_node_id: &PublicKey, _their_features: InitFeatures, _msg: &msgs::AcceptChannel) {} + fn handle_funding_created(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingCreated) {} + fn handle_funding_signed(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingSigned) {} + fn handle_funding_locked(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingLocked) {} + fn handle_shutdown(&self, _their_node_id: &PublicKey, _msg: &msgs::Shutdown) {} + fn handle_closing_signed(&self, _their_node_id: &PublicKey, _msg: &msgs::ClosingSigned) {} + fn handle_update_add_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateAddHTLC) {} + fn handle_update_fulfill_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFulfillHTLC) {} + fn handle_update_fail_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFailHTLC) {} + fn handle_update_fail_malformed_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFailMalformedHTLC) {} + fn handle_commitment_signed(&self, _their_node_id: &PublicKey, _msg: &msgs::CommitmentSigned) {} + fn handle_revoke_and_ack(&self, _their_node_id: &PublicKey, _msg: &msgs::RevokeAndACK) {} + fn handle_update_fee(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFee) {} + fn handle_announcement_signatures(&self, _their_node_id: &PublicKey, _msg: &msgs::AnnouncementSignatures) {} + fn handle_channel_reestablish(&self, _their_node_id: &PublicKey, _msg: &msgs::ChannelReestablish) {} fn peer_disconnected(&self, _their_node_id: &PublicKey, _no_connection_possible: bool) {} - fn peer_connected(&self, _their_node_id: &PublicKey) {} + fn peer_connected(&self, _their_node_id: &PublicKey, _msg: &msgs::Init) {} fn handle_error(&self, _their_node_id: &PublicKey, _msg: &msgs::ErrorMessage) {} } @@ -184,11 +192,15 @@ impl msgs::RoutingMessageHandler for TestRoutingMessageHandler { fn get_next_node_announcements(&self, _starting_point: Option<&PublicKey>, _batch_amount: u8) -> Vec { Vec::new() } + fn should_request_full_sync(&self, _node_id: &PublicKey) -> bool { + true + } } pub struct TestLogger { level: Level, id: String, + pub lines: Mutex>, } impl TestLogger { @@ -199,15 +211,21 @@ impl TestLogger { TestLogger { level: Level::Trace, id, + lines: Mutex::new(HashMap::new()) } } pub fn enable(&mut self, level: Level) { self.level = level; } + pub fn assert_log(&self, module: String, line: String, count: usize) { + let log_entries = self.lines.lock().unwrap(); + assert_eq!(log_entries.get(&(module, line)), Some(&count)); + } } impl Logger for TestLogger { fn log(&self, record: &Record) { + *self.lines.lock().unwrap().entry((record.module_path.to_string(), format!("{}", record.args))).or_insert(0) += 1; if self.level >= record.level { println!("{:<5} {} [{} : {}, {}] {}", record.level.to_string(), self.id, record.module_path, record.file, record.line, record.args); } @@ -221,15 +239,19 @@ pub struct TestKeysInterface { } impl keysinterface::KeysInterface for TestKeysInterface { + type ChanKeySigner = EnforcingChannelKeys; + fn get_node_secret(&self) -> SecretKey { self.backing.get_node_secret() } fn get_destination_script(&self) -> Script { self.backing.get_destination_script() } fn get_shutdown_pubkey(&self) -> PublicKey { self.backing.get_shutdown_pubkey() } - fn get_channel_keys(&self, inbound: bool) -> keysinterface::ChannelKeys { self.backing.get_channel_keys(inbound) } + fn get_channel_keys(&self, inbound: bool, channel_value_satoshis: u64) -> EnforcingChannelKeys { + EnforcingChannelKeys::new(self.backing.get_channel_keys(inbound, channel_value_satoshis)) + } - fn get_session_key(&self) -> SecretKey { + fn get_onion_rand(&self) -> (SecretKey, [u8; 32]) { match *self.override_session_priv.lock().unwrap() { - Some(key) => key.clone(), - None => self.backing.get_session_key() + Some(key) => (key.clone(), [0; 32]), + None => self.backing.get_onion_rand() } }