test(logwriter): forward logs to mock in-memory log logger

Author: enigbe

Cargo.toml

@@ -75,7 +75,7 @@ libc = "0.2"
 uniffi = { version = "0.27.3", features = ["build"], optional = true }
 serde = { version = "1.0.210", default-features = false, features = ["std", "derive"] }
 serde_json = { version = "1.0.128", default-features = false, features = ["std"] }
-log = { version = "0.4.22" }
+log = { version = "0.4.22", features = ["std"]}
 
 vss-client = "0.3"
 prost = { version = "0.11.6", default-features = false}

src/config.rs

@@ -430,7 +430,7 @@ impl From<MaxDustHTLCExposure> for LdkMaxDustHTLCExposure {
 }
 
 /// Configuration options for logging to the filesystem.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct FilesystemLoggerConfig {
 	/// The log file path.
 	///
@@ -442,7 +442,7 @@ pub struct FilesystemLoggerConfig {
 }
 
 /// Configuration options for logging to the `log` facade.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct LogFacadeLoggerConfig {
 	/// This specifies the log level.
 	pub level: LdkLevel,

tests/common/mod.rs

@@ -12,7 +12,8 @@ use ldk_node::config::{Config, EsploraSyncConfig};
 use ldk_node::io::sqlite_store::SqliteStore;
 use ldk_node::payment::{PaymentDirection, PaymentKind, PaymentStatus};
 use ldk_node::{
-	Builder, CustomTlvRecord, Event, LightningBalance, Node, NodeError, PendingSweepBalance,
+	Builder, CustomTlvRecord, Event, FilesystemLoggerConfig, LightningBalance,
+	LogFacadeLoggerConfig, Node, NodeError, PendingSweepBalance,
 };
 
 use lightning::ln::msgs::SocketAddress;
@@ -36,9 +37,11 @@ use electrum_client::ElectrumApi;
 use rand::distributions::Alphanumeric;
 use rand::{thread_rng, Rng};
 
+use log::{LevelFilter, Log};
+
 use std::env;
 use std::path::PathBuf;
-use std::sync::{Arc, RwLock};
+use std::sync::{Arc, Mutex, RwLock};
 use std::time::Duration;
 
 macro_rules! expect_event {
@@ -247,6 +250,47 @@ pub(crate) enum TestChainSource<'a> {
 	BitcoindRpc(&'a BitcoinD),
 }
 
+#[derive(Clone)]
+pub(crate) enum TestLogWriter {
+	File(FilesystemLoggerConfig),
+	LogFacade(LogFacadeLoggerConfig),
+}
+
+/// Simple in-memory mock `log` logger for tests.
+pub(crate) struct MockLogger {
+	logs: Arc<Mutex<Vec<String>>>,
+}
+
+impl MockLogger {
+	pub fn new() -> Self {
+		Self { logs: Arc::new(Mutex::new(Vec::new())) }
+	}
+
+	pub fn retrieve_logs(&self) -> Vec<String> {
+		self.logs.lock().unwrap().clone()
+	}
+}
+
+impl Log for MockLogger {
+	fn log(&self, record: &log::Record) {
+		let message = format!("[{}] {}", record.level(), record.args());
+		self.logs.lock().unwrap().push(message);
+	}
+
+	fn enabled(&self, _metadata: &log::Metadata) -> bool {
+		true
+	}
+
+	fn flush(&self) {}
+}
+
+pub(crate) fn init_mock_logger(level: LevelFilter) -> Arc<MockLogger> {
+	let logger = Arc::new(MockLogger::new());
+	log::set_boxed_logger(Box::new(logger.clone())).unwrap();
+	log::set_max_level(level);
+	logger
+}
+
 macro_rules! setup_builder {
 	($builder: ident, $config: expr) => {
 		#[cfg(feature = "uniffi")]
@@ -260,11 +304,11 @@ pub(crate) use setup_builder;
 
 pub(crate) fn setup_two_nodes(
 	chain_source: &TestChainSource, allow_0conf: bool, anchor_channels: bool,
-	anchors_trusted_no_reserve: bool,
+	anchors_trusted_no_reserve: bool, log_writer: TestLogWriter,
 ) -> (TestNode, TestNode) {
 	println!("== Node A ==");
 	let config_a = random_config(anchor_channels);
-	let node_a = setup_node(chain_source, config_a, None);
+	let node_a = setup_node(chain_source, config_a, None, log_writer.clone());
 
 	println!("\n== Node B ==");
 	let mut config_b = random_config(anchor_channels);
@@ -279,12 +323,13 @@ pub(crate) fn setup_two_nodes(
 			.trusted_peers_no_reserve
 			.push(node_a.node_id());
 	}
-	let node_b = setup_node(chain_source, config_b, None);
+	let node_b = setup_node(chain_source, config_b, None, log_writer);
 	(node_a, node_b)
 }
 
 pub(crate) fn setup_node(
 	chain_source: &TestChainSource, config: Config, seed_bytes: Option<Vec<u8>>,
+	log_writer: TestLogWriter,
 ) -> TestNode {
 	setup_builder!(builder, config);
 	match chain_source {
@@ -305,6 +350,15 @@ pub(crate) fn setup_node(
 		},
 	}
 
+	match log_writer {
+		TestLogWriter::File(fs_config) => {
+			builder.set_filesystem_logger(fs_config);
+		},
+		TestLogWriter::LogFacade(lf_config) => {
+			builder.set_log_facade_logger(lf_config);
+		},
+	}
+
 	if let Some(seed) = seed_bytes {
 		builder.set_entropy_seed_bytes(seed).unwrap();
 	}

tests/integration_tests_rust.rs

@@ -9,14 +9,15 @@ mod common;
 
 use common::{
 	do_channel_full_cycle, expect_channel_ready_event, expect_event, expect_payment_received_event,
-	expect_payment_successful_event, generate_blocks_and_wait, open_channel,
+	expect_payment_successful_event, generate_blocks_and_wait, init_mock_logger, open_channel,
 	premine_and_distribute_funds, random_config, setup_bitcoind_and_electrsd, setup_builder,
-	setup_node, setup_two_nodes, wait_for_tx, TestChainSource, TestSyncStore,
+	setup_node, setup_two_nodes, wait_for_tx, TestChainSource, TestLogWriter, TestSyncStore,
 };
 
 use ldk_node::config::{EsploraSyncConfig, FilesystemLoggerConfig};
 use ldk_node::payment::{PaymentKind, QrPaymentResult, SendingParameters};
-use ldk_node::{Builder, Event, NodeError};
+use ldk_node::LdkLevel;
+use ldk_node::{Builder, Event, LogFacadeLoggerConfig, NodeError};
 
 use lightning::ln::channelmanager::PaymentId;
 use lightning::util::logger::Level;
@@ -32,55 +33,62 @@ use std::sync::Arc;
 fn channel_full_cycle() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false, log_writer);
 	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false, true, false);
 }
 
 #[test]
 fn channel_full_cycle_bitcoind() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::BitcoindRpc(&bitcoind);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false, log_writer);
 	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false, true, false);
 }
 
 #[test]
 fn channel_full_cycle_force_close() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false, log_writer);
 	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false, true, true);
 }
 
 #[test]
 fn channel_full_cycle_force_close_trusted_no_reserve() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, true);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, true, log_writer);
 	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false, true, true);
 }
 
 #[test]
 fn channel_full_cycle_0conf() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, true, true, false);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, true, true, false, log_writer);
 	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, true, true, false)
 }
 
 #[test]
 fn channel_full_cycle_legacy_staticremotekey() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, false, false);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, false, false, log_writer);
 	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false, false, false);
 }
 
 #[test]
 fn channel_open_fails_when_funds_insufficient() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false, log_writer);
 
 	let addr_a = node_a.onchain_payment().new_address().unwrap();
 	let addr_b = node_b.onchain_payment().new_address().unwrap();
