fixup: refactor tests to match reviewed PR #3712. Also improve readability and reduce indentation in some places

Author: martinsaposnic

lightning-liquidity/tests/common/mod.rs

@@ -67,7 +67,7 @@ type LockingWrapper<T> = lightning::routing::scoring::MultiThreadedLockableScore
 #[cfg(not(c_bindings))]
 type LockingWrapper<T> = std::sync::Mutex<T>;
 
-pub(crate) type ChannelManager = channelmanager::ChannelManager<
+type ChannelManager = channelmanager::ChannelManager<
 	Arc<ChainMonitor>,
 	Arc<test_utils::TestBroadcaster>,
 	Arc<KeysManager>,

lightning-liquidity/tests/lsps2_integration_tests.rs

@@ -2,24 +2,22 @@
 
 mod common;
 
-use common::{create_service_and_client_nodes, ChannelManager};
+use common::create_service_and_client_nodes;
 use common::{get_lsps_message, Node};
 
 use lightning_liquidity::events::LiquidityEvent;
 use lightning_liquidity::lsps0::ser::LSPSDateTime;
 use lightning_liquidity::lsps2::client::LSPS2ClientConfig;
-use lightning_liquidity::lsps2::client::LSPS2ClientHandler;
 use lightning_liquidity::lsps2::event::LSPS2ClientEvent;
 use lightning_liquidity::lsps2::event::LSPS2ServiceEvent;
 use lightning_liquidity::lsps2::msgs::LSPS2RawOpeningFeeParams;
-use lightning_liquidity::lsps2::service::{LSPS2ServiceConfig, LSPS2ServiceHandler};
+use lightning_liquidity::lsps2::service::LSPS2ServiceConfig;
 use lightning_liquidity::lsps2::utils::is_valid_opening_fee_params;
 
 use lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA;
 use lightning::ln::peer_handler::CustomMessageHandler;
 use lightning::log_error;
 use lightning::routing::router::{RouteHint, RouteHintHop};
-use lightning::sign::KeysManager;
 use lightning::util::logger::Logger;
 
 use lightning_invoice::{Bolt11Invoice, InvoiceBuilder, RoutingFees};
@@ -31,21 +29,13 @@ use lightning_liquidity::LiquidityClientConfig;
 use lightning_liquidity::LiquidityServiceConfig;
 
 use std::str::FromStr;
-use std::sync::Arc;
 use std::time::Duration;
 
 const MAX_PENDING_REQUESTS_PER_PEER: usize = 10;
 const MAX_TOTAL_PENDING_REQUESTS: usize = 1000;
 
