Add test coverage ChannelClosed event fields

Author: vladimirfomene

lightning-persister/src/lib.rs

@@ -237,7 +237,7 @@ mod tests {
 		// Force close because cooperative close doesn't result in any persisted
 		// updates.
 		nodes[0].node.force_close_broadcasting_latest_txn(&nodes[0].node.list_channels()[0].channel_id, &nodes[1].node.get_our_node_id()).unwrap();
-		check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed);
+		check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed, nodes[1].node.get_our_node_id(), 100000);
 		check_closed_broadcast!(nodes[0], true);
 		check_added_monitors!(nodes[0], 1);
 
@@ -246,7 +246,7 @@ mod tests {
 
 		connect_block(&nodes[1], &create_dummy_block(nodes[0].best_block_hash(), 42, vec![node_txn[0].clone(), node_txn[0].clone()]));
 		check_closed_broadcast!(nodes[1], true);
-		check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
+		check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, nodes[0].node.get_our_node_id(), 100000);
 		check_added_monitors!(nodes[1], 1);
 
 		// Make sure everything is persisted as expected after close.
@@ -270,7 +270,7 @@ mod tests {
 		let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 		let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
 		nodes[1].node.force_close_broadcasting_latest_txn(&chan.2, &nodes[0].node.get_our_node_id()).unwrap();
-		check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed);
+		check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed, nodes[0].node.get_our_node_id(), 100000);
 		let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
 		let update_map = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap();
 		let update_id = update_map.get(&added_monitors[0].0.to_channel_id()).unwrap();
@@ -309,7 +309,7 @@ mod tests {
 		let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 		let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
 		nodes[1].node.force_close_broadcasting_latest_txn(&chan.2, &nodes[0].node.get_our_node_id()).unwrap();
-		check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed);
+		check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed, nodes[0].node.get_our_node_id(), 100000);
 		let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
 		let update_map = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap();
 		let update_id = update_map.get(&added_monitors[0].0.to_channel_id()).unwrap();

lightning/src/chain/chainmonitor.rs

@@ -966,7 +966,8 @@ mod tests {
 			assert!(err.contains("ChannelMonitor storage failure")));
 		check_added_monitors!(nodes[0], 2); // After the failure we generate a close-channel monitor update
 		check_closed_broadcast!(nodes[0], true);
-		check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "ChannelMonitor storage failure".to_string() });
+		check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "ChannelMonitor storage failure".to_string() }, 
+		nodes[1].node.get_our_node_id(), 100000);
 
 		// However, as the ChainMonitor is still waiting for the original persistence to complete,
 		// it won't yet release the MonitorEvents.
@@ -1013,7 +1014,8 @@ mod tests {
 		// ... however once we get events once, the channel will close, creating a channel-closed
 		// ChannelMonitorUpdate.
 		check_closed_broadcast!(nodes[0], true);
-		check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "Failed to persist ChannelMonitor update during chain sync".to_string() });
+		check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "Failed to persist ChannelMonitor update during chain sync".to_string() },
+			nodes[1].node.get_our_node_id(), 100000);
 		check_added_monitors!(nodes[0], 1);
 	}
 }

lightning/src/chain/channelmonitor.rs

@@ -4274,7 +4274,8 @@ mod tests {
 			assert!(err.contains("ChannelMonitor storage failure")));
 		check_added_monitors!(nodes[1], 2); // After the failure we generate a close-channel monitor update
 		check_closed_broadcast!(nodes[1], true);
-		check_closed_event!(nodes[1], 1, ClosureReason::ProcessingError { err: "ChannelMonitor storage failure".to_string() });
+		check_closed_event!(nodes[1], 1, ClosureReason::ProcessingError { err: "ChannelMonitor storage failure".to_string() }, 
+			nodes[0].node.get_our_node_id(), 100000);
 
 		// Build a new ChannelMonitorUpdate which contains both the failing commitment tx update
 		// and provides the claim preimages for the two pending HTLCs. The first update generates

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -70,7 +70,8 @@ fn test_simple_monitor_permanent_update_fail() {
 	// PaymentPathFailed event
 
 	assert_eq!(nodes[0].node.list_channels().len(), 0);
-	check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "ChannelMonitor storage failure".to_string() });
+	check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "ChannelMonitor storage failure".to_string() },
+	nodes[1].node.get_our_node_id(), 100000);
 }
 
 #[test]