@@ -280,7 +288,8 @@ fn start_stop_reinit() {
 fn onchain_spend_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false, log_writer);
 
 	let addr_a = node_a.onchain_payment().new_address().unwrap();
 	let addr_b = node_b.onchain_payment().new_address().unwrap();
@@ -381,7 +390,9 @@ fn onchain_wallet_recovery() {
 	let seed_bytes = vec![42u8; 64];
 
 	let original_config = random_config(true);
-	let original_node = setup_node(&chain_source, original_config, Some(seed_bytes.clone()));
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let original_node =
+		setup_node(&chain_source, original_config, Some(seed_bytes.clone()), log_writer);
 
 	let premine_amount_sat = 100_000;
 
@@ -426,7 +437,8 @@ fn onchain_wallet_recovery() {
 
 	// Now we start from scratch, only the seed remains the same.
 	let recovered_config = random_config(true);
-	let recovered_node = setup_node(&chain_source, recovered_config, Some(seed_bytes));
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let recovered_node = setup_node(&chain_source, recovered_config, Some(seed_bytes), log_writer);
 
 	recovered_node.sync_wallets().unwrap();
 	assert_eq!(
@@ -469,7 +481,8 @@ fn sign_verify_msg() {
 	let (_bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let config = random_config(true);
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let node = setup_node(&chain_source, config, None);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let node = setup_node(&chain_source, config, None, log_writer);
 
 	// Tests arbitrary message signing and later verification
 	let msg = "OK computer".as_bytes();
@@ -487,7 +500,8 @@ fn connection_restart_behavior() {
 fn do_connection_restart_behavior(persist: bool) {
 	let (_bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, false, false);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, false, false, log_writer);
 
 	let node_id_a = node_a.node_id();
 	let node_id_b = node_b.node_id();
@@ -539,7 +553,8 @@ fn do_connection_restart_behavior(persist: bool) {
 fn concurrent_connections_succeed() {
 	let (_bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false, log_writer);
 
 	let node_a = Arc::new(node_a);
 	let node_b = Arc::new(node_b);
@@ -570,7 +585,8 @@ fn concurrent_connections_succeed() {
 fn simple_bolt12_send_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false, log_writer);
 
 	let address_a = node_a.onchain_payment().new_address().unwrap();
 	let premine_amount_sat = 5_000_000;
@@ -778,7 +794,8 @@ fn simple_bolt12_send_receive() {
 fn generate_bip21_uri() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false, log_writer);
 
 	let address_a = node_a.onchain_payment().new_address().unwrap();
 	let premined_sats = 5_000_000;
@@ -820,7 +837,10 @@ fn generate_bip21_uri() {
 fn unified_qr_send_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+
+	let mock_logger = init_mock_logger(log::LevelFilter::Trace);
+	let log_writer = TestLogWriter::LogFacade(LogFacadeLoggerConfig { level: LdkLevel::Trace });
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false, log_writer);
 
 	let address_a = node_a.onchain_payment().new_address().unwrap();
 	let premined_sats = 5_000_000;
@@ -926,4 +946,10 @@ fn unified_qr_send_receive() {
 
 	assert_eq!(node_b.list_balances().total_onchain_balance_sats, 800_000);
 	assert_eq!(node_b.list_balances().total_lightning_balance_sats, 200_000);
+
+	assert!(mock_logger
+		.retrieve_logs()
+		.last()
+		.unwrap()
+		.contains("Incremental sync of on-chain wallet finished"),);
 }