fixup: simplify LSPS2 test setup and consolidate duplicate tests

Author: martinsaposnic

lightning-liquidity/tests/common/mod.rs

@@ -9,7 +9,6 @@ use lightning::sign::EntropySource;
 
 use bitcoin::blockdata::constants::{genesis_block, ChainHash};
 use bitcoin::blockdata::transaction::Transaction;
-use bitcoin::secp256k1::SecretKey;
 use bitcoin::Network;
 use lightning::chain::channelmonitor::ANTI_REORG_DELAY;
 use lightning::chain::{chainmonitor, BestBlock, Confirm};
@@ -35,8 +34,6 @@ use lightning::util::persist::{
 	SCORER_PERSISTENCE_SECONDARY_NAMESPACE,
 };
 use lightning::util::test_utils;
-use lightning_liquidity::lsps2::client::{LSPS2ClientConfig, LSPS2ClientHandler};
-use lightning_liquidity::lsps2::service::{LSPS2ServiceConfig, LSPS2ServiceHandler};
 use lightning_liquidity::{LiquidityClientConfig, LiquidityManager, LiquidityServiceConfig};
 use lightning_persister::fs_store::FilesystemStore;
 
@@ -70,7 +67,7 @@ type LockingWrapper<T> = lightning::routing::scoring::MultiThreadedLockableScore
 #[cfg(not(c_bindings))]
 type LockingWrapper<T> = std::sync::Mutex<T>;
 
-type ChannelManager = channelmanager::ChannelManager<
+pub(crate) type ChannelManager = channelmanager::ChannelManager<
 	Arc<ChainMonitor>,
 	Arc<test_utils::TestBroadcaster>,
 	Arc<KeysManager>,
@@ -490,7 +487,7 @@ pub(crate) fn create_liquidity_node(
 	}
 }
 
-fn create_service_and_client_nodes(
+pub(crate) fn create_service_and_client_nodes(
 	persist_dir: &str, service_config: LiquidityServiceConfig, client_config: LiquidityClientConfig,
 ) -> (Node, Node) {
 	let persist_temp_path = env::temp_dir().join(persist_dir);
@@ -674,53 +671,3 @@ fn advance_chain(node: &mut Node, num_blocks: u32) {
 		}
 	}
 }
-
-pub(crate) fn setup_test_lsps2() -> (
-	&'static LSPS2ClientHandler<Arc<KeysManager>>,
-	&'static LSPS2ServiceHandler<Arc<ChannelManager>>,
-	bitcoin::secp256k1::PublicKey,
-	bitcoin::secp256k1::PublicKey,
-	&'static Node,
-	&'static Node,
-	[u8; 32],
-) {
-	let promise_secret = [42; 32];
-	let signing_key = SecretKey::from_slice(&promise_secret).unwrap();
-	let lsps2_service_config = LSPS2ServiceConfig { promise_secret };
-	let service_config = LiquidityServiceConfig {
-		#[cfg(lsps1_service)]
-		lsps1_service_config: None,
-		lsps2_service_config: Some(lsps2_service_config),
-		advertise_service: true,
-	};
-
-	let lsps2_client_config = LSPS2ClientConfig::default();
-	let client_config = LiquidityClientConfig {
-		lsps1_client_config: None,
-		lsps2_client_config: Some(lsps2_client_config),
-	};
-
-	let (service_node, client_node) =
-		create_service_and_client_nodes("webhook_registration_flow", 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,
-	)
-}

lightning-liquidity/tests/lsps2_integration_tests.rs

@@ -2,12 +2,14 @@
 
 mod common;
 
