Prevent other tests from failing

Author: chuksys

bindings/kotlin/ldk-node-jvm/lib/src/test/kotlin/org/lightningdevkit/ldknode/LibraryTest.kt

@@ -176,13 +176,29 @@ class LibraryTest {
         config1.storageDirPath = tmpDir1
         config1.listeningAddresses = listOf(listenAddress1)
         config1.network = Network.REGTEST
+        if (System.getenv("HRN_TESTS") == null) {
+            config1.hrnConfig = HumanReadableNamesConfig(
+                resolutionConfig = HrnResolverConfig.Dns(
+                    dnsServerAddress = "8.8.8.8:53",
+                    enableHrnResolutionService = false
+                )
+            )
+        }
 
         println("Config 1: $config1")
 
         val config2 = defaultConfig()
         config2.storageDirPath = tmpDir2
         config2.listeningAddresses = listOf(listenAddress2)
         config2.network = Network.REGTEST
+        if (System.getenv("HRN_TESTS") == null) {
+            config2.hrnConfig = HumanReadableNamesConfig(
+                resolutionConfig = HrnResolverConfig.Dns(
+                    dnsServerAddress = "8.8.8.8:53",
+                    enableHrnResolutionService = false
+                )
+            )
+        }
         println("Config 2: $config2")
 
         val builder1 = Builder.fromConfig(config1)

bindings/python/src/ldk_node/test_ldk_node.py

@@ -100,6 +100,8 @@ def setup_node(tmp_dir, esplora_endpoint, listening_addresses):
     mnemonic = generate_entropy_mnemonic(None)
     node_entropy = NodeEntropy.from_bip39_mnemonic(mnemonic, None)
     config = default_config()
+    if os.getenv("HRN_TESTS") is None:
+        config.hrn_config.resolution_config = HrnResolverConfig.DNS("8.8.8.8:53", False)
     builder = Builder.from_config(config)
     builder.set_storage_dir_path(tmp_dir)
     builder.set_chain_source_esplora(esplora_endpoint, None)

src/lib.rs

@@ -1940,13 +1940,17 @@ impl Node {
 	/// For example, you could retrieve all stored outbound payments as follows:
 	/// ```
 	/// # use ldk_node::Builder;
-	/// # use ldk_node::config::Config;
+	/// # use ldk_node::config::{Config, HRNResolverConfig};
 	/// # use ldk_node::payment::PaymentDirection;
 	/// # use ldk_node::bitcoin::Network;
 	/// # use ldk_node::entropy::{generate_entropy_mnemonic, NodeEntropy};
 	/// # use rand::distr::Alphanumeric;
 	/// # use rand::{rng, Rng};
 	/// # let mut config = Config::default();
+	/// # config.hrn_config.resolution_config = HRNResolverConfig::Dns {
+	/// # dns_server_address: "8.8.8.8:53".to_string(),
+	/// # enable_hrn_resolution_service: false,
+	/// # };
 	/// # config.network = Network::Regtest;
 	/// # let mut temp_path = std::env::temp_dir();
 	/// # let rand_dir: String = (0..7).map(|_| rng().sample(Alphanumeric) as char).collect();

tests/common/mod.rs

@@ -294,6 +294,13 @@ pub(crate) fn random_node_alias() -> Option<NodeAlias> {
 pub(crate) fn random_config(anchor_channels: bool) -> TestConfig {
 	let mut node_config = Config::default();
 
+	if !cfg!(hrn_tests) {
+		node_config.hrn_config.resolution_config = HRNResolverConfig::Dns {
+			dns_server_address: "8.8.8.8:53".to_string(),
+			enable_hrn_resolution_service: false,
+		};
+	}
+
 	if !anchor_channels {
 		node_config.anchor_channels_config = None;
 	}

tests/integration_tests_rust.rs

@@ -28,7 +28,7 @@ use common::{
 };
 use electrsd::corepc_node::Node as BitcoinD;
 use electrsd::ElectrsD;
-use ldk_node::config::{AsyncPaymentsRole, EsploraSyncConfig};
+use ldk_node::config::{AsyncPaymentsRole, Config, EsploraSyncConfig, HRNResolverConfig};
 use ldk_node::entropy::NodeEntropy;
 use ldk_node::liquidity::LSPS2ServiceConfig;
 use ldk_node::payment::{
@@ -1295,6 +1295,10 @@ async fn async_payment() {
 	let mut config_sender = random_config(true);
 	config_sender.node_config.listening_addresses = None;
 	config_sender.node_config.node_alias = None;
+	config_sender.node_config.hrn_config.resolution_config = HRNResolverConfig::Dns {
+		dns_server_address: "8.8.8.8:53".to_string(),
+		enable_hrn_resolution_service: false,
+	};
 	config_sender.log_writer =
 		TestLogWriter::Custom(Arc::new(MultiNodeLogger::new("sender      ".to_string())));
 	config_sender.async_payments_role = Some(AsyncPaymentsRole::Client);
@@ -1316,6 +1320,10 @@ async fn async_payment() {
 	let mut config_receiver = random_config(true);
 	config_receiver.node_config.listening_addresses = None;
 	config_receiver.node_config.node_alias = None;
+	config_receiver.node_config.hrn_config.resolution_config = HRNResolverConfig::Dns {
+		dns_server_address: "8.8.8.8:53".to_string(),
+		enable_hrn_resolution_service: false,
+	};
 	config_receiver.log_writer =
 		TestLogWriter::Custom(Arc::new(MultiNodeLogger::new("receiver    ".to_string())));
 	let node_receiver = setup_node(&chain_source, config_receiver);
@@ -2520,11 +2528,17 @@ async fn do_persistence_backwards_compatibility(version: OldLdkVersion) {
 		},
 	};
 
+	let mut config = Config::default();
+	config.hrn_config.resolution_config = HRNResolverConfig::Dns {
+		dns_server_address: "8.8.8.8:53".to_string(),
+		enable_hrn_resolution_service: false,
+	};
+
 	// Now ensure we can still reinit from the same backend.
 	#[cfg(feature = "uniffi")]
-	let builder_new = Builder::new();
+	let builder_new = Builder::from_config(config);
 	#[cfg(not(feature = "uniffi"))]
-	let mut builder_new = Builder::new();
+	let mut builder_new = Builder::from_config(config);
 	builder_new.set_network(bitcoin::Network::Regtest);
 	builder_new.set_storage_dir_path(storage_path);
 	builder_new.set_chain_source_esplora(esplora_url, None);

tests/integration_tests_vss.rs

@@ -11,8 +11,10 @@ mod common;
 
 use std::collections::HashMap;
 
+use ldk_node::config::{Config, HRNResolverConfig};
 use ldk_node::entropy::NodeEntropy;
 use ldk_node::Builder;
+use ldk_node_070::lightning::util::config;
 use rand::RngCore;
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
@@ -73,7 +75,12 @@ async fn vss_node_restart() {
 
 	// Setup initial node and fund it.
 	let (expected_balance_sats, expected_node_id) = {
-		let mut builder = Builder::new();
+		let mut config = Config::default();
+		config.hrn_config.resolution_config = HRNResolverConfig::Dns {
+			dns_server_address: "8.8.8.8:53".to_string(),
+			enable_hrn_resolution_service: false,
+		};
+		let mut builder = Builder::from_config(config);
 		builder.set_network(bitcoin::Network::Regtest);
 		builder.set_storage_dir_path(storage_path.clone());
 		builder.set_chain_source_esplora(esplora_url.clone(), None);
@@ -105,8 +112,14 @@ async fn vss_node_restart() {
 		(balance, node_id)
 	};
 
+	let mut config = Config::default();
+	config.hrn_config.resolution_config = HRNResolverConfig::Dns {
+		dns_server_address: "8.8.8.8:53".to_string(),
+		enable_hrn_resolution_service: false,
+	};
+
 	// Verify node can be restarted from VSS backend.
-	let mut builder = Builder::new();
+	let mut builder = Builder::from_config(config);
 	builder.set_network(bitcoin::Network::Regtest);
 	builder.set_storage_dir_path(storage_path);
 	builder.set_chain_source_esplora(esplora_url, None);

tests/integration_tests_vss_no_auth.rs

@@ -11,8 +11,9 @@ mod common;
 
 use std::collections::HashMap;
 
-use ldk_node::entropy::NodeEntropy;
-use ldk_node::Builder;
+use ldk_node::config::{Config, HRNResolverConfig};
+use ldk_node::{entropy::NodeEntropy, Builder};
+use ldk_node_070::lightning::util::config;
 use rand::{rng, Rng, RngCore};
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
@@ -69,7 +70,13 @@ async fn vss_v0_schema_backwards_compatibility() {
 	};
 
 	// Now ensure we can still reinit from the same backend.
-	let mut builder_new = Builder::new();
+	let mut config = Config::default();
+	config.hrn_config.resolution_config = HRNResolverConfig::Dns {
+		dns_server_address: "8.8.8.8:53".to_string(),
+		enable_hrn_resolution_service: false,
+	};
+	let mut builder_new = Builder::from_config(config);
+
 	builder_new.set_network(bitcoin::Network::Regtest);
 	builder_new.set_storage_dir_path(storage_path);
 	builder_new.set_chain_source_esplora(esplora_url, None);