-fn setup_lsps2_test() -> (
-	&'static LSPS2ClientHandler<Arc<KeysManager>>,
-	&'static LSPS2ServiceHandler<Arc<ChannelManager>>,
-	bitcoin::secp256k1::PublicKey,
-	bitcoin::secp256k1::PublicKey,
-	&'static Node,
-	&'static Node,
-	[u8; 32],
-) {
+fn setup_lsps2_test(
+) -> (bitcoin::secp256k1::PublicKey, bitcoin::secp256k1::PublicKey, Node, Node, [u8; 32]) {
 	let promise_secret = [42; 32];
 	let signing_key = SecretKey::from_slice(&promise_secret).unwrap();
 	let lsps2_service_config = LSPS2ServiceConfig { promise_secret };
@@ -65,26 +55,11 @@ fn setup_lsps2_test() -> (
 	let (service_node, client_node) =
 		create_service_and_client_nodes("default_persist_dir", service_config, client_config);
 
-	// Leak the nodes to extend their lifetime to 'static since this is test code
-	let service_node = Box::leak(Box::new(service_node));
-	let client_node = Box::leak(Box::new(client_node));
-
-	let client_handler = client_node.liquidity_manager.lsps2_client_handler().unwrap();
-	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
-
 	let secp = bitcoin::secp256k1::Secp256k1::new();
 	let service_node_id = bitcoin::secp256k1::PublicKey::from_secret_key(&secp, &signing_key);
 	let client_node_id = client_node.channel_manager.get_our_node_id();
 
-	(
-		client_handler,
-		service_handler,
-		service_node_id,
-		client_node_id,
-		service_node,
-		client_node,
-		promise_secret,
-	)
+	(service_node_id, client_node_id, service_node, client_node, promise_secret)
 }
 
 fn create_jit_invoice(
@@ -141,33 +116,29 @@ fn create_jit_invoice(
 
 #[test]
 fn invoice_generation_flow() {
-	let (
-		client_handler,
-		service_handler,
-		service_node_id,
-		client_node_id,
-		service_node,
-		client_node,
-		promise_secret,
-	) = setup_lsps2_test();
+	let (service_node_id, client_node_id, service_node, client_node, promise_secret) =
+		setup_lsps2_test();
+
+	let client_handler = client_node.liquidity_manager.lsps2_client_handler().unwrap();
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
 
 	let get_info_request_id = client_handler.request_opening_params(service_node_id, None);
 	let get_info_request = get_lsps_message!(client_node, service_node_id);
 
 	service_node.liquidity_manager.handle_custom_message(get_info_request, client_node_id).unwrap();
 
 	let get_info_event = service_node.liquidity_manager.next_event().unwrap();
-	match get_info_event {
-		LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::GetInfo {
-			request_id,
-			counterparty_node_id,
-			token,
-		}) => {
-			assert_eq!(request_id, get_info_request_id);
-			assert_eq!(counterparty_node_id, client_node_id);
-			assert_eq!(token, None);
-		},
-		_ => panic!("Unexpected event"),
+	if let LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::GetInfo {
+		request_id,
+		counterparty_node_id,
+		token,
+	}) = get_info_event
+	{
+		assert_eq!(request_id, get_info_request_id);
+		assert_eq!(counterparty_node_id, client_node_id);
+		assert_eq!(token, None);
+	} else {
+		panic!("Unexpected event");
 	}
 
 	let raw_opening_params = LSPS2RawOpeningFeeParams {
@@ -219,19 +190,19 @@ fn invoice_generation_flow() {
 	service_node.liquidity_manager.handle_custom_message(buy_request, client_node_id).unwrap();
 
 	let buy_event = service_node.liquidity_manager.next_event().unwrap();
-	match buy_event {
-		LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::BuyRequest {
-			request_id,
-			counterparty_node_id,
-			opening_fee_params: ofp,
-			payment_size_msat: psm,
-		}) => {
-			assert_eq!(request_id, buy_request_id);
-			assert_eq!(counterparty_node_id, client_node_id);
-			assert_eq!(opening_fee_params, ofp);
-			assert_eq!(payment_size_msat, psm);
-		},
-		_ => panic!("Unexpected event"),
+	if let LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::BuyRequest {
+		request_id,
+		counterparty_node_id,
+		opening_fee_params: ofp,
+		payment_size_msat: psm,
+	}) = buy_event
+	{
+		assert_eq!(request_id, buy_request_id);
+		assert_eq!(counterparty_node_id, client_node_id);
+		assert_eq!(opening_fee_params, ofp);
+		assert_eq!(payment_size_msat, psm);
+	} else {
+		panic!("Unexpected event");
 	}
 
 	let user_channel_id = 42;
@@ -254,22 +225,22 @@ fn invoice_generation_flow() {
 	client_node.liquidity_manager.handle_custom_message(buy_response, service_node_id).unwrap();
 
 	let invoice_params_event = client_node.liquidity_manager.next_event().unwrap();
-	match invoice_params_event {
-		LiquidityEvent::LSPS2Client(LSPS2ClientEvent::InvoiceParametersReady {
-			request_id,
-			counterparty_node_id,
-			intercept_scid: iscid,
-			cltv_expiry_delta: ced,
-			payment_size_msat: psm,
-		}) => {
-			assert_eq!(request_id, buy_request_id);
-			assert_eq!(counterparty_node_id, service_node_id);
-			assert_eq!(intercept_scid, iscid);
-			assert_eq!(cltv_expiry_delta, ced);
-			assert_eq!(payment_size_msat, psm);
-		},
-		_ => panic!("Unexpected event"),
-	};
+	if let LiquidityEvent::LSPS2Client(LSPS2ClientEvent::InvoiceParametersReady {
+		request_id,
+		counterparty_node_id,
+		intercept_scid: iscid,
+		cltv_expiry_delta: ced,
+		payment_size_msat: psm,
+	}) = invoice_params_event
+	{
+		assert_eq!(request_id, buy_request_id);
+		assert_eq!(counterparty_node_id, service_node_id);
+		assert_eq!(intercept_scid, iscid);
+		assert_eq!(cltv_expiry_delta, ced);
+		assert_eq!(payment_size_msat, psm);
+	} else {
+		panic!("Unexpected event");
+	}
 
 	let description = "asdf";
 	let expiry_secs = 3600;
@@ -287,8 +258,8 @@ fn invoice_generation_flow() {
 
 #[test]
 fn max_pending_requests_per_peer_rejected() {
-	let (client_handler, _, service_node_id, client_node_id, service_node, client_node, _) =
-		setup_lsps2_test();
+	let (service_node_id, client_node_id, service_node, client_node, _) = setup_lsps2_test();
+	let client_handler = client_node.liquidity_manager.lsps2_client_handler().unwrap();
 
 	for _ in 0..MAX_PENDING_REQUESTS_PER_PEER {
 		let _ = client_handler.request_opening_params(service_node_id, None);
@@ -333,8 +304,10 @@ fn max_pending_requests_per_peer_rejected() {
 
 #[test]
 fn max_total_requests_buy_rejected() {
-	let (client_handler, service_handler, service_node_id, _, service_node, client_node, _) =
-		setup_lsps2_test();
+	let (service_node_id, _, service_node, client_node, _) = setup_lsps2_test();
+
+	let client_handler = client_node.liquidity_manager.lsps2_client_handler().unwrap();
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
 	let secp = Secp256k1::new();
 
 	let special_sk_bytes = [99u8; 32];
@@ -456,15 +429,11 @@ fn max_total_requests_buy_rejected() {
 
 #[test]
 fn invalid_token_flow() {
-	let (
-		client_handler,
-		service_handler,
-		service_node_id,
-		client_node_id,
-		service_node,
-		client_node,
-		_promise_secret,
-	) = setup_lsps2_test();
+	let (service_node_id, client_node_id, service_node, client_node, _promise_secret) =
+		setup_lsps2_test();
+
+	let client_handler = client_node.liquidity_manager.lsps2_client_handler().unwrap();
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
 
 	let token = Some("invalid_token".to_string());
 	let get_info_request_id = client_handler.request_opening_params(service_node_id, token);
@@ -473,40 +442,40 @@ fn invalid_token_flow() {
 	service_node.liquidity_manager.handle_custom_message(get_info_request, client_node_id).unwrap();
 
 	let get_info_event = service_node.liquidity_manager.next_event().unwrap();
-	match get_info_event {
-		LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::GetInfo {
-			request_id,
-			counterparty_node_id,
-			token,
-		}) => {
-			assert_eq!(request_id, get_info_request_id);
-			assert_eq!(counterparty_node_id, client_node_id);
-			assert_eq!(token, Some("invalid_token".to_string()));
-
-			// Service rejects the token as invalid
-			service_handler.invalid_token_provided(&client_node_id, request_id.clone()).unwrap();
-
-			// Attempt to respond to the same request again which should fail
-			// because the request has been removed from pending_requests
-			let raw_opening_params = LSPS2RawOpeningFeeParams {
-				min_fee_msat: 100,
-				proportional: 21,
-				valid_until: LSPSDateTime::from_str("2035-05-20T08:30:45Z").unwrap(),
-				min_lifetime: 144,
-				max_client_to_self_delay: 128,
-				min_payment_size_msat: 1,
-				max_payment_size_msat: 100_000_000,
-			};
-
-			let result = service_handler.opening_fee_params_generated(
-				&client_node_id,
-				request_id.clone(),
-				vec![raw_opening_params],
-			);
+	if let LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::GetInfo {
+		request_id,
+		counterparty_node_id,
+		token,
+	}) = get_info_event
+	{
+		assert_eq!(request_id, get_info_request_id);
+		assert_eq!(counterparty_node_id, client_node_id);
+		assert_eq!(token, Some("invalid_token".to_string()));
+
+		// Service rejects the token as invalid
+		service_handler.invalid_token_provided(&client_node_id, request_id.clone()).unwrap();
+
+		// Attempt to respond to the same request again which should fail
+		// because the request has been removed from pending_requests
+		let raw_opening_params = LSPS2RawOpeningFeeParams {
+			min_fee_msat: 100,
+			proportional: 21,
+			valid_until: LSPSDateTime::from_str("2035-05-20T08:30:45Z").unwrap(),
+			min_lifetime: 144,
+			max_client_to_self_delay: 128,
+			min_payment_size_msat: 1,
+			max_payment_size_msat: 100_000_000,
+		};
+
+		let result = service_handler.opening_fee_params_generated(
+			&client_node_id,
+			request_id.clone(),
+			vec![raw_opening_params],
+		);
 
-			assert!(result.is_err(), "Request should have been removed from pending_requests");
-		},
-		_ => panic!("Unexpected event"),
+		assert!(result.is_err(), "Request should have been removed from pending_requests");
+	} else {
+		panic!("Unexpected event");
 	}
 
 	let get_info_error_response = get_lsps_message!(service_node, client_node_id);
@@ -517,16 +486,16 @@ fn invalid_token_flow() {
 		.unwrap_err();
 
 	let error_event = client_node.liquidity_manager.next_event().unwrap();
-	match error_event {
-		LiquidityEvent::LSPS2Client(LSPS2ClientEvent::GetInfoFailed {
-			request_id,
-			counterparty_node_id,
-			error,
-		}) => {
-			assert_eq!(request_id, get_info_request_id);
-			assert_eq!(counterparty_node_id, service_node_id);
-			assert_eq!(error.code, 200); // LSPS2_GET_INFO_REQUEST_UNRECOGNIZED_OR_STALE_TOKEN_ERROR_CODE
-		},
-		_ => panic!("Expected LSPS2ClientEvent::GetInfoFailed event"),
+	if let LiquidityEvent::LSPS2Client(LSPS2ClientEvent::GetInfoFailed {
+		request_id,
+		counterparty_node_id,
+		error,
+	}) = error_event
+	{
+		assert_eq!(request_id, get_info_request_id);
+		assert_eq!(counterparty_node_id, service_node_id);
+		assert_eq!(error.code, 200); // LSPS2_GET_INFO_REQUEST_UNRECOGNIZED_OR_STALE_TOKEN_ERROR_CODE
+	} else {
+		panic!("Expected LSPS2ClientEvent::GetInfoFailed event");
 	}
 }