@@ -245,7 +246,7 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
 	// PaymentPathFailed event
 
 	assert_eq!(nodes[0].node.list_channels().len(), 0);
-	check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed);
+	check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed, nodes[1].node.get_our_node_id(), 100000);
 }
 
 #[test]
@@ -1983,8 +1984,8 @@ fn do_during_funding_monitor_fail(confirm_a_first: bool, restore_b_before_conf:
 
 	send_payment(&nodes[0], &[&nodes[1]], 8000000);
 	close_channel(&nodes[0], &nodes[1], &channel_id, funding_tx, true);
-	check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
-	check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
+	check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, nodes[1].node.get_our_node_id(), 100000);
+	check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, nodes[0].node.get_our_node_id(), 100000);
 }
 
 #[test]
@@ -2184,7 +2185,7 @@ fn test_fail_htlc_on_broadcast_after_claim() {
 	expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false);
 
 	mine_transaction(&nodes[1], &bs_txn[0]);
-	check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
+	check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, nodes[2].node.get_our_node_id(), 100000);
 	check_closed_broadcast!(nodes[1], true);
 	connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 	check_added_monitors!(nodes[1], 1);
@@ -2651,8 +2652,8 @@ fn test_temporary_error_during_shutdown() {
 	assert_eq!(txn_a, txn_b);
 	assert_eq!(txn_a.len(), 1);
 	check_spends!(txn_a[0], funding_tx);
-	check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
-	check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
+	check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, nodes[0].node.get_our_node_id(), 100000);
+	check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, nodes[1].node.get_our_node_id(), 100000);
 }
 
 #[test]
@@ -2681,7 +2682,8 @@ fn test_permanent_error_during_sending_shutdown() {
 	if let MessageSendEvent::HandleError { .. } =  msg_events[2] {} else { panic!(); }
 
 	check_added_monitors!(nodes[0], 2);
-	check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "ChannelMonitor storage failure".to_string() });
+	check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "ChannelMonitor storage failure".to_string() },
+		nodes[1].node.get_our_node_id(), 100000);
 }
 
 #[test]
@@ -2712,7 +2714,8 @@ fn test_permanent_error_during_handling_shutdown() {
 	if let MessageSendEvent::HandleError { .. } =  msg_events[2] {} else { panic!(); }
 
 	check_added_monitors!(nodes[1], 2);
-	check_closed_event!(nodes[1], 1, ClosureReason::ProcessingError { err: "ChannelMonitor storage failure".to_string() });
+	check_closed_event!(nodes[1], 1, ClosureReason::ProcessingError { err: "ChannelMonitor storage failure".to_string() },
+		nodes[0].node.get_our_node_id(), 100000);
 }
 
 #[test]
@@ -2906,7 +2909,7 @@ fn do_test_outbound_reload_without_init_mon(use_0conf: bool) {
 	nodes[0].chain_source.watched_outputs.lock().unwrap().clear();
 
 	reload_node!(nodes[0], &nodes[0].node.encode(), &[], persister, new_chain_monitor, nodes_0_deserialized);
-	check_closed_event!(nodes[0], 1, ClosureReason::DisconnectedPeer);
+	check_closed_event!(nodes[0], 1, ClosureReason::DisconnectedPeer, nodes[1].node.get_our_node_id(), 100000);
 	assert!(nodes[0].node.list_channels().is_empty());
 }
 
@@ -2993,7 +2996,7 @@ fn do_test_inbound_reload_without_init_mon(use_0conf: bool, lock_commitment: boo
 
 	reload_node!(nodes[1], &nodes[1].node.encode(), &[], persister, new_chain_monitor, nodes_1_deserialized);
 
-	check_closed_event!(nodes[1], 1, ClosureReason::DisconnectedPeer);
+	check_closed_event!(nodes[1], 1, ClosureReason::DisconnectedPeer, nodes[0].node.get_our_node_id(), 100000);
 	assert!(nodes[1].node.list_channels().is_empty());
 }
 

