Add an integration test for InvoicePayer paying when one part fails

This tests the multi-part-single-failure-immediately fixes in the
previous commit.

Author: TheBlueMatt

lightning-invoice/src/payment.rs

@@ -439,18 +439,22 @@ where
 mod tests {
 	use super::*;
 	use crate::{DEFAULT_EXPIRY_TIME, InvoiceBuilder, Currency};
+	use utils::create_invoice_from_channelmanager;
 	use bitcoin_hashes::sha256::Hash as Sha256;
 	use lightning::ln::PaymentPreimage;
-	use lightning::ln::features::{ChannelFeatures, NodeFeatures};
+	use lightning::ln::features::{ChannelFeatures, NodeFeatures, InitFeatures};
+	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::msgs::{ErrorAction, LightningError};
 	use lightning::routing::network_graph::NodeId;
 	use lightning::routing::router::{Payee, Route, RouteHop};
 	use lightning::util::test_utils::TestLogger;
 	use lightning::util::errors::APIError;
-	use lightning::util::events::Event;
+	use lightning::util::events::{Event, MessageSendEventsProvider};
 	use secp256k1::{SecretKey, PublicKey, Secp256k1};
 	use std::cell::RefCell;
 	use std::time::{SystemTime, Duration};
+	use std::collections::LinkedList;
+	use std::sync::Mutex;
 
 	fn invoice(payment_preimage: PaymentPreimage) -> Invoice {
 		let payment_hash = Sha256::hash(&payment_preimage.0);
@@ -1174,4 +1178,72 @@ mod tests {
 			}
 		}
 	}
+
+	// *** Full Featured Functional Tests with a Real ChannelManager ***
+	struct ManualRouter(Mutex<LinkedList<Result<Route, LightningError>>>);
+
+	impl Router for ManualRouter {
+		fn find_route(&self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>)
+		-> Result<Route, LightningError> {
+			self.0.lock().unwrap().pop_front().unwrap()
+		}
+	}
+
+	impl Drop for ManualRouter {
+		fn drop(&mut self) {
+			assert!(self.0.lock().unwrap().is_empty());
+		}
+	}
+
+	#[test]
+	fn retry_multi_path_single_failed_payment() {
+		// Tests that we can/will retry after a single path of an MPP payment failed immediately
+		let chanmon_cfgs = create_chanmon_cfgs(2);
+		let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+		let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None, None]);
+		let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+		create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
+		create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
+		let chans = nodes[0].node.list_usable_channels();
+		let mut route = Route {
+			paths: vec![
+				vec![RouteHop {
+					pubkey: nodes[1].node.get_our_node_id(),
+					node_features: NodeFeatures::known(),
+					short_channel_id: chans[0].short_channel_id.unwrap(),
+					channel_features: ChannelFeatures::known(),
+					fee_msat: 10_000,
+					cltv_expiry_delta: 100,
+				}],
+				vec![RouteHop {
+					pubkey: nodes[1].node.get_our_node_id(),
+					node_features: NodeFeatures::known(),
+					short_channel_id: chans[1].short_channel_id.unwrap(),
+					channel_features: ChannelFeatures::known(),
+					fee_msat: 100_000_001, // Our default max-HTLC-value is 10% of the channel value
+					cltv_expiry_delta: 100,
+				}],
+			],
+			payee: Some(Payee::new(nodes[1].node.get_our_node_id())),
+		};
+		let mut routes = LinkedList::new();
+		routes.push_back(Ok(route.clone()));
+		// On retry, split the payment across both channels.
+		route.paths[0][0].fee_msat = 50_000_001;
+		route.paths[1][0].fee_msat = 50_000_000;
+		routes.push_back(Ok(route.clone()));
+		let route_res = ManualRouter(Mutex::new(routes));
+
+		let event_handled = core::cell::RefCell::new(false);
+		let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
+		let invoice_payer = InvoicePayer::new(nodes[0].node, route_res, nodes[0].logger, event_handler, RetryAttempts(1));
+
+		invoice_payer.pay_invoice(&create_invoice_from_channelmanager(
+			&nodes[1].node, nodes[1].keys_manager, Currency::Bitcoin, Some(100_010_000), "Invoice".to_string()).unwrap()).unwrap();
+		let htlc_msgs = nodes[0].node.get_and_clear_pending_msg_events();
+		assert_eq!(htlc_msgs.len(), 2);
+		check_added_monitors!(nodes[0], 2);
+		assert!(!*event_handled.borrow());
+	}
 }