(XXX: doc for one thing) update test!

Author: TheBlueMatt

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -3248,7 +3248,7 @@ fn test_inverted_mon_completion_order() {
 	do_test_inverted_mon_completion_order(false, false);
 }
 
-fn do_test_durable_preimages_on_closed_channel(close_chans_before_reload: bool, close_only_a: bool) {
+fn do_test_durable_preimages_on_closed_channel(close_chans_before_reload: bool, close_only_a: bool, hold_post_reload_mon_update: bool) {
 	// Test that we can apply a `ChannelMonitorUpdate` with a payment preimage even if the channel
 	// is force-closed between when we generate the update on reload and when we go to handle the
 	// update or prior to generating the update at all.
@@ -3344,8 +3344,14 @@ fn do_test_durable_preimages_on_closed_channel(close_chans_before_reload: bool,
 	// After a timer tick a payment preimage ChannelMonitorUpdate is applied to the A<->B
 	// ChannelMonitor (possible twice), even though the channel has since been closed.
 	check_added_monitors(&nodes[1], 0);
+	let mons_added = if close_chans_before_reload { if !close_only_a { 4 } else { 3 } } else { 2 };
+	if hold_post_reload_mon_update {
+		for _ in 0..mons_added {
+			persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
+		}
+	}
 	nodes[1].node.timer_tick_occurred();
-	check_added_monitors(&nodes[1], if close_chans_before_reload { if !close_only_a { 4 } else { 3 } } else { 2 });
+	check_added_monitors(&nodes[1], mons_added);
 
 	// Finally, check that B created a payment preimage transaction and close out the payment.
 	let bs_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
@@ -3359,17 +3365,39 @@ fn do_test_durable_preimages_on_closed_channel(close_chans_before_reload: bool,
 	} else {
 		// While we forwarded the payment a while ago, we don't want to process events too early or
 		// we'll run background tasks we wanted to test individually.
-		expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], None, false, !close_only_a);
+		expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], None, true, !close_only_a);
 	}
 
 	mine_transactions(&nodes[0], &[&as_closing_tx[0], bs_preimage_tx]);
 	check_closed_broadcast(&nodes[0], 1, true);
 	expect_payment_sent(&nodes[0], payment_preimage, None, true, true);
+
+	if !close_chans_before_reload || close_only_a {
+		// Make sure the B<->C channel is still alive and well by sending a payment over it.
+		let have_mon = if close_only_a {
+			// XXX If 
+			-1
+		} else { -2 };
+		reconnect_nodes(&nodes[1], &nodes[2], (false, false), (0, have_mon), (0, 0), (0, 0), (0, 0), (0, 0), (false, true));
+		let (outpoint, ab_update_id, _) = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id_ab).unwrap().clone();
+		nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(outpoint, ab_update_id);
+		expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), true, false);
+		if !close_only_a {
+			// Once we call `process_pending_events` the final `ChannelMonitor` for the B<->C
+			// channel will fly, removing the payment preimage from it.
+			check_added_monitors(&nodes[1], 1);
+		}
+		assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
+		send_payment(&nodes[1], &[&nodes[2]], 100_000);
+	}
 }
 
 #[test]
 fn test_durable_preimages_on_closed_channel() {
-	do_test_durable_preimages_on_closed_channel(true, true);
-	do_test_durable_preimages_on_closed_channel(true, false);
-	do_test_durable_preimages_on_closed_channel(false, false);
+	do_test_durable_preimages_on_closed_channel(true, true, true);
+	do_test_durable_preimages_on_closed_channel(true, true, false);
+	do_test_durable_preimages_on_closed_channel(true, false, true);
+	do_test_durable_preimages_on_closed_channel(true, false, false);
+	do_test_durable_preimages_on_closed_channel(false, false, true);
+	do_test_durable_preimages_on_closed_channel(false, false, false);
 }