f test-only method

Author: valentinewallace

lightning/src/ln/async_payments_tests.rs

@@ -637,30 +637,29 @@ 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();
-			*invoice_request = offer
-				.request_invoice(
-					&nodes[0].keys_manager.get_inbound_payment_key(),
-					Nonce::from_entropy_source(nodes[0].keys_manager),
-					&secp_ctx,
-					payment_id,
-				)
-				.unwrap()
-				.amount_msats(amt_msat + 1)
-				.unwrap()
-				.chain_hash(ChainHash::using_genesis_block(Network::Testnet))
-				.unwrap()
-				.build_and_sign()
-				.unwrap();
-		},
-		_ => panic!(),
-	}
-	core::mem::drop(outbounds);
+	let mut valid_invreq = None;
+	nodes[0].node.test_modify_pending_payment(&payment_id, |pmt| {
+		match pmt {
+			PendingOutboundPayment::StaticInvoiceReceived { invoice_request, .. } => {
+				valid_invreq = Some(invoice_request.clone());
+				*invoice_request = offer
+					.request_invoice(
+						&nodes[0].keys_manager.get_inbound_payment_key(),
+						Nonce::from_entropy_source(nodes[0].keys_manager),
+						&secp_ctx,
+						payment_id,
+					)
+					.unwrap()
+					.amount_msats(amt_msat + 1)
+					.unwrap()
+					.chain_hash(ChainHash::using_genesis_block(Network::Testnet))
+					.unwrap()
+					.build_and_sign()
+					.unwrap();
+			},
+			_ => panic!()
+		}
+	});
 
 	nodes[0]
 		.onion_messenger
@@ -683,15 +682,14 @@ 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| {
+		match pmt {
+			PendingOutboundPayment::Retryable { invoice_request, .. } => {
+				*invoice_request = valid_invreq.take();
+			},
+			_ => panic!(),
+		}
+	});
 
 	fail_blinded_htlc_backwards(payment_hash, 1, &[&nodes[0], &nodes[1], &nodes[3]], true);
 
@@ -720,27 +718,26 @@ 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, .. }) => {
-					assert!(invoice_request.is_some());
-					invoice_request.take()
-				},
-				_ => panic!(),
-			};
-			*valid_invreq.lock().unwrap() = valid_invreq_from_outbounds;
+			sender.node.test_modify_pending_payment(&payment_id, |pmt| {
+				match pmt {
+					PendingOutboundPayment::Retryable { invoice_request, .. } => {
+						assert!(invoice_request.is_some());
+						*valid_invreq.lock().unwrap() = invoice_request.take();
+					},
+					_ => 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, .. }) => {
-					*invoice_request = valid_invreq.lock().unwrap().take();
-				},
-				_ => panic!(),
-			}
+			sender.node.test_modify_pending_payment(&payment_id, |pmt| {
+				match pmt  {
+					PendingOutboundPayment::Retryable { invoice_request, .. } => {
+						*invoice_request = valid_invreq.lock().unwrap().take();
+					},
+					_ => panic!(),
+				}
+			});
 		},
 	);
 }
@@ -773,35 +770,34 @@ 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, .. }) => {
-					assert!(payment_params.is_some());
-					let valid_params = payment_params.clone();
-					if let Payee::Blinded { ref mut route_hints, .. } =
-						&mut payment_params.as_mut().unwrap().payee
-					{
-						core::mem::swap(route_hints, &mut invalid_blinded_payment_paths);
-					} else {
-						panic!()
-					}
-					valid_params
-				},
-				_ => panic!(),
-			};
-			*valid_payment_params.lock().unwrap() = valid_params_from_outbounds;
+			sender.node.test_modify_pending_payment(&payment_id, |pmt| {
+				match pmt {
+					PendingOutboundPayment::Retryable { ref mut payment_params, .. } => {
+						assert!(payment_params.is_some());
+						let valid_params = payment_params.clone();
+						if let Payee::Blinded { ref mut route_hints, .. } =
+							&mut payment_params.as_mut().unwrap().payee
+						{
+							core::mem::swap(route_hints, &mut invalid_blinded_payment_paths);
+						} else {
+							panic!()
+						}
+						*valid_payment_params.lock().unwrap() = valid_params;
+					},
+					_ => 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, .. }) => {
-					*payment_params = valid_payment_params.lock().unwrap().take();
-				},
-				_ => panic!(),
-			}
+			sender.node.test_modify_pending_payment(&payment_id, |pmt| {
+				match pmt {
+					PendingOutboundPayment::Retryable { payment_params, .. } => {
+						*payment_params = valid_payment_params.lock().unwrap().take();
+					},
+					_ => 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);