lightning/src/ln/channelmanager.rs

@@ -9522,7 +9522,7 @@ mod tests {
 		nodes[0].node.force_close_broadcasting_latest_txn(&chan.2, &nodes[1].node.get_our_node_id()).unwrap();
 		check_closed_broadcast!(nodes[0], true);
 		check_added_monitors!(nodes[0], 1);
-		check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed);
+		check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed, nodes[1].node.get_our_node_id(), 100000);
 
 		{
 			// Assert that nodes[1] is awaiting removal for nodes[0] once nodes[1] has been
@@ -9685,8 +9685,8 @@ mod tests {
 		}
 		let (_nodes_1_update, _none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 
-		check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
-		check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
+		check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, nodes[1].node.get_our_node_id(), 1000000);
+		check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, nodes[0].node.get_our_node_id(), 1000000);
 	}
 
 	fn check_not_connected_to_peer_error<T>(res_err: Result<T, APIError>, expected_public_key: PublicKey) {
@@ -10081,7 +10081,7 @@ mod tests {
 		let open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
 		assert!(!open_channel_msg.channel_type.unwrap().supports_anchors_zero_fee_htlc_tx());
 
-		check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed);
+		check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed, nodes[0].node.get_our_node_id(), 100000);
 	}
 
 	#[test]

lightning/src/ln/functional_test_utils.rs

@@ -1399,14 +1399,23 @@ macro_rules! check_closed_broadcast {
 }
 
 /// Check that a channel's closing channel events has been issued
-pub fn check_closed_event(node: &Node, events_count: usize, expected_reason: ClosureReason, is_check_discard_funding: bool) {
+pub fn check_closed_event(node: &Node, events_count: usize, expected_reason: ClosureReason, is_check_discard_funding: bool,
+	expected_counterparty_node_id: &PublicKey, expected_channel_capacity: u64) {
 	let events = node.node.get_and_clear_pending_events();
 	assert_eq!(events.len(), events_count, "{:?}", events);
 	let mut issues_discard_funding = false;
 	for event in events {
 		match event {
-			Event::ChannelClosed { ref reason, .. } => {
+			Event::ChannelClosed { ref reason, counterparty_node_id, 
+				channel_capacity, .. } => {
 				assert_eq!(*reason, expected_reason);
+				if let Some(counterparty_node_id) = counterparty_node_id {
+					assert_eq!(counterparty_node_id, *expected_counterparty_node_id);
+				}
+				
+				if let Some(channel_capacity) = channel_capacity {
+					assert_eq!(channel_capacity, expected_channel_capacity);
+				}
 			},
 			Event::DiscardFunding { .. } => {
 				issues_discard_funding = true;
@@ -1422,11 +1431,12 @@ pub fn check_closed_event(node: &Node, events_count: usize, expected_reason: Clo
 /// Don't use this, use the identically-named function instead.
 #[macro_export]
 macro_rules! check_closed_event {
-	($node: expr, $events: expr, $reason: expr) => {
-		check_closed_event!($node, $events, $reason, false);
+	($node: expr, $events: expr, $reason: expr, $counterparty_node_id: expr, $channel_capacity: expr) => {
+		check_closed_event!($node, $events, $reason, false, $counterparty_node_id, $channel_capacity);
 	};
-	($node: expr, $events: expr, $reason: expr, $is_check_discard_funding: expr) => {
-		$crate::ln::functional_test_utils::check_closed_event(&$node, $events, $reason, $is_check_discard_funding);
+	($node: expr, $events: expr, $reason: expr, $is_check_discard_funding: expr, $counterparty_node_id: expr, $channel_capacity: expr) => {
+		$crate::ln::functional_test_utils::check_closed_event(&$node, $events, $reason, 
+			$is_check_discard_funding, &$counterparty_node_id, $channel_capacity);
 	}
 }