Add e2e config startup tests

e2e-tests/src/lib.rs

@@ -16,11 +16,11 @@ use std::time::Duration;
 use corepc_node::Node;
 use hex_conservative::DisplayHex;
 use ldk_server_client::client::LdkServerClient;
-use serde_json::Value;
 use ldk_server_client::ldk_server_grpc::api::{GetNodeInfoRequest, GetNodeInfoResponse};
 use ldk_server_grpc::api::{
 	GetBalancesRequest, ListChannelsRequest, OnchainReceiveRequest, OpenChannelRequest,
 };
+use serde_json::Value;
 
 /// Wrapper around a managed bitcoind process for regtest.
 pub struct TestBitcoind {
@@ -103,30 +103,36 @@ pub struct LdkServerConfig {
 	pub metrics_auth: Option<(String, String)>,
 }
 
-impl LdkServerHandle {
-	/// Starts a new ldk-server instance against the given bitcoind.
-	/// Waits until the server is ready to accept requests.
-	pub async fn start(bitcoind: &TestBitcoind) -> Self {
-		Self::start_with_config(bitcoind, LdkServerConfig::default()).await
-	}
-
-	pub async fn start_with_config(bitcoind: &TestBitcoind, config: LdkServerConfig) -> Self {
-		#[allow(deprecated)]
-		let storage_dir = tempfile::tempdir().unwrap().into_path();
-		let grpc_port = find_available_port();
-		let p2p_port = find_available_port();
-
-		let (rpc_host, rpc_port_num, rpc_user, rpc_password) = bitcoind.rpc_details();
-		let rpc_address = format!("{rpc_host}:{rpc_port_num}");
+/// Dynamic parameters available when building test configs.
+pub struct TestServerParams {
+	pub grpc_port: u16,
+	pub p2p_port: u16,
+	pub storage_dir: PathBuf,
+	pub rpc_address: String,
+	pub rpc_user: String,
+	pub rpc_password: String,
+}
 
-		let metrics_auth_config = if let Some((user, pass)) = config.metrics_auth {
-			format!("username = \"{}\"\npassword = \"{}\"", user, pass)
-		} else {
-			String::new()
-		};
+/// Generate a test config TOML with a custom chain source section.
+pub fn test_config_with_chain_source(params: &TestServerParams, chain_source_toml: &str) -> String {
+	test_config_with_chain_source_and_options(
+		params,
+		chain_source_toml,
+		&LdkServerConfig::default(),
+	)
+}
 
-		let config_content = format!(
-			r#"[node]
+fn test_config_with_chain_source_and_options(
+	params: &TestServerParams, chain_source_toml: &str, config: &LdkServerConfig,
+) -> String {
+	let metrics_auth_config = if let Some((user, pass)) = &config.metrics_auth {
+		format!("username = \"{}\"\npassword = \"{}\"", user, pass)
+	} else {
+		String::new()
+	};
+
+	format!(
+		r#"[node]
 network = "regtest"
 listening_addresses = ["127.0.0.1:{p2p_port}"]
 grpc_service_address = "127.0.0.1:{grpc_port}"
@@ -135,10 +141,7 @@ alias = "e2e-test-node"
 [storage.disk]
 dir_path = "{storage_dir}"
 
-[bitcoind]
-rpc_address = "{rpc_address}"
-rpc_user = "{rpc_user}"
-rpc_password = "{rpc_password}"
+{chain_source}
 
 [liquidity.lsps2_service]
 advertise_service = false
@@ -157,21 +160,45 @@ enabled = true
 poll_metrics_interval = 1
 {metrics_auth_config}
 "#,
-			storage_dir = storage_dir.display(),
-		);
+		p2p_port = params.p2p_port,
+		grpc_port = params.grpc_port,
+		storage_dir = params.storage_dir.display(),
+		chain_source = chain_source_toml,
+	)
+}
 
-		let config_path = storage_dir.join("config.toml");
-		std::fs::write(&config_path, &config_content).unwrap();
+/// Generate the default test config TOML with bitcoind RPC chain source.
+pub fn default_test_config(params: &TestServerParams) -> String {
+	let chain_source = format!(
+		"[bitcoind]\nrpc_address = \"{}\"\nrpc_user = \"{}\"\nrpc_password = \"{}\"",
+		params.rpc_address, params.rpc_user, params.rpc_password
+	);
+	test_config_with_chain_source(params, &chain_source)
+}
 
-		let server_binary = server_binary_path();
-		let mut child = Command::new(&server_binary)
-			.arg(config_path.to_str().unwrap())
-			.stdout(Stdio::piped())
-			.stderr(Stdio::piped())
-			.spawn()
-			.unwrap_or_else(|e| {
-				panic!("Failed to start ldk-server binary at {:?}: {}", server_binary, e)
-			});
+impl LdkServerHandle {
+	/// Starts a new ldk-server instance against the given bitcoind.
+	/// Waits until the server is ready to accept requests.
+	pub async fn start(bitcoind: &TestBitcoind) -> Self {
+		Self::start_with_options(bitcoind, LdkServerConfig::default()).await
+	}
+
+	pub async fn start_with_options(bitcoind: &TestBitcoind, config: LdkServerConfig) -> Self {
+		Self::start_with_config(bitcoind, |params| {
+			let chain_source = format!(
+				"[bitcoind]\nrpc_address = \"{}\"\nrpc_user = \"{}\"\nrpc_password = \"{}\"",
+				params.rpc_address, params.rpc_user, params.rpc_password
+			);
+			test_config_with_chain_source_and_options(params, &chain_source, &config)
+		})
+		.await
+	}
+
+	pub async fn start_with_config(
+		config_bitcoind: &TestBitcoind, config: impl FnOnce(&TestServerParams) -> String,
+	) -> Self {
+		let (mut child, params, config_path) = spawn_server(config_bitcoind, config);
+		let TestServerParams { grpc_port, p2p_port, storage_dir, .. } = params;
 
 		// Spawn threads to forward stdout and stderr for debugging
 		let stdout = child.stdout.take().unwrap();
@@ -251,6 +278,78 @@ impl Drop for LdkServerHandle {
 	}
 }
 
+/// Prepare test server params and spawn the ldk-server process.
+fn spawn_server(
+	bitcoind: &TestBitcoind, config_fn: impl FnOnce(&TestServerParams) -> String,
+) -> (Child, TestServerParams, PathBuf) {
+	#[allow(deprecated)]
+	let storage_dir = tempfile::tempdir().unwrap().into_path();
+	let grpc_port = find_available_port();
+	let p2p_port = find_available_port();
+
+	let (rpc_host, rpc_port_num, rpc_user, rpc_password) = bitcoind.rpc_details();
+	let rpc_address = format!("{rpc_host}:{rpc_port_num}");
+
+	let params =
+		TestServerParams { grpc_port, p2p_port, storage_dir, rpc_address, rpc_user, rpc_password };
+
+	let config_content = config_fn(&params);
+
+	let config_path = params.storage_dir.join("config.toml");
+	std::fs::write(&config_path, &config_content).unwrap();
+
+	let server_binary = server_binary_path();
+	let child = Command::new(&server_binary)
+		.arg(config_path.to_str().unwrap())
+		.stdout(Stdio::piped())
+		.stderr(Stdio::piped())
+		.spawn()
+		.unwrap_or_else(|e| {
+			panic!("Failed to start ldk-server binary at {:?}: {}", server_binary, e)
+		});
+
+	(child, params, config_path)
+}
+
+/// Start ldk-server with the given config and expect it to fail (exit non-zero).
+/// Returns the stderr output for assertion in tests.
+pub fn start_expect_failure(
+	bitcoind: &TestBitcoind, config_fn: impl FnOnce(&TestServerParams) -> String,
+) -> String {
+	let (mut child, ..) = spawn_server(bitcoind, config_fn);
+
+	let timeout = Duration::from_secs(30);
+	let start = std::time::Instant::now();
+	loop {
+		match child.try_wait() {
+			Ok(Some(_)) => break,
+			Ok(None) => {
+				if start.elapsed() > timeout {
+					let _ = child.kill();
+					panic!(
+						"Server did not exit within {:?} — it may have started successfully \
+						 instead of failing",
+						timeout
+					);
+				}
+				std::thread::sleep(Duration::from_millis(100));
+			},
+			Err(e) => panic!("Failed to wait for ldk-server process: {}", e),
+		}
+	}
+
+	let output = child
+		.wait_with_output()
+		.unwrap_or_else(|e| panic!("Failed to read ldk-server output: {}", e));
+
+	assert!(
+		!output.status.success(),
+		"Expected server to fail but it exited with status: {}",
+		output.status
+	);
+
+	String::from_utf8_lossy(&output.stderr).to_string()
+}
 /// Find an available TCP port by binding to port 0.
 pub fn find_available_port() -> u16 {
 	let listener = TcpListener::bind("127.0.0.1:0").unwrap();

e2e-tests/tests/config.rs

@@ -0,0 +1,164 @@
+// This file is Copyright its original authors, visible in version control
+// history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
+use e2e_tests::{
+	default_test_config, start_expect_failure, test_config_with_chain_source, LdkServerHandle,
+	TestBitcoind,
+};
+use ldk_server_grpc::api::GetNodeInfoRequest;
+
+fn remove_config_line(config: &str, key: &str) -> String {
+	config.lines().filter(|line| !line.trim_start().starts_with(key)).collect::<Vec<_>>().join("\n")
+}
+
+fn replace_config_line(config: &str, key: &str, new_line: &str) -> String {
+	config
+		.lines()
+		.map(|line| if line.trim_start().starts_with(key) { new_line } else { line })
+		.collect::<Vec<_>>()
+		.join("\n")
+}
+
+#[tokio::test]
+async fn test_config_no_alias() {
+	let bitcoind = TestBitcoind::new();
+	let server = LdkServerHandle::start_with_config(&bitcoind, |params| {
+		remove_config_line(&default_test_config(params), "alias =")
+	})
+	.await;
+	let info = server.client().get_node_info(GetNodeInfoRequest {}).await.unwrap();
+	assert!(info.current_best_block.is_some());
+}
+
+#[tokio::test]
+async fn test_config_no_listening_addresses() {
+	let bitcoind = TestBitcoind::new();
+	let server = LdkServerHandle::start_with_config(&bitcoind, |params| {
+		let config = remove_config_line(&default_test_config(params), "listening_addresses =");
+		// Alias requires listening addresses for announcement, so remove it too
+		remove_config_line(&config, "alias =")
+	})
+	.await;
+	let info = server.client().get_node_info(GetNodeInfoRequest {}).await.unwrap();
+	assert!(info.current_best_block.is_some());
+}
+
+#[tokio::test]
+async fn test_config_multiple_listening_addresses() {
+	let bitcoind = TestBitcoind::new();
+	let server = LdkServerHandle::start_with_config(&bitcoind, |params| {
+		let extra_port = e2e_tests::find_available_port();
+		replace_config_line(
+			&default_test_config(params),
+			"listening_addresses =",
+			&format!(
+				"listening_addresses = [\"127.0.0.1:{}\", \"127.0.0.1:{}\"]",
+				params.p2p_port, extra_port
+			),
+		)
+	})
+	.await;
+	let info = server.client().get_node_info(GetNodeInfoRequest {}).await.unwrap();
+	assert!(info.current_best_block.is_some());
+}
+
+#[tokio::test]
+async fn test_config_with_announcement_addresses() {
+	let bitcoind = TestBitcoind::new();
+	let server = LdkServerHandle::start_with_config(&bitcoind, |params| {
+		let mut config = default_test_config(params);
+		// Insert announcement_addresses after alias line
+		config = config.replace(
+			"alias = \"e2e-test-node\"",
+			&format!(
+				"alias = \"e2e-test-node\"\nannouncement_addresses = [\"127.0.0.1:{}\"]",
+				params.p2p_port
+			),
+		);
+		config
+	})
+	.await;
+	let info = server.client().get_node_info(GetNodeInfoRequest {}).await.unwrap();
+	assert!(info.current_best_block.is_some());
+}
+
+#[tokio::test]
+async fn test_config_with_log_file() {
+	let bitcoind = TestBitcoind::new();
+	let server = LdkServerHandle::start_with_config(&bitcoind, |params| {
+		let log_path = format!("{}/ldk-server.log", params.storage_dir.display());
+		let mut config = default_test_config(params);
+		config.push_str(&format!("\n[log]\nlevel = \"Debug\"\nfile = \"{}\"\n", log_path));
+		config
+	})
+	.await;
+	let info = server.client().get_node_info(GetNodeInfoRequest {}).await.unwrap();
+	assert!(info.current_best_block.is_some());
+}
+
+#[tokio::test]
+async fn test_config_with_tls_hosts() {
+	let bitcoind = TestBitcoind::new();
+	let server = LdkServerHandle::start_with_config(&bitcoind, |params| {
+		let mut config = default_test_config(params);
+		config.push_str("\n[tls]\nhosts = [\"example.com\", \"ldk-server.local\"]\n");
+		config
+	})
+	.await;
+	let info = server.client().get_node_info(GetNodeInfoRequest {}).await.unwrap();
+	assert!(info.current_best_block.is_some());
+}
+
+#[test]
+fn test_config_fail_log_file_matches_storage_dir() {
+	let bitcoind = TestBitcoind::new();
+	let stderr = start_expect_failure(&bitcoind, |params| {
+		let mut config = default_test_config(params);
+		config.push_str(&format!("\n[log]\nfile = \"{}\"\n", params.storage_dir.display()));
+		config
+	});
+	assert!(
+		stderr.contains("Log file path cannot be the same as storage directory path"),
+		"Unexpected stderr: {stderr}"
+	);
+}
+
+#[test]
+fn test_config_fail_log_file_matches_network_dir() {
+	let bitcoind = TestBitcoind::new();
+	let stderr = start_expect_failure(&bitcoind, |params| {
+		let mut config = default_test_config(params);
+		let network_dir = params.storage_dir.join("regtest");
+		config.push_str(&format!("\n[log]\nfile = \"{}\"\n", network_dir.display()));
+		config
+	});
+	assert!(
+		stderr.contains("Log file path cannot be the same as storage directory path"),
+		"Unexpected stderr: {stderr}"
+	);
+}
+
+#[tokio::test]
+async fn test_config_chain_source_bitcoind_localhost() {
+	let bitcoind = TestBitcoind::new();
+	let server = LdkServerHandle::start_with_config(&bitcoind, |params| {
+		// Use "localhost:port" instead of "127.0.0.1:port" to test hostname RPC support
+		let rpc_address = params.rpc_address.replace("127.0.0.1", "localhost");
+		test_config_with_chain_source(
+			params,
+			&format!(
+				"[bitcoind]\nrpc_address = \"{}\"\nrpc_user = \"{}\"\nrpc_password = \"{}\"",
+				rpc_address, params.rpc_user, params.rpc_password
+			),
+		)
+	})
+	.await;
+	let info = server.client().get_node_info(GetNodeInfoRequest {}).await.unwrap();
+	assert!(info.current_best_block.is_some());
+}

e2e-tests/tests/e2e.rs

@@ -1429,7 +1429,7 @@ async fn test_metrics_endpoint_with_auth() {
 	let config =
 		LdkServerConfig { metrics_auth: Some((username.to_string(), password.to_string())) };
 
-	let server = LdkServerHandle::start_with_config(&bitcoind, config).await;
+	let server = LdkServerHandle::start_with_options(&bitcoind, config).await;
 	let client = server.client();
 
 	// Should fail because auth is provided in the config