f test-only method

Author: valentinewallace

lightning/src/ln/async_payments_tests.rs

@@ -637,12 +637,10 @@ fn amount_doesnt_match_invreq() {
 
 	// Replace the invoice request contained within outbound_payments before sending so the invreq
 	// amount doesn't match the onion amount when the HTLC gets to the recipient.
-	let mut outbounds =
-		nodes[0].node.pending_outbound_payments.pending_outbound_payments.lock().unwrap();
-	let valid_invreq;
-	match outbounds.get_mut(&payment_id) {
-		Some(PendingOutboundPayment::StaticInvoiceReceived { invoice_request, .. }) => {
-			valid_invreq = invoice_request.clone();
+	let mut valid_invreq = None;
+	nodes[0].node.test_modify_pending_payment(&payment_id, |pmt| {
+		if let PendingOutboundPayment::StaticInvoiceReceived { invoice_request, .. } = pmt {
+			valid_invreq = Some(invoice_request.clone());
 			*invoice_request = offer
 				.request_invoice(
 					&nodes[0].keys_manager.get_inbound_payment_key(),
@@ -657,10 +655,10 @@ fn amount_doesnt_match_invreq() {
 				.unwrap()
 				.build_and_sign()
 				.unwrap();
-		},
-		_ => panic!(),
-	}
-	core::mem::drop(outbounds);
+		} else {
+			panic!()
+		}
+	});
 
 	nodes[0]
 		.onion_messenger
@@ -683,15 +681,13 @@ fn amount_doesnt_match_invreq() {
 
 	// Modify the invoice request stored in our outbounds to be the correct one, to make sure the
 	// payment retry will succeed after we finish failing the invalid HTLC back.
-	let mut outbounds =
-		nodes[0].node.pending_outbound_payments.pending_outbound_payments.lock().unwrap();
-	match outbounds.get_mut(&payment_id) {
-		Some(PendingOutboundPayment::Retryable { invoice_request, .. }) => {
-			*invoice_request = Some(valid_invreq);
-		},
-		_ => panic!(),
-	}
-	core::mem::drop(outbounds);
+	nodes[0].node.test_modify_pending_payment(&payment_id, |pmt| {
+		if let PendingOutboundPayment::Retryable { invoice_request, .. } = pmt {
+			*invoice_request = valid_invreq.take();
+		} else {
+			panic!()
+		}
+	});
 
 	fail_blinded_htlc_backwards(payment_hash, 1, &[&nodes[0], &nodes[1], &nodes[3]], true);
 
@@ -720,27 +716,24 @@ fn reject_missing_invreq() {
 		|sender, _, payment_id| {
 			// Remove the invoice request from our Retryable payment so we don't include it in the onion on
 			// retry.
-			let mut outbounds =
-				sender.node.pending_outbound_payments.pending_outbound_payments.lock().unwrap();
-			let valid_invreq_from_outbounds = match outbounds.get_mut(&payment_id) {
-				Some(PendingOutboundPayment::Retryable { invoice_request, .. }) => {
+			sender.node.test_modify_pending_payment(&payment_id, |pmt| {
+				if let PendingOutboundPayment::Retryable { invoice_request, .. } = pmt {
 					assert!(invoice_request.is_some());
-					invoice_request.take()
-				},
-				_ => panic!(),
-			};
-			*valid_invreq.lock().unwrap() = valid_invreq_from_outbounds;
+					*valid_invreq.lock().unwrap() = invoice_request.take();
+				} else {
+					panic!()
+				}
+			});
 		},
 		|sender, payment_id| {
 			// Re-add the invoice request so we include it in the onion on the next retry.
-			let mut outbounds =
-				sender.node.pending_outbound_payments.pending_outbound_payments.lock().unwrap();
-			match outbounds.get_mut(&payment_id) {
-				Some(PendingOutboundPayment::Retryable { invoice_request, .. }) => {
+			sender.node.test_modify_pending_payment(&payment_id, |pmt| {
+				if let PendingOutboundPayment::Retryable { invoice_request, .. } = pmt {
 					*invoice_request = valid_invreq.lock().unwrap().take();
-				},
-				_ => panic!(),
-			}
+				} else {
+					panic!()
+				}
+			});
 		},
 	);
 }
@@ -773,10 +766,8 @@ fn reject_bad_payment_secret() {
 			}
 
 			// Modify the outbound payment parameters to use payment paths with an invalid payment secret.
-			let mut outbounds =
-				sender.node.pending_outbound_payments.pending_outbound_payments.lock().unwrap();
-			let valid_params_from_outbounds = match outbounds.get_mut(&payment_id) {
-				Some(PendingOutboundPayment::Retryable { ref mut payment_params, .. }) => {
+			sender.node.test_modify_pending_payment(&payment_id, |pmt| {
+				if let PendingOutboundPayment::Retryable { ref mut payment_params, .. } = pmt {
 					assert!(payment_params.is_some());
 					let valid_params = payment_params.clone();
 					if let Payee::Blinded { ref mut route_hints, .. } =
@@ -786,22 +777,21 @@ fn reject_bad_payment_secret() {
 					} else {
 						panic!()
 					}
-					valid_params
-				},
-				_ => panic!(),
-			};
-			*valid_payment_params.lock().unwrap() = valid_params_from_outbounds;
+					*valid_payment_params.lock().unwrap() = valid_params;
+				} else {
+					panic!()
+				}
+			});
 		},
 		|sender, payment_id| {
 			// Re-add the valid payment params so we use the right payment secret on the next retry.
-			let mut outbounds =
-				sender.node.pending_outbound_payments.pending_outbound_payments.lock().unwrap();
-			match outbounds.get_mut(&payment_id) {
-				Some(PendingOutboundPayment::Retryable { payment_params, .. }) => {
+			sender.node.test_modify_pending_payment(&payment_id, |pmt| {
+				if let PendingOutboundPayment::Retryable { payment_params, .. } = pmt {
 					*payment_params = valid_payment_params.lock().unwrap().take();
-				},
-				_ => panic!(),
-			}
+				} else {
+					panic!()
+				}
+			});
 		},
 	);
 }

lightning/src/ln/channelmanager.rs

@@ -2441,9 +2441,6 @@ where
 	/// See `PendingOutboundPayment` documentation for more info.
 	///
 	/// See `ChannelManager` struct-level documentation for lock order requirements.
-	#[cfg(test)]
-	pub(super) pending_outbound_payments: OutboundPayments,
-	#[cfg(not(test))]
 	pending_outbound_payments: OutboundPayments,
 
 	/// SCID/SCID Alias -> forward infos. Key of 0 means payments received.
@@ -4696,6 +4693,17 @@ where
 		self.pending_outbound_payments.test_add_new_pending_payment(payment_hash, recipient_onion, payment_id, route, None, &self.entropy_source, best_block_height)
 	}
 
+	#[cfg(test)]
+	pub(crate) fn test_modify_pending_payment<Fn>(
+		&self, payment_id: &PaymentId, mut callback: Fn
+	) where Fn: FnMut(&mut PendingOutboundPayment) {
+		let mut outbounds = self.pending_outbound_payments.pending_outbound_payments.lock().unwrap();
+		match outbounds.get_mut(payment_id) {
+			Some(outb) => callback(outb),
+			_ => panic!()
+		}
+	}
+
 	#[cfg(test)]
 	pub(crate) fn test_set_payment_metadata(&self, payment_id: PaymentId, new_payment_metadata: Option<Vec<u8>>) {
 		self.pending_outbound_payments.test_set_payment_metadata(payment_id, new_payment_metadata);