-use common::{get_lsps_message, setup_test_lsps2, Node};
+use common::{create_service_and_client_nodes, 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::event::{LSPS2ClientEvent, LSPS2ServiceEvent};
 use lightning_liquidity::lsps2::msgs::LSPS2RawOpeningFeeParams;
+use lightning_liquidity::lsps2::service::LSPS2ServiceConfig;
 use lightning_liquidity::lsps2::utils::is_valid_opening_fee_params;
 
 use lightning::ln::channelmanager::{InterceptId, MIN_FINAL_CLTV_EXPIRY_DELTA};
@@ -19,15 +21,44 @@ use lightning::util::logger::Logger;
 
 use lightning_invoice::{Bolt11Invoice, InvoiceBuilder, RoutingFees};
 
+use lightning_liquidity::{LiquidityClientConfig, LiquidityServiceConfig};
 use lightning_types::payment::PaymentHash;
 
 use bitcoin::hashes::{sha256, Hash};
-use bitcoin::secp256k1::{PublicKey, Secp256k1};
+use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
 use bitcoin::Network;
 
 use std::str::FromStr;
 use std::time::Duration;
 
+fn setup_test_lsps2(
+) -> (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 };
+	let service_config = LiquidityServiceConfig {
+		#[cfg(lsps1_service)]
+		lsps1_service_config: None,
+		lsps2_service_config: Some(lsps2_service_config),
+		advertise_service: true,
+	};
+
+	let lsps2_client_config = LSPS2ClientConfig::default();
+	let client_config = LiquidityClientConfig {
+		lsps1_client_config: None,
+		lsps2_client_config: Some(lsps2_client_config),
+	};
+
+	let (service_node, client_node) =
+		create_service_and_client_nodes("webhook_registration_flow", service_config, client_config);
+
+	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();
+
+	(service_node_id, client_node_id, service_node, client_node, promise_secret)
+}
+
 fn create_jit_invoice(
 	node: &Node, service_node_id: PublicKey, intercept_scid: u64, cltv_expiry_delta: u32,
 	payment_size_msat: Option<u64>, description: &str, expiry_secs: u32,
@@ -82,15 +113,11 @@ 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_test_lsps2();
+	let (service_node_id, client_node_id, service_node, client_node, promise_secret) =
+		setup_test_lsps2();
+
+	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);
@@ -228,8 +255,9 @@ fn invoice_generation_flow() {
 
 #[test]
 fn channel_open_failed() {
-	let (_, service_handler, service_node_id, client_node_id, service_node, client_node, _) =
-		setup_test_lsps2();
+	let (service_node_id, client_node_id, service_node, client_node, _) = setup_test_lsps2();
+
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
 
 	let get_info_request_id = client_node
 		.liquidity_manager
@@ -303,6 +331,16 @@ fn channel_open_failed() {
 	client_node.liquidity_manager.handle_custom_message(buy_response, service_node_id).unwrap();
 	let _invoice_params_event = client_node.liquidity_manager.next_event().unwrap();
 
+	// Test calling channel_open_failed in invalid state (before HTLC interception)
+	let result = service_handler.channel_open_failed(&client_node_id, user_channel_id);
+	assert!(result.is_err());
+	match result.unwrap_err() {
+		APIError::APIMisuseError { err } => {
+			assert!(err.contains("Channel is not in the PendingChannelOpen state."));
+		},
+		other => panic!("Unexpected error type: {:?}", other),
+	}
+
 	let htlc_amount_msat = 1_000_000;
 	let intercept_id = InterceptId([0; 32]);
 	let payment_hash = PaymentHash([1; 32]);
@@ -348,95 +386,11 @@ fn channel_open_failed() {
 	};
 }
 
-#[test]
-fn channel_open_failed_invalid_state() {
-	let (_, service_handler, service_node_id, client_node_id, service_node, client_node, _) =
-		setup_test_lsps2();
-
-	let get_info_request_id = client_node
-		.liquidity_manager
-		.lsps2_client_handler()
-		.unwrap()
-		.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();
-
-	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,
-	};
-	service_handler
-		.opening_fee_params_generated(
-			&client_node_id,
-			get_info_request_id.clone(),
-			vec![raw_opening_params],
-		)
-		.unwrap();
-
-	let get_info_response = get_lsps_message!(service_node, client_node_id);
-	client_node
-		.liquidity_manager
-		.handle_custom_message(get_info_response, service_node_id)
-		.unwrap();
-
-	let opening_fee_params = match client_node.liquidity_manager.next_event().unwrap() {
-		LiquidityEvent::LSPS2Client(LSPS2ClientEvent::OpeningParametersReady {
-			opening_fee_params_menu,
-			..
-		}) => opening_fee_params_menu.first().unwrap().clone(),
-		_ => panic!("Unexpected event"),
-	};
-
-	let payment_size_msat = Some(1_000_000);
-	let buy_request_id = client_node
-		.liquidity_manager
-		.lsps2_client_handler()
-		.unwrap()
-		.select_opening_params(service_node_id, payment_size_msat, opening_fee_params.clone())
-		.unwrap();
-	let buy_request = get_lsps_message!(client_node, service_node_id);
-	service_node.liquidity_manager.handle_custom_message(buy_request, client_node_id).unwrap();
-
-	let _buy_event = service_node.liquidity_manager.next_event().unwrap();
-	let user_channel_id = 42;
-	let cltv_expiry_delta = 144;
-	let intercept_scid = service_node.channel_manager.get_intercept_scid();
-	let client_trusts_lsp = true;
-
-	service_handler
-		.invoice_parameters_generated(
-			&client_node_id,
-			buy_request_id.clone(),
-			intercept_scid,
-			cltv_expiry_delta,
-			client_trusts_lsp,
-			user_channel_id,
-		)
-		.unwrap();
-
-	// We're purposely not intercepting an HTLC, so the state remains PendingInitialPayment
-
-	// Try to call channel_open_failed, which should fail because the channel is not in PendingChannelOpen state
-	let result = service_handler.channel_open_failed(&client_node_id, user_channel_id);
-
-	assert!(result.is_err());
-	match result.unwrap_err() {
-		APIError::APIMisuseError { err } => {
-			assert!(err.contains("Channel is not in the PendingChannelOpen state."));
-		},
-		other => panic!("Unexpected error type: {:?}", other),
-	}
-}
-
 #[test]
 fn channel_open_failed_nonexistent_channel() {
-	let (_, service_handler, _, client_node_id, _, _, _) = setup_test_lsps2();
+	let (_, client_node_id, service_node, _, _) = setup_test_lsps2();
+
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
 
 	// Call channel_open_failed with a nonexistent user_channel_id
 	let nonexistent_user_channel_id = 999;
@@ -453,8 +407,9 @@ fn channel_open_failed_nonexistent_channel() {
 
 #[test]
 fn channel_open_abandoned() {
-	let (_, service_handler, service_node_id, client_node_id, service_node, client_node, _) =
-		setup_test_lsps2();
+	let (service_node_id, client_node_id, service_node, client_node, _) = setup_test_lsps2();
+
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
 
 	// Set up a JIT channel
 	let get_info_request_id = client_node
@@ -534,7 +489,8 @@ fn channel_open_abandoned() {
 
 #[test]
 fn channel_open_abandoned_nonexistent_channel() {
-	let (_, service_handler, _, client_node_id, _, _, _) = setup_test_lsps2();
+	let (_, client_node_id, service_node, _, _) = setup_test_lsps2();
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
 
 	// Call channel_open_abandoned with a nonexistent user_channel_id
 	let nonexistent_user_channel_id = 999;