From 30848af634d091ec2293624dca66dc62a20304f4 Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Tue, 19 Dec 2023 10:10:32 +0100 Subject: [PATCH 1/5] Use `fn_params_layout` in `rustfmt` --- rustfmt.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rustfmt.toml b/rustfmt.toml index c00f65546a..34eece0249 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -2,4 +2,4 @@ hard_tabs = true # use tab characters for indentation, spaces for alignment use_field_init_shorthand = true max_width = 100 use_small_heuristics = "Max" -fn_args_layout = "Compressed" +fn_params_layout = "Compressed" From 139f58fa76d23fabd255002a5a132660914d6260 Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Mon, 18 Dec 2023 14:30:57 +0100 Subject: [PATCH 2/5] Make CI script names more homogeneous --- .github/workflows/{cln.yml => cln-integration.yml} | 2 +- .github/workflows/kotlin.yml | 2 +- .github/workflows/python.yml | 2 +- .github/workflows/{build.yml => rust.yml} | 2 +- .github/workflows/vss-integration.yml | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) rename .github/workflows/{cln.yml => cln-integration.yml} (95%) rename .github/workflows/{build.yml => rust.yml} (98%) diff --git a/.github/workflows/cln.yml b/.github/workflows/cln-integration.yml similarity index 95% rename from .github/workflows/cln.yml rename to .github/workflows/cln-integration.yml index df82504608..2c427cbdeb 100644 --- a/.github/workflows/cln.yml +++ b/.github/workflows/cln-integration.yml @@ -1,4 +1,4 @@ -name: Continuous Integration Checks - CLN +name: CI Checks - CLN Integration Tests on: [push, pull_request] diff --git a/.github/workflows/kotlin.yml b/.github/workflows/kotlin.yml index 7182d76480..47e51b5d72 100644 --- a/.github/workflows/kotlin.yml +++ b/.github/workflows/kotlin.yml @@ -1,4 +1,4 @@ -name: Continuous Integration Checks - Kotlin +name: CI Checks - Kotlin Tests on: [push, pull_request] diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index 4269c69bf6..21c0139a22 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -1,4 +1,4 @@ -name: Continuous Integration Checks - Python +name: CI Checks - Python Tests on: [push, pull_request] diff --git a/.github/workflows/build.yml b/.github/workflows/rust.yml similarity index 98% rename from .github/workflows/build.yml rename to .github/workflows/rust.yml index dfd6824889..a76e1e6636 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/rust.yml @@ -1,4 +1,4 @@ -name: Continuous Integration Checks +name: CI Checks - Rust Tests on: [push, pull_request] diff --git a/.github/workflows/vss-integration.yml b/.github/workflows/vss-integration.yml index c41e5f9f03..0afba97111 100644 --- a/.github/workflows/vss-integration.yml +++ b/.github/workflows/vss-integration.yml @@ -1,4 +1,4 @@ -name: VSS Integration Test +name: CI Checks - VSS Integration Tests on: [push, pull_request] From 14c0d37e29acc098acf03aab758d9cde7e9083a1 Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Mon, 18 Dec 2023 15:00:55 +0100 Subject: [PATCH 3/5] Move VSS integration tests to integration test folder --- .github/workflows/vss-integration.yml | 4 +- Cargo.toml | 2 +- src/test/functional_tests.rs | 23 --- tests/common.rs | 281 +++++++++++++++++++++++++- tests/integration_tests_vss.rs | 27 +++ 5 files changed, 300 insertions(+), 37 deletions(-) create mode 100644 tests/integration_tests_vss.rs diff --git a/.github/workflows/vss-integration.yml b/.github/workflows/vss-integration.yml index 0afba97111..df739abce4 100644 --- a/.github/workflows/vss-integration.yml +++ b/.github/workflows/vss-integration.yml @@ -74,8 +74,8 @@ jobs: run: | cd ldk-node export TEST_VSS_BASE_URL="http://localhost:8080/vss" - RUSTFLAGS="--cfg=vss_test --cfg=vss" cargo build --verbose --color always - RUSTFLAGS="--cfg=vss_test --cfg=vss" cargo test -- --nocapture + RUSTFLAGS="--cfg vss_test --cfg vss" cargo build --verbose --color always + RUSTFLAGS="--cfg vss_test --cfg vss" cargo test --test integration_tests_vss - name: Cleanup run: | diff --git a/Cargo.toml b/Cargo.toml index 8d57cd3934..c336cdeef8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -78,12 +78,12 @@ lightning = { version = "0.0.119", features = ["std", "_test_utils"] } #lightning = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main", features = ["std", "_test_utils"] } electrsd = { version = "0.26.0", features = ["legacy", "esplora_a33e97e1", "bitcoind_25_0"] } electrum-client = { version = "0.18.0", default-features = true } +bitcoincore-rpc = { version = "0.17.0", default-features = false } proptest = "1.0.0" regex = "1.5.6" [target.'cfg(cln_test)'.dev-dependencies] clightningrpc = { version = "0.3.0-beta.8", default-features = false } -bitcoincore-rpc = { version = "0.17.0", default-features = false } [build-dependencies] uniffi = { version = "0.25.1", features = ["build"], optional = true } diff --git a/src/test/functional_tests.rs b/src/test/functional_tests.rs index 3600ee1164..c9796b9827 100644 --- a/src/test/functional_tests.rs +++ b/src/test/functional_tests.rs @@ -18,29 +18,6 @@ fn channel_full_cycle() { do_channel_full_cycle(node_a, node_b, &bitcoind, &electrsd, false); } -#[test] -#[cfg(vss_test)] -fn channel_full_cycle_with_vss_store() { - let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); - println!("== Node A =="); - let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap()); - let config_a = random_config(); - let mut builder_a = NodeBuilder::from_config(config_a); - builder_a.set_esplora_server(esplora_url.clone()); - let vss_base_url = std::env::var("TEST_VSS_BASE_URL").unwrap(); - let node_a = builder_a.build_with_vss_store(&vss_base_url, "node_1_store".to_string()).unwrap(); - node_a.start().unwrap(); - - println!("\n== Node B =="); - let config_b = random_config(); - let mut builder_b = NodeBuilder::from_config(config_b); - builder_b.set_esplora_server(esplora_url); - let node_b = builder_b.build_with_vss_store(&vss_base_url, "node_2_store".to_string()).unwrap(); - node_b.start().unwrap(); - - do_channel_full_cycle(node_a, node_b, &bitcoind, &electrsd, false); -} - #[test] fn channel_full_cycle_0conf() { let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); diff --git a/tests/common.rs b/tests/common.rs index 381827d7fb..d1adb3f4b6 100644 --- a/tests/common.rs +++ b/tests/common.rs @@ -1,8 +1,9 @@ -#![cfg(cln_test)] +#![cfg(any(cln_test, vss_test))] -use ldk_node::{Config, LogLevel, Network}; +use ldk_node::{Config, Event, LogLevel, Network, Node, NodeError, PaymentDirection, PaymentStatus}; use lightning::ln::msgs::SocketAddress; +use lightning::util::persist::KVStore; use bitcoin::{Address, Amount, OutPoint, Txid}; @@ -10,12 +11,13 @@ use bitcoincore_rpc::bitcoincore_rpc_json::AddressType; use bitcoincore_rpc::Client as BitcoindClient; use bitcoincore_rpc::RpcApi; -use electrum_client::Client as ElectrumClient; +use electrsd::{bitcoind, bitcoind::BitcoinD, ElectrsD}; use electrum_client::ElectrumApi; use rand::distributions::Alphanumeric; use rand::{thread_rng, Rng}; +use std::env; use std::path::PathBuf; use std::time::Duration; @@ -71,6 +73,26 @@ macro_rules! expect_channel_ready_event { pub(crate) use expect_channel_ready_event; +pub(crate) fn setup_bitcoind_and_electrsd() -> (BitcoinD, ElectrsD) { + let bitcoind_exe = + env::var("BITCOIND_EXE").ok().or_else(|| bitcoind::downloaded_exe_path().ok()).expect( + "you need to provide an env var BITCOIND_EXE or specify a bitcoind version feature", + ); + let mut bitcoind_conf = bitcoind::Conf::default(); + bitcoind_conf.network = "regtest"; + let bitcoind = BitcoinD::with_conf(bitcoind_exe, &bitcoind_conf).unwrap(); + + let electrs_exe = env::var("ELECTRS_EXE") + .ok() + .or_else(electrsd::downloaded_exe_path) + .expect("you need to provide env var ELECTRS_EXE or specify an electrsd version feature"); + let mut electrsd_conf = electrsd::Conf::default(); + electrsd_conf.http_enabled = true; + electrsd_conf.network = "regtest"; + let electrsd = ElectrsD::with_conf(electrs_exe, &bitcoind, &electrsd_conf).unwrap(); + (bitcoind, electrsd) +} + pub(crate) fn random_storage_path() -> PathBuf { let mut temp_path = std::env::temp_dir(); let mut rng = thread_rng(); @@ -116,8 +138,8 @@ pub(crate) fn random_config() -> Config { config } -pub(crate) fn generate_blocks_and_wait( - bitcoind: &BitcoindClient, electrs: &ElectrumClient, num: usize, +pub(crate) fn generate_blocks_and_wait( + bitcoind: &BitcoindClient, electrs: &E, num: usize, ) { let _ = bitcoind.create_wallet("ldk_node_test", None, None, None, None); let _ = bitcoind.load_wallet("ldk_node_test"); @@ -135,14 +157,14 @@ pub(crate) fn generate_blocks_and_wait( println!("\n"); } -pub(crate) fn wait_for_block(electrs: &ElectrumClient, min_height: usize) { +pub(crate) fn wait_for_block(electrs: &E, min_height: usize) { let mut header = match electrs.block_headers_subscribe() { Ok(header) => header, Err(_) => { // While subscribing should succeed the first time around, we ran into some cases where // it didn't. Since we can't proceed without subscribing, we try again after a delay // and panic if it still fails. - std::thread::sleep(Duration::from_secs(1)); + std::thread::sleep(Duration::from_secs(3)); electrs.block_headers_subscribe().expect("failed to subscribe to block headers") } }; @@ -157,7 +179,7 @@ pub(crate) fn wait_for_block(electrs: &ElectrumClient, min_height: usize) { } } -pub(crate) fn wait_for_tx(electrs: &ElectrumClient, txid: Txid) { +pub(crate) fn wait_for_tx(electrs: &E, txid: Txid) { let mut tx_res = electrs.transaction_get(&txid); loop { if tx_res.is_ok() { @@ -170,7 +192,7 @@ pub(crate) fn wait_for_tx(electrs: &ElectrumClient, txid: Txid) { } } -pub(crate) fn wait_for_outpoint_spend(electrs: &ElectrumClient, outpoint: OutPoint) { +pub(crate) fn wait_for_outpoint_spend(electrs: &E, outpoint: OutPoint) { let tx = electrs.transaction_get(&outpoint.txid).unwrap(); let txout_script = tx.output.get(outpoint.vout as usize).unwrap().clone().script_pubkey; let mut is_spent = !electrs.script_get_history(&txout_script).unwrap().is_empty(); @@ -207,8 +229,8 @@ where } } -pub(crate) fn premine_and_distribute_funds( - bitcoind: &BitcoindClient, electrs: &ElectrumClient, addrs: Vec
, amount: Amount, +pub(crate) fn premine_and_distribute_funds( + bitcoind: &BitcoindClient, electrs: &E, addrs: Vec
, amount: Amount, ) { let _ = bitcoind.create_wallet("ldk_node_test", None, None, None, None); let _ = bitcoind.load_wallet("ldk_node_test"); @@ -222,3 +244,240 @@ pub(crate) fn premine_and_distribute_funds( generate_blocks_and_wait(bitcoind, electrs, 1); } + +pub(crate) fn do_channel_full_cycle( + node_a: Node, node_b: Node, bitcoind: &BitcoindClient, electrsd: &E, allow_0conf: bool, +) { + let addr_a = node_a.new_onchain_address().unwrap(); + let addr_b = node_b.new_onchain_address().unwrap(); + + let premine_amount_sat = 100_000; + + premine_and_distribute_funds( + &bitcoind, + electrsd, + vec![addr_a, addr_b], + Amount::from_sat(premine_amount_sat), + ); + node_a.sync_wallets().unwrap(); + node_b.sync_wallets().unwrap(); + assert_eq!(node_a.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); + assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); + + // Check we haven't got any events yet + assert_eq!(node_a.next_event(), None); + assert_eq!(node_b.next_event(), None); + + println!("\nA -- connect_open_channel -> B"); + let funding_amount_sat = 80_000; + let push_msat = (funding_amount_sat / 2) * 1000; // balance the channel + node_a + .connect_open_channel( + node_b.node_id(), + node_b.listening_addresses().unwrap().first().unwrap().clone(), + funding_amount_sat, + Some(push_msat), + None, + true, + ) + .unwrap(); + + assert_eq!(node_a.list_peers().first().unwrap().node_id, node_b.node_id()); + let funding_txo_a = expect_channel_pending_event!(node_a, node_b.node_id()); + let funding_txo_b = expect_channel_pending_event!(node_b, node_a.node_id()); + assert_eq!(funding_txo_a, funding_txo_b); + + wait_for_tx(electrsd, funding_txo_a.txid); + + if !allow_0conf { + generate_blocks_and_wait(&bitcoind, electrsd, 6); + } + + node_a.sync_wallets().unwrap(); + node_b.sync_wallets().unwrap(); + + let onchain_fee_buffer_sat = 1500; + let node_a_upper_bound_sat = premine_amount_sat - funding_amount_sat; + let node_a_lower_bound_sat = premine_amount_sat - funding_amount_sat - onchain_fee_buffer_sat; + assert!(node_a.spendable_onchain_balance_sats().unwrap() < node_a_upper_bound_sat); + assert!(node_a.spendable_onchain_balance_sats().unwrap() > node_a_lower_bound_sat); + assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); + + expect_channel_ready_event!(node_a, node_b.node_id()); + + let channel_id = expect_channel_ready_event!(node_b, node_a.node_id()); + + println!("\nB receive_payment"); + let invoice_amount_1_msat = 2500_000; + let invoice = node_b.receive_payment(invoice_amount_1_msat, &"asdf", 9217).unwrap(); + + println!("\nA send_payment"); + let payment_hash = node_a.send_payment(&invoice).unwrap(); + assert_eq!(node_a.send_payment(&invoice), Err(NodeError::DuplicatePayment)); + + assert_eq!(node_a.list_payments().first().unwrap().hash, payment_hash); + + let outbound_payments_a = + node_a.list_payments_with_filter(|p| p.direction == PaymentDirection::Outbound); + assert_eq!(outbound_payments_a.len(), 1); + + let inbound_payments_a = + node_a.list_payments_with_filter(|p| p.direction == PaymentDirection::Inbound); + assert_eq!(inbound_payments_a.len(), 0); + + let outbound_payments_b = + node_b.list_payments_with_filter(|p| p.direction == PaymentDirection::Outbound); + assert_eq!(outbound_payments_b.len(), 0); + + let inbound_payments_b = + node_b.list_payments_with_filter(|p| p.direction == PaymentDirection::Inbound); + assert_eq!(inbound_payments_b.len(), 1); + + expect_event!(node_a, PaymentSuccessful); + expect_event!(node_b, PaymentReceived); + assert_eq!(node_a.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); + assert_eq!(node_a.payment(&payment_hash).unwrap().direction, PaymentDirection::Outbound); + assert_eq!(node_a.payment(&payment_hash).unwrap().amount_msat, Some(invoice_amount_1_msat)); + assert_eq!(node_b.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); + assert_eq!(node_b.payment(&payment_hash).unwrap().direction, PaymentDirection::Inbound); + assert_eq!(node_b.payment(&payment_hash).unwrap().amount_msat, Some(invoice_amount_1_msat)); + + // Assert we fail duplicate outbound payments and check the status hasn't changed. + assert_eq!(Err(NodeError::DuplicatePayment), node_a.send_payment(&invoice)); + assert_eq!(node_a.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); + assert_eq!(node_a.payment(&payment_hash).unwrap().direction, PaymentDirection::Outbound); + assert_eq!(node_a.payment(&payment_hash).unwrap().amount_msat, Some(invoice_amount_1_msat)); + assert_eq!(node_b.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); + assert_eq!(node_b.payment(&payment_hash).unwrap().direction, PaymentDirection::Inbound); + assert_eq!(node_b.payment(&payment_hash).unwrap().amount_msat, Some(invoice_amount_1_msat)); + + // Test under-/overpayment + let invoice_amount_2_msat = 2500_000; + let invoice = node_b.receive_payment(invoice_amount_2_msat, &"asdf", 9217).unwrap(); + + let underpaid_amount = invoice_amount_2_msat - 1; + assert_eq!( + Err(NodeError::InvalidAmount), + node_a.send_payment_using_amount(&invoice, underpaid_amount) + ); + + println!("\nB overpaid receive_payment"); + let invoice = node_b.receive_payment(invoice_amount_2_msat, &"asdf", 9217).unwrap(); + let overpaid_amount_msat = invoice_amount_2_msat + 100; + + println!("\nA overpaid send_payment"); + let payment_hash = node_a.send_payment_using_amount(&invoice, overpaid_amount_msat).unwrap(); + expect_event!(node_a, PaymentSuccessful); + let received_amount = match node_b.wait_next_event() { + ref e @ Event::PaymentReceived { amount_msat, .. } => { + println!("{} got event {:?}", std::stringify!(node_b), e); + node_b.event_handled(); + amount_msat + } + ref e => { + panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e); + } + }; + assert_eq!(received_amount, overpaid_amount_msat); + assert_eq!(node_a.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); + assert_eq!(node_a.payment(&payment_hash).unwrap().direction, PaymentDirection::Outbound); + assert_eq!(node_a.payment(&payment_hash).unwrap().amount_msat, Some(overpaid_amount_msat)); + assert_eq!(node_b.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); + assert_eq!(node_b.payment(&payment_hash).unwrap().direction, PaymentDirection::Inbound); + assert_eq!(node_b.payment(&payment_hash).unwrap().amount_msat, Some(overpaid_amount_msat)); + + // Test "zero-amount" invoice payment + println!("\nB receive_variable_amount_payment"); + let variable_amount_invoice = node_b.receive_variable_amount_payment(&"asdf", 9217).unwrap(); + let determined_amount_msat = 2345_678; + assert_eq!(Err(NodeError::InvalidInvoice), node_a.send_payment(&variable_amount_invoice)); + println!("\nA send_payment_using_amount"); + let payment_hash = + node_a.send_payment_using_amount(&variable_amount_invoice, determined_amount_msat).unwrap(); + + expect_event!(node_a, PaymentSuccessful); + let received_amount = match node_b.wait_next_event() { + ref e @ Event::PaymentReceived { amount_msat, .. } => { + println!("{} got event {:?}", std::stringify!(node_b), e); + node_b.event_handled(); + amount_msat + } + ref e => { + panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e); + } + }; + assert_eq!(received_amount, determined_amount_msat); + assert_eq!(node_a.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); + assert_eq!(node_a.payment(&payment_hash).unwrap().direction, PaymentDirection::Outbound); + assert_eq!(node_a.payment(&payment_hash).unwrap().amount_msat, Some(determined_amount_msat)); + assert_eq!(node_b.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); + assert_eq!(node_b.payment(&payment_hash).unwrap().direction, PaymentDirection::Inbound); + assert_eq!(node_b.payment(&payment_hash).unwrap().amount_msat, Some(determined_amount_msat)); + + // Test spontaneous/keysend payments + println!("\nA send_spontaneous_payment"); + let keysend_amount_msat = 2500_000; + let keysend_payment_hash = + node_a.send_spontaneous_payment(keysend_amount_msat, node_b.node_id()).unwrap(); + expect_event!(node_a, PaymentSuccessful); + let received_keysend_amount = match node_b.wait_next_event() { + ref e @ Event::PaymentReceived { amount_msat, .. } => { + println!("{} got event {:?}", std::stringify!(node_b), e); + node_b.event_handled(); + amount_msat + } + ref e => { + panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e); + } + }; + assert_eq!(received_keysend_amount, keysend_amount_msat); + assert_eq!(node_a.payment(&keysend_payment_hash).unwrap().status, PaymentStatus::Succeeded); + assert_eq!( + node_a.payment(&keysend_payment_hash).unwrap().direction, + PaymentDirection::Outbound + ); + assert_eq!( + node_a.payment(&keysend_payment_hash).unwrap().amount_msat, + Some(keysend_amount_msat) + ); + assert_eq!(node_b.payment(&keysend_payment_hash).unwrap().status, PaymentStatus::Succeeded); + assert_eq!(node_b.payment(&keysend_payment_hash).unwrap().direction, PaymentDirection::Inbound); + assert_eq!( + node_b.payment(&keysend_payment_hash).unwrap().amount_msat, + Some(keysend_amount_msat) + ); + + println!("\nB close_channel"); + node_b.close_channel(&channel_id, node_a.node_id()).unwrap(); + expect_event!(node_a, ChannelClosed); + expect_event!(node_b, ChannelClosed); + + wait_for_outpoint_spend(electrsd, funding_txo_b); + + generate_blocks_and_wait(&bitcoind, electrsd, 1); + node_a.sync_wallets().unwrap(); + node_b.sync_wallets().unwrap(); + + let sum_of_all_payments_sat = (push_msat + + invoice_amount_1_msat + + overpaid_amount_msat + + determined_amount_msat + + keysend_amount_msat) + / 1000; + let node_a_upper_bound_sat = + (premine_amount_sat - funding_amount_sat) + (funding_amount_sat - sum_of_all_payments_sat); + let node_a_lower_bound_sat = node_a_upper_bound_sat - onchain_fee_buffer_sat; + assert!(node_a.spendable_onchain_balance_sats().unwrap() > node_a_lower_bound_sat); + assert!(node_a.spendable_onchain_balance_sats().unwrap() < node_a_upper_bound_sat); + let expected_final_amount_node_b_sat = premine_amount_sat + sum_of_all_payments_sat; + assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), expected_final_amount_node_b_sat); + + // Check we handled all events + assert_eq!(node_a.next_event(), None); + assert_eq!(node_b.next_event(), None); + + node_a.stop().unwrap(); + println!("\nA stopped"); + node_b.stop().unwrap(); + println!("\nB stopped"); +} diff --git a/tests/integration_tests_vss.rs b/tests/integration_tests_vss.rs new file mode 100644 index 0000000000..165f6a3861 --- /dev/null +++ b/tests/integration_tests_vss.rs @@ -0,0 +1,27 @@ +#![cfg(vss_test)] + +mod common; + +use ldk_node::Builder; + +#[test] +fn channel_full_cycle_with_vss_store() { + let (bitcoind, electrsd) = common::setup_bitcoind_and_electrsd(); + println!("== Node A =="); + let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap()); + let config_a = common::random_config(); + let mut builder_a = Builder::from_config(config_a); + builder_a.set_esplora_server(esplora_url.clone()); + let vss_base_url = std::env::var("TEST_VSS_BASE_URL").unwrap(); + let node_a = builder_a.build_with_vss_store(&vss_base_url, "node_1_store".to_string()).unwrap(); + node_a.start().unwrap(); + + println!("\n== Node B =="); + let config_b = common::random_config(); + let mut builder_b = Builder::from_config(config_b); + builder_b.set_esplora_server(esplora_url); + let node_b = builder_b.build_with_vss_store(&vss_base_url, "node_2_store".to_string()).unwrap(); + node_b.start().unwrap(); + + common::do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false); +} From 3fdd3b09d776b2fc3d56bcb77006d2c740f5ae4d Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Tue, 19 Dec 2023 18:57:04 +0100 Subject: [PATCH 4/5] Move Rust integration tests to `tests` folder.. .. as all of our tests in `functional_tests.rs` are essentially integration tests. --- Cargo.toml | 2 +- src/event.rs | 3 +- src/io/sqlite_store/migrations.rs | 3 +- src/io/sqlite_store/mod.rs | 5 +- src/io/test_utils.rs | 162 +--------- src/lib.rs | 2 - src/payment_store.rs | 3 +- src/peer_store.rs | 4 +- src/test/functional_tests.rs | 515 ------------------------------ src/test/mod.rs | 2 - src/test/utils.rs | 362 --------------------- tests/common.rs | 223 ++++++++++++- tests/integration_tests_rust.rs | 274 ++++++++++++++++ 13 files changed, 514 insertions(+), 1046 deletions(-) delete mode 100644 src/test/functional_tests.rs delete mode 100644 src/test/mod.rs delete mode 100644 src/test/utils.rs create mode 100644 tests/integration_tests_rust.rs diff --git a/Cargo.toml b/Cargo.toml index c336cdeef8..cf1292a304 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -77,7 +77,7 @@ winapi = { version = "0.3", features = ["winbase"] } lightning = { version = "0.0.119", features = ["std", "_test_utils"] } #lightning = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main", features = ["std", "_test_utils"] } electrsd = { version = "0.26.0", features = ["legacy", "esplora_a33e97e1", "bitcoind_25_0"] } -electrum-client = { version = "0.18.0", default-features = true } +electrum-client = { version = "0.15.1", default-features = true } bitcoincore-rpc = { version = "0.17.0", default-features = false } proptest = "1.0.0" regex = "1.5.6" diff --git a/src/event.rs b/src/event.rs index 56c8f74a2d..192e0b8c26 100644 --- a/src/event.rs +++ b/src/event.rs @@ -795,8 +795,7 @@ where #[cfg(test)] mod tests { use super::*; - use crate::test::utils::TestLogger; - use lightning::util::test_utils::TestStore; + use lightning::util::test_utils::{TestLogger, TestStore}; #[test] fn event_queue_persistence() { diff --git a/src/io/sqlite_store/migrations.rs b/src/io/sqlite_store/migrations.rs index bdf1baf9ad..6d108185a7 100644 --- a/src/io/sqlite_store/migrations.rs +++ b/src/io/sqlite_store/migrations.rs @@ -69,8 +69,7 @@ pub(super) fn migrate_schema( #[cfg(test)] mod tests { use crate::io::sqlite_store::SqliteStore; - use crate::io::test_utils::do_read_write_remove_list_persist; - use crate::test::utils::random_storage_path; + use crate::io::test_utils::{do_read_write_remove_list_persist, random_storage_path}; use lightning::util::persist::KVStore; diff --git a/src/io/sqlite_store/mod.rs b/src/io/sqlite_store/mod.rs index 605c8b77a3..f4c24909d8 100644 --- a/src/io/sqlite_store/mod.rs +++ b/src/io/sqlite_store/mod.rs @@ -284,8 +284,9 @@ impl KVStore for SqliteStore { #[cfg(test)] mod tests { use super::*; - use crate::io::test_utils::{do_read_write_remove_list_persist, do_test_store}; - use crate::test::utils::random_storage_path; + use crate::io::test_utils::{ + do_read_write_remove_list_persist, do_test_store, random_storage_path, + }; impl Drop for SqliteStore { fn drop(&mut self) { diff --git a/src/io/test_utils.rs b/src/io/test_utils.rs index 3abd75b66f..cf3da452dd 100644 --- a/src/io/test_utils.rs +++ b/src/io/test_utils.rs @@ -1,6 +1,3 @@ -use crate::io::sqlite_store::SqliteStore; -use lightning_persister::fs_store::FilesystemStore; - use lightning::ln::functional_test_utils::{ connect_block, create_announced_chan_between_nodes, create_chanmon_cfgs, create_dummy_block, create_network, create_node_cfgs, create_node_chanmgrs, send_payment, @@ -9,12 +6,22 @@ use lightning::util::persist::{read_channel_monitors, KVStore, KVSTORE_NAMESPACE use lightning::chain::channelmonitor::CLOSED_CHANNEL_UPDATE_ID; use lightning::events::ClosureReason; -use lightning::util::test_utils::{self, TestStore}; +use lightning::util::test_utils; use lightning::{check_added_monitors, check_closed_broadcast, check_closed_event}; +use rand::distributions::Alphanumeric; +use rand::{thread_rng, Rng}; + use std::panic::RefUnwindSafe; use std::path::PathBuf; -use std::sync::RwLock; + +pub(crate) fn random_storage_path() -> PathBuf { + let mut temp_path = std::env::temp_dir(); + let mut rng = thread_rng(); + let rand_dir: String = (0..7).map(|_| rng.sample(Alphanumeric) as char).collect(); + temp_path.push(rand_dir); + temp_path +} pub(crate) fn do_read_write_remove_list_persist(kv_store: &K) { let data = [42u8; 32]; @@ -173,148 +180,3 @@ pub(crate) fn do_test_store(store_0: &K, store_1: &K) { // Make sure everything is persisted as expected after close. check_persisted_data!(CLOSED_CHANNEL_UPDATE_ID); } - -// A `KVStore` impl for testing purposes that wraps all our `KVStore`s and asserts their synchronicity. -pub(crate) struct TestSyncStore { - serializer: RwLock<()>, - test_store: TestStore, - fs_store: FilesystemStore, - sqlite_store: SqliteStore, -} - -impl TestSyncStore { - pub(crate) fn new(dest_dir: PathBuf) -> Self { - let serializer = RwLock::new(()); - let mut fs_dir = dest_dir.clone(); - fs_dir.push("fs_store"); - let fs_store = FilesystemStore::new(fs_dir); - let mut sql_dir = dest_dir.clone(); - sql_dir.push("sqlite_store"); - let sqlite_store = SqliteStore::new( - sql_dir, - Some("test_sync_db".to_string()), - Some("test_sync_table".to_string()), - ) - .unwrap(); - let test_store = TestStore::new(false); - Self { serializer, fs_store, sqlite_store, test_store } - } - - fn do_list( - &self, primary_namespace: &str, secondary_namespace: &str, - ) -> std::io::Result> { - let fs_res = self.fs_store.list(primary_namespace, secondary_namespace); - let sqlite_res = self.sqlite_store.list(primary_namespace, secondary_namespace); - let test_res = self.test_store.list(primary_namespace, secondary_namespace); - - match fs_res { - Ok(mut list) => { - list.sort(); - - let mut sqlite_list = sqlite_res.unwrap(); - sqlite_list.sort(); - assert_eq!(list, sqlite_list); - - let mut test_list = test_res.unwrap(); - test_list.sort(); - assert_eq!(list, test_list); - - Ok(list) - } - Err(e) => { - assert!(sqlite_res.is_err()); - assert!(test_res.is_err()); - Err(e) - } - } - } -} - -impl KVStore for TestSyncStore { - fn read( - &self, primary_namespace: &str, secondary_namespace: &str, key: &str, - ) -> std::io::Result> { - let _guard = self.serializer.read().unwrap(); - - let fs_res = self.fs_store.read(primary_namespace, secondary_namespace, key); - let sqlite_res = self.sqlite_store.read(primary_namespace, secondary_namespace, key); - let test_res = self.test_store.read(primary_namespace, secondary_namespace, key); - - match fs_res { - Ok(read) => { - assert_eq!(read, sqlite_res.unwrap()); - assert_eq!(read, test_res.unwrap()); - Ok(read) - } - Err(e) => { - assert!(sqlite_res.is_err()); - assert_eq!(e.kind(), unsafe { sqlite_res.unwrap_err_unchecked().kind() }); - assert!(test_res.is_err()); - assert_eq!(e.kind(), unsafe { test_res.unwrap_err_unchecked().kind() }); - Err(e) - } - } - } - - fn write( - &self, primary_namespace: &str, secondary_namespace: &str, key: &str, buf: &[u8], - ) -> std::io::Result<()> { - let _guard = self.serializer.write().unwrap(); - let fs_res = self.fs_store.write(primary_namespace, secondary_namespace, key, buf); - let sqlite_res = self.sqlite_store.write(primary_namespace, secondary_namespace, key, buf); - let test_res = self.test_store.write(primary_namespace, secondary_namespace, key, buf); - - assert!(self - .do_list(primary_namespace, secondary_namespace) - .unwrap() - .contains(&key.to_string())); - - match fs_res { - Ok(()) => { - assert!(sqlite_res.is_ok()); - assert!(test_res.is_ok()); - Ok(()) - } - Err(e) => { - assert!(sqlite_res.is_err()); - assert!(test_res.is_err()); - Err(e) - } - } - } - - fn remove( - &self, primary_namespace: &str, secondary_namespace: &str, key: &str, lazy: bool, - ) -> std::io::Result<()> { - let _guard = self.serializer.write().unwrap(); - let fs_res = self.fs_store.remove(primary_namespace, secondary_namespace, key, lazy); - let sqlite_res = - self.sqlite_store.remove(primary_namespace, secondary_namespace, key, lazy); - let test_res = self.test_store.remove(primary_namespace, secondary_namespace, key, lazy); - - assert!(!self - .do_list(primary_namespace, secondary_namespace) - .unwrap() - .contains(&key.to_string())); - - match fs_res { - Ok(()) => { - assert!(sqlite_res.is_ok()); - assert!(test_res.is_ok()); - Ok(()) - } - Err(e) => { - assert!(sqlite_res.is_err()); - assert!(test_res.is_err()); - Err(e) - } - } - } - - fn list( - &self, primary_namespace: &str, secondary_namespace: &str, - ) -> std::io::Result> { - let _guard = self.serializer.read().unwrap(); - self.do_list(primary_namespace, secondary_namespace) - } -} diff --git a/src/lib.rs b/src/lib.rs index 2f09f2fd3f..3d51ef9842 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -85,8 +85,6 @@ mod logger; mod payment_store; mod peer_store; mod sweep; -#[cfg(test)] -mod test; mod tx_broadcaster; mod types; #[cfg(feature = "uniffi")] diff --git a/src/payment_store.rs b/src/payment_store.rs index 45acc4c71a..a541757661 100644 --- a/src/payment_store.rs +++ b/src/payment_store.rs @@ -219,8 +219,7 @@ where #[cfg(test)] mod tests { use super::*; - use crate::test::utils::TestLogger; - use lightning::util::test_utils::TestStore; + use lightning::util::test_utils::{TestLogger, TestStore}; use std::sync::Arc; #[test] diff --git a/src/peer_store.rs b/src/peer_store.rs index 648331fa14..46ba1dbe25 100644 --- a/src/peer_store.rs +++ b/src/peer_store.rs @@ -143,9 +143,7 @@ impl_writeable_tlv_based!(PeerInfo, { #[cfg(test)] mod tests { use super::*; - use crate::test::utils::TestLogger; - - use lightning::util::test_utils::TestStore; + use lightning::util::test_utils::{TestLogger, TestStore}; use std::str::FromStr; use std::sync::Arc; diff --git a/src/test/functional_tests.rs b/src/test/functional_tests.rs deleted file mode 100644 index c9796b9827..0000000000 --- a/src/test/functional_tests.rs +++ /dev/null @@ -1,515 +0,0 @@ -use crate::builder::NodeBuilder; -use crate::io::test_utils::TestSyncStore; -use crate::test::utils::*; -use crate::test::utils::{expect_channel_pending_event, expect_event, open_channel, random_config}; -use crate::{Error, Event, Network, Node, PaymentDirection, PaymentStatus}; - -use bitcoin::Amount; -use electrsd::bitcoind::BitcoinD; -use electrsd::ElectrsD; -use lightning::util::persist::KVStore; - -use std::sync::Arc; - -#[test] -fn channel_full_cycle() { - let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); - let (node_a, node_b) = setup_two_nodes(&electrsd, false); - do_channel_full_cycle(node_a, node_b, &bitcoind, &electrsd, false); -} - -#[test] -fn channel_full_cycle_0conf() { - let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); - let (node_a, node_b) = setup_two_nodes(&electrsd, true); - do_channel_full_cycle(node_a, node_b, &bitcoind, &electrsd, true) -} - -fn do_channel_full_cycle( - node_a: Node, node_b: Node, bitcoind: &BitcoinD, electrsd: &ElectrsD, allow_0conf: bool, -) { - let addr_a = node_a.new_onchain_address().unwrap(); - let addr_b = node_b.new_onchain_address().unwrap(); - - let premine_amount_sat = 100_000; - - premine_and_distribute_funds( - &bitcoind, - &electrsd, - vec![addr_a, addr_b], - Amount::from_sat(premine_amount_sat), - ); - node_a.sync_wallets().unwrap(); - node_b.sync_wallets().unwrap(); - assert_eq!(node_a.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); - assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); - - // Check we haven't got any events yet - assert_eq!(node_a.next_event(), None); - assert_eq!(node_b.next_event(), None); - - println!("\nA -- connect_open_channel -> B"); - let funding_amount_sat = 80_000; - let push_msat = (funding_amount_sat / 2) * 1000; // balance the channel - node_a - .connect_open_channel( - node_b.node_id(), - node_b.listening_addresses().unwrap().first().unwrap().clone(), - funding_amount_sat, - Some(push_msat), - None, - true, - ) - .unwrap(); - - assert_eq!(node_a.list_peers().first().unwrap().node_id, node_b.node_id()); - let funding_txo_a = expect_channel_pending_event!(node_a, node_b.node_id()); - let funding_txo_b = expect_channel_pending_event!(node_b, node_a.node_id()); - assert_eq!(funding_txo_a, funding_txo_b); - - wait_for_tx(&electrsd, funding_txo_a.txid); - - if !allow_0conf { - generate_blocks_and_wait(&bitcoind, &electrsd, 6); - } - - node_a.sync_wallets().unwrap(); - node_b.sync_wallets().unwrap(); - - let onchain_fee_buffer_sat = 1500; - let node_a_upper_bound_sat = premine_amount_sat - funding_amount_sat; - let node_a_lower_bound_sat = premine_amount_sat - funding_amount_sat - onchain_fee_buffer_sat; - assert!(node_a.spendable_onchain_balance_sats().unwrap() < node_a_upper_bound_sat); - assert!(node_a.spendable_onchain_balance_sats().unwrap() > node_a_lower_bound_sat); - assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); - - expect_event!(node_a, ChannelReady); - - let ev = node_b.wait_next_event(); - let channel_id = match ev { - ref e @ Event::ChannelReady { ref channel_id, .. } => { - println!("{} got event {:?}", std::stringify!(node_b), e); - node_b.event_handled(); - channel_id - } - ref e => { - panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e); - } - }; - - println!("\nB receive_payment"); - let invoice_amount_1_msat = 2500_000; - let invoice = node_b.receive_payment(invoice_amount_1_msat, &"asdf", 9217).unwrap(); - - println!("\nA send_payment"); - let payment_hash = node_a.send_payment(&invoice).unwrap(); - assert_eq!(node_a.send_payment(&invoice), Err(Error::DuplicatePayment)); - - assert_eq!(node_a.list_payments().first().unwrap().hash, payment_hash); - - let outbound_payments_a = - node_a.list_payments_with_filter(|p| p.direction == PaymentDirection::Outbound); - assert_eq!(outbound_payments_a.len(), 1); - - let inbound_payments_a = - node_a.list_payments_with_filter(|p| p.direction == PaymentDirection::Inbound); - assert_eq!(inbound_payments_a.len(), 0); - - let outbound_payments_b = - node_b.list_payments_with_filter(|p| p.direction == PaymentDirection::Outbound); - assert_eq!(outbound_payments_b.len(), 0); - - let inbound_payments_b = - node_b.list_payments_with_filter(|p| p.direction == PaymentDirection::Inbound); - assert_eq!(inbound_payments_b.len(), 1); - - expect_event!(node_a, PaymentSuccessful); - expect_event!(node_b, PaymentReceived); - assert_eq!(node_a.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); - assert_eq!(node_a.payment(&payment_hash).unwrap().direction, PaymentDirection::Outbound); - assert_eq!(node_a.payment(&payment_hash).unwrap().amount_msat, Some(invoice_amount_1_msat)); - assert_eq!(node_b.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); - assert_eq!(node_b.payment(&payment_hash).unwrap().direction, PaymentDirection::Inbound); - assert_eq!(node_b.payment(&payment_hash).unwrap().amount_msat, Some(invoice_amount_1_msat)); - - // Assert we fail duplicate outbound payments and check the status hasn't changed. - assert_eq!(Err(Error::DuplicatePayment), node_a.send_payment(&invoice)); - assert_eq!(node_a.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); - assert_eq!(node_a.payment(&payment_hash).unwrap().direction, PaymentDirection::Outbound); - assert_eq!(node_a.payment(&payment_hash).unwrap().amount_msat, Some(invoice_amount_1_msat)); - assert_eq!(node_b.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); - assert_eq!(node_b.payment(&payment_hash).unwrap().direction, PaymentDirection::Inbound); - assert_eq!(node_b.payment(&payment_hash).unwrap().amount_msat, Some(invoice_amount_1_msat)); - - // Test under-/overpayment - let invoice_amount_2_msat = 2500_000; - let invoice = node_b.receive_payment(invoice_amount_2_msat, &"asdf", 9217).unwrap(); - - let underpaid_amount = invoice_amount_2_msat - 1; - assert_eq!( - Err(Error::InvalidAmount), - node_a.send_payment_using_amount(&invoice, underpaid_amount) - ); - - println!("\nB overpaid receive_payment"); - let invoice = node_b.receive_payment(invoice_amount_2_msat, &"asdf", 9217).unwrap(); - let overpaid_amount_msat = invoice_amount_2_msat + 100; - - println!("\nA overpaid send_payment"); - let payment_hash = node_a.send_payment_using_amount(&invoice, overpaid_amount_msat).unwrap(); - expect_event!(node_a, PaymentSuccessful); - let received_amount = match node_b.wait_next_event() { - ref e @ Event::PaymentReceived { amount_msat, .. } => { - println!("{} got event {:?}", std::stringify!(node_b), e); - node_b.event_handled(); - amount_msat - } - ref e => { - panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e); - } - }; - assert_eq!(received_amount, overpaid_amount_msat); - assert_eq!(node_a.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); - assert_eq!(node_a.payment(&payment_hash).unwrap().direction, PaymentDirection::Outbound); - assert_eq!(node_a.payment(&payment_hash).unwrap().amount_msat, Some(overpaid_amount_msat)); - assert_eq!(node_b.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); - assert_eq!(node_b.payment(&payment_hash).unwrap().direction, PaymentDirection::Inbound); - assert_eq!(node_b.payment(&payment_hash).unwrap().amount_msat, Some(overpaid_amount_msat)); - - // Test "zero-amount" invoice payment - println!("\nB receive_variable_amount_payment"); - let variable_amount_invoice = node_b.receive_variable_amount_payment(&"asdf", 9217).unwrap(); - let determined_amount_msat = 2345_678; - assert_eq!(Err(Error::InvalidInvoice), node_a.send_payment(&variable_amount_invoice)); - println!("\nA send_payment_using_amount"); - let payment_hash = - node_a.send_payment_using_amount(&variable_amount_invoice, determined_amount_msat).unwrap(); - - expect_event!(node_a, PaymentSuccessful); - let received_amount = match node_b.wait_next_event() { - ref e @ Event::PaymentReceived { amount_msat, .. } => { - println!("{} got event {:?}", std::stringify!(node_b), e); - node_b.event_handled(); - amount_msat - } - ref e => { - panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e); - } - }; - assert_eq!(received_amount, determined_amount_msat); - assert_eq!(node_a.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); - assert_eq!(node_a.payment(&payment_hash).unwrap().direction, PaymentDirection::Outbound); - assert_eq!(node_a.payment(&payment_hash).unwrap().amount_msat, Some(determined_amount_msat)); - assert_eq!(node_b.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded); - assert_eq!(node_b.payment(&payment_hash).unwrap().direction, PaymentDirection::Inbound); - assert_eq!(node_b.payment(&payment_hash).unwrap().amount_msat, Some(determined_amount_msat)); - - // Test spontaneous/keysend payments - println!("\nA send_spontaneous_payment"); - let keysend_amount_msat = 2500_000; - let keysend_payment_hash = - node_a.send_spontaneous_payment(keysend_amount_msat, node_b.node_id()).unwrap(); - expect_event!(node_a, PaymentSuccessful); - let received_keysend_amount = match node_b.wait_next_event() { - ref e @ Event::PaymentReceived { amount_msat, .. } => { - println!("{} got event {:?}", std::stringify!(node_b), e); - node_b.event_handled(); - amount_msat - } - ref e => { - panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e); - } - }; - assert_eq!(received_keysend_amount, keysend_amount_msat); - assert_eq!(node_a.payment(&keysend_payment_hash).unwrap().status, PaymentStatus::Succeeded); - assert_eq!( - node_a.payment(&keysend_payment_hash).unwrap().direction, - PaymentDirection::Outbound - ); - assert_eq!( - node_a.payment(&keysend_payment_hash).unwrap().amount_msat, - Some(keysend_amount_msat) - ); - assert_eq!(node_b.payment(&keysend_payment_hash).unwrap().status, PaymentStatus::Succeeded); - assert_eq!(node_b.payment(&keysend_payment_hash).unwrap().direction, PaymentDirection::Inbound); - assert_eq!( - node_b.payment(&keysend_payment_hash).unwrap().amount_msat, - Some(keysend_amount_msat) - ); - - println!("\nB close_channel"); - node_b.close_channel(&channel_id, node_a.node_id()).unwrap(); - expect_event!(node_a, ChannelClosed); - expect_event!(node_b, ChannelClosed); - - wait_for_outpoint_spend(&electrsd, funding_txo_b); - - generate_blocks_and_wait(&bitcoind, &electrsd, 1); - node_a.sync_wallets().unwrap(); - node_b.sync_wallets().unwrap(); - - let sum_of_all_payments_sat = (push_msat - + invoice_amount_1_msat - + overpaid_amount_msat - + determined_amount_msat - + keysend_amount_msat) - / 1000; - let node_a_upper_bound_sat = - (premine_amount_sat - funding_amount_sat) + (funding_amount_sat - sum_of_all_payments_sat); - let node_a_lower_bound_sat = node_a_upper_bound_sat - onchain_fee_buffer_sat; - assert!(node_a.spendable_onchain_balance_sats().unwrap() > node_a_lower_bound_sat); - assert!(node_a.spendable_onchain_balance_sats().unwrap() < node_a_upper_bound_sat); - let expected_final_amount_node_b_sat = premine_amount_sat + sum_of_all_payments_sat; - assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), expected_final_amount_node_b_sat); - - // Check we handled all events - assert_eq!(node_a.next_event(), None); - assert_eq!(node_b.next_event(), None); - - node_a.stop().unwrap(); - println!("\nA stopped"); - node_b.stop().unwrap(); - println!("\nB stopped"); -} - -#[test] -fn channel_open_fails_when_funds_insufficient() { - let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); - let (node_a, node_b) = setup_two_nodes(&electrsd, false); - - let addr_a = node_a.new_onchain_address().unwrap(); - let addr_b = node_b.new_onchain_address().unwrap(); - - let premine_amount_sat = 100_000; - - premine_and_distribute_funds( - &bitcoind, - &electrsd, - vec![addr_a, addr_b], - Amount::from_sat(premine_amount_sat), - ); - node_a.sync_wallets().unwrap(); - node_b.sync_wallets().unwrap(); - assert_eq!(node_a.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); - assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); - - println!("\nA -- connect_open_channel -> B"); - assert_eq!( - Err(Error::InsufficientFunds), - node_a.connect_open_channel( - node_b.node_id(), - node_b.listening_addresses().unwrap().first().unwrap().clone(), - 120000, - None, - None, - true - ) - ); -} - -#[test] -fn multi_hop_sending() { - let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); - let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap()); - - // Setup and fund 5 nodes - let mut nodes = Vec::new(); - for _ in 0..5 { - let config = random_config(); - let mut builder = NodeBuilder::from_config(config); - builder.set_esplora_server(esplora_url.clone()); - let node = builder.build().unwrap(); - node.start().unwrap(); - nodes.push(node); - } - - let addresses = nodes.iter().map(|n| n.new_onchain_address().unwrap()).collect(); - let premine_amount_sat = 5_000_000; - premine_and_distribute_funds( - &bitcoind, - &electrsd, - addresses, - Amount::from_sat(premine_amount_sat), - ); - - for n in &nodes { - n.sync_wallets().unwrap(); - assert_eq!(n.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); - assert_eq!(n.next_event(), None); - } - - // Setup channel topology: - // (1M:0)- N2 -(1M:0) - // / \ - // N0 -(100k:0)-> N1 N4 - // \ / - // (1M:0)- N3 -(1M:0) - - open_channel(&nodes[0], &nodes[1], 100_000, true, &electrsd); - open_channel(&nodes[1], &nodes[2], 1_000_000, true, &electrsd); - // We need to sync wallets in-between back-to-back channel opens from the same node so BDK - // wallet picks up on the broadcast funding tx and doesn't double-spend itself. - // - // TODO: Remove once fixed in BDK. - nodes[1].sync_wallets().unwrap(); - open_channel(&nodes[1], &nodes[3], 1_000_000, true, &electrsd); - open_channel(&nodes[2], &nodes[4], 1_000_000, true, &electrsd); - open_channel(&nodes[3], &nodes[4], 1_000_000, true, &electrsd); - - generate_blocks_and_wait(&bitcoind, &electrsd, 6); - - for n in &nodes { - n.sync_wallets().unwrap(); - } - - expect_event!(nodes[0], ChannelReady); - expect_event!(nodes[1], ChannelReady); - expect_event!(nodes[1], ChannelReady); - expect_event!(nodes[1], ChannelReady); - expect_event!(nodes[2], ChannelReady); - expect_event!(nodes[2], ChannelReady); - expect_event!(nodes[3], ChannelReady); - expect_event!(nodes[3], ChannelReady); - expect_event!(nodes[4], ChannelReady); - expect_event!(nodes[4], ChannelReady); - - // Sleep a bit for gossip to propagate. - std::thread::sleep(std::time::Duration::from_secs(1)); - - let invoice = nodes[4].receive_payment(2_500_000, &"asdf", 9217).unwrap(); - nodes[0].send_payment(&invoice).unwrap(); - - expect_event!(nodes[4], PaymentReceived); - expect_event!(nodes[0], PaymentSuccessful); -} - -#[test] -fn connect_to_public_testnet_esplora() { - let mut config = random_config(); - config.network = Network::Testnet; - let mut builder = NodeBuilder::from_config(config); - builder.set_esplora_server("https://blockstream.info/testnet/api".to_string()); - let node = builder.build().unwrap(); - node.start().unwrap(); - node.stop().unwrap(); -} - -#[test] -fn start_stop_reinit() { - let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); - let config = random_config(); - - let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap()); - - let test_sync_store = Arc::new(TestSyncStore::new(config.storage_dir_path.clone().into())); - - let mut builder = NodeBuilder::from_config(config.clone()); - builder.set_esplora_server(esplora_url.clone()); - - let node = builder.build_with_store(Arc::clone(&test_sync_store)).unwrap(); - node.start().unwrap(); - - let expected_node_id = node.node_id(); - assert_eq!(node.start(), Err(Error::AlreadyRunning)); - - let funding_address = node.new_onchain_address().unwrap(); - - assert_eq!(node.total_onchain_balance_sats().unwrap(), 0); - - let expected_amount = Amount::from_sat(100000); - premine_and_distribute_funds(&bitcoind, &electrsd, vec![funding_address], expected_amount); - - node.sync_wallets().unwrap(); - assert_eq!(node.spendable_onchain_balance_sats().unwrap(), expected_amount.to_sat()); - - let log_file_symlink = format!("{}/logs/ldk_node_latest.log", config.clone().storage_dir_path); - assert!(std::path::Path::new(&log_file_symlink).is_symlink()); - - node.stop().unwrap(); - assert_eq!(node.stop(), Err(Error::NotRunning)); - - node.start().unwrap(); - assert_eq!(node.start(), Err(Error::AlreadyRunning)); - - node.stop().unwrap(); - assert_eq!(node.stop(), Err(Error::NotRunning)); - drop(node); - - let mut builder = NodeBuilder::from_config(config.clone()); - builder.set_esplora_server(esplora_url.clone()); - - let reinitialized_node = builder.build_with_store(Arc::clone(&test_sync_store)).unwrap(); - reinitialized_node.start().unwrap(); - assert_eq!(reinitialized_node.node_id(), expected_node_id); - - assert_eq!( - reinitialized_node.spendable_onchain_balance_sats().unwrap(), - expected_amount.to_sat() - ); - - reinitialized_node.sync_wallets().unwrap(); - assert_eq!( - reinitialized_node.spendable_onchain_balance_sats().unwrap(), - expected_amount.to_sat() - ); - - reinitialized_node.stop().unwrap(); -} - -#[test] -fn onchain_spend_receive() { - let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); - let (node_a, node_b) = setup_two_nodes(&electrsd, false); - - let addr_a = node_a.new_onchain_address().unwrap(); - let addr_b = node_b.new_onchain_address().unwrap(); - - premine_and_distribute_funds( - &bitcoind, - &electrsd, - vec![addr_b.clone()], - Amount::from_sat(100000), - ); - - node_a.sync_wallets().unwrap(); - node_b.sync_wallets().unwrap(); - assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), 100000); - - assert_eq!(Err(Error::InsufficientFunds), node_a.send_to_onchain_address(&addr_b, 1000)); - - let txid = node_b.send_to_onchain_address(&addr_a, 1000).unwrap(); - generate_blocks_and_wait(&bitcoind, &electrsd, 6); - wait_for_tx(&electrsd, txid); - - node_a.sync_wallets().unwrap(); - node_b.sync_wallets().unwrap(); - - assert_eq!(node_a.spendable_onchain_balance_sats().unwrap(), 1000); - assert!(node_b.spendable_onchain_balance_sats().unwrap() > 98000); - assert!(node_b.spendable_onchain_balance_sats().unwrap() < 100000); - - let addr_b = node_b.new_onchain_address().unwrap(); - let txid = node_a.send_all_to_onchain_address(&addr_b).unwrap(); - generate_blocks_and_wait(&bitcoind, &electrsd, 6); - wait_for_tx(&electrsd, txid); - - node_a.sync_wallets().unwrap(); - node_b.sync_wallets().unwrap(); - - assert_eq!(node_a.total_onchain_balance_sats().unwrap(), 0); - assert!(node_b.spendable_onchain_balance_sats().unwrap() > 99000); - assert!(node_b.spendable_onchain_balance_sats().unwrap() < 100000); -} - -#[test] -fn sign_verify_msg() { - let (_bitcoind, electrsd) = setup_bitcoind_and_electrsd(); - let config = random_config(); - let node = setup_node(&electrsd, config); - - // Tests arbitrary message signing and later verification - let msg = "OK computer".as_bytes(); - let sig = node.sign_message(msg).unwrap(); - let pkey = node.node_id(); - assert!(node.verify_signature(msg, sig.as_str(), &pkey)); -} diff --git a/src/test/mod.rs b/src/test/mod.rs deleted file mode 100644 index f856f48784..0000000000 --- a/src/test/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub mod functional_tests; -pub mod utils; diff --git a/src/test/utils.rs b/src/test/utils.rs deleted file mode 100644 index ea1ac1bc01..0000000000 --- a/src/test/utils.rs +++ /dev/null @@ -1,362 +0,0 @@ -use crate::builder::NodeBuilder; -use crate::io::test_utils::TestSyncStore; -use crate::{Config, Event, Network, Node}; -use lightning::ln::msgs::SocketAddress; -use lightning::util::logger::{Level, Logger, Record}; -use lightning::util::persist::KVStore; - -use bitcoin::{Address, Amount, OutPoint, Txid}; - -use bitcoind::bitcoincore_rpc::RpcApi; -use electrsd::bitcoind::bitcoincore_rpc::bitcoincore_rpc_json::AddressType; -use electrsd::electrum_client::ElectrumApi; -use electrsd::{bitcoind, bitcoind::BitcoinD, ElectrsD}; - -use regex; - -use rand::distributions::Alphanumeric; -use rand::{thread_rng, Rng}; -use std::collections::HashMap; -use std::env; -use std::path::PathBuf; -use std::sync::Arc; -use std::sync::Mutex; -use std::time::Duration; - -macro_rules! expect_event { - ($node: expr, $event_type: ident) => {{ - match $node.wait_next_event() { - ref e @ Event::$event_type { .. } => { - println!("{} got event {:?}", $node.node_id(), e); - $node.event_handled(); - } - ref e => { - panic!("{} got unexpected event!: {:?}", std::stringify!($node), e); - } - } - }}; -} - -pub(crate) use expect_event; - -macro_rules! expect_channel_pending_event { - ($node: expr, $counterparty_node_id: expr) => {{ - match $node.wait_next_event() { - ref e @ Event::ChannelPending { funding_txo, counterparty_node_id, .. } => { - println!("{} got event {:?}", $node.node_id(), e); - assert_eq!(counterparty_node_id, $counterparty_node_id); - $node.event_handled(); - funding_txo - } - ref e => { - panic!("{} got unexpected event!: {:?}", std::stringify!($node), e); - } - } - }}; -} - -pub(crate) use expect_channel_pending_event; - -// Copied over from upstream LDK -#[allow(dead_code)] -pub struct TestLogger { - level: Level, - pub(crate) id: String, - pub lines: Mutex>, -} - -impl TestLogger { - #[allow(dead_code)] - pub fn new() -> TestLogger { - Self::with_id("".to_owned()) - } - - #[allow(dead_code)] - pub fn with_id(id: String) -> TestLogger { - TestLogger { level: Level::Trace, id, lines: Mutex::new(HashMap::new()) } - } - - #[allow(dead_code)] - pub fn enable(&mut self, level: Level) { - self.level = level; - } - - #[allow(dead_code)] - pub fn assert_log(&self, module: String, line: String, count: usize) { - let log_entries = self.lines.lock().unwrap(); - assert_eq!(log_entries.get(&(module, line)), Some(&count)); - } - - /// Search for the number of occurrence of the logged lines which - /// 1. belongs to the specified module and - /// 2. contains `line` in it. - /// And asserts if the number of occurrences is the same with the given `count` - #[allow(dead_code)] - pub fn assert_log_contains(&self, module: &str, line: &str, count: usize) { - let log_entries = self.lines.lock().unwrap(); - let l: usize = log_entries - .iter() - .filter(|&(&(ref m, ref l), _c)| m == module && l.contains(line)) - .map(|(_, c)| c) - .sum(); - assert_eq!(l, count) - } - - /// Search for the number of occurrences of logged lines which - /// 1. belong to the specified module and - /// 2. match the given regex pattern. - /// Assert that the number of occurrences equals the given `count` - #[allow(dead_code)] - pub fn assert_log_regex(&self, module: &str, pattern: regex::Regex, count: usize) { - let log_entries = self.lines.lock().unwrap(); - let l: usize = log_entries - .iter() - .filter(|&(&(ref m, ref l), _c)| m == module && pattern.is_match(&l)) - .map(|(_, c)| c) - .sum(); - assert_eq!(l, count) - } -} - -impl Logger for TestLogger { - fn log(&self, record: Record) { - *self - .lines - .lock() - .unwrap() - .entry((record.module_path.to_string(), format!("{}", record.args))) - .or_insert(0) += 1; - if record.level >= self.level { - #[cfg(feature = "std")] - println!( - "{:<5} {} [{} : {}, {}] {}", - record.level.to_string(), - self.id, - record.module_path, - record.file, - record.line, - record.args - ); - } - } -} - -pub fn random_storage_path() -> PathBuf { - let mut temp_path = std::env::temp_dir(); - let mut rng = thread_rng(); - let rand_dir: String = (0..7).map(|_| rng.sample(Alphanumeric) as char).collect(); - temp_path.push(rand_dir); - temp_path -} - -pub fn random_port() -> u16 { - let mut rng = thread_rng(); - rng.gen_range(5000..65535) -} - -pub fn random_listening_addresses() -> Vec { - let num_addresses = 2; - let mut listening_addresses = Vec::with_capacity(num_addresses); - - for _ in 0..num_addresses { - let rand_port = random_port(); - let address: SocketAddress = format!("127.0.0.1:{}", rand_port).parse().unwrap(); - listening_addresses.push(address); - } - - listening_addresses -} - -pub fn random_config() -> Config { - let mut config = Config::default(); - - config.network = Network::Regtest; - println!("Setting network: {}", config.network); - - let rand_dir = random_storage_path(); - println!("Setting random LDK storage dir: {}", rand_dir.display()); - config.storage_dir_path = rand_dir.to_str().unwrap().to_owned(); - - let rand_listening_addresses = random_listening_addresses(); - println!("Setting random LDK listening addresses: {:?}", rand_listening_addresses); - config.listening_addresses = Some(rand_listening_addresses); - - config.log_level = Level::Gossip; - - config -} - -pub fn setup_bitcoind_and_electrsd() -> (BitcoinD, ElectrsD) { - let bitcoind_exe = - env::var("BITCOIND_EXE").ok().or_else(|| bitcoind::downloaded_exe_path().ok()).expect( - "you need to provide an env var BITCOIND_EXE or specify a bitcoind version feature", - ); - let mut bitcoind_conf = bitcoind::Conf::default(); - bitcoind_conf.network = "regtest"; - let bitcoind = BitcoinD::with_conf(bitcoind_exe, &bitcoind_conf).unwrap(); - - let electrs_exe = env::var("ELECTRS_EXE") - .ok() - .or_else(electrsd::downloaded_exe_path) - .expect("you need to provide env var ELECTRS_EXE or specify an electrsd version feature"); - let mut electrsd_conf = electrsd::Conf::default(); - electrsd_conf.http_enabled = true; - electrsd_conf.network = "regtest"; - let electrsd = ElectrsD::with_conf(electrs_exe, &bitcoind, &electrsd_conf).unwrap(); - (bitcoind, electrsd) -} - -pub(crate) fn setup_two_nodes( - electrsd: &ElectrsD, allow_0conf: bool, -) -> (Node, Node) { - println!("== Node A =="); - let config_a = random_config(); - let node_a = setup_node(electrsd, config_a); - - println!("\n== Node B =="); - let mut config_b = random_config(); - if allow_0conf { - config_b.trusted_peers_0conf.push(node_a.node_id()); - } - let node_b = setup_node(electrsd, config_b); - (node_a, node_b) -} - -pub(crate) fn setup_node(electrsd: &ElectrsD, config: Config) -> Node { - let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap()); - let mut builder = NodeBuilder::from_config(config.clone()); - builder.set_esplora_server(esplora_url.clone()); - let test_sync_store = Arc::new(TestSyncStore::new(config.storage_dir_path.into())); - let node = builder.build_with_store(test_sync_store).unwrap(); - node.start().unwrap(); - node -} - -pub fn generate_blocks_and_wait(bitcoind: &BitcoinD, electrsd: &ElectrsD, num: usize) { - print!("Generating {} blocks...", num); - let cur_height = bitcoind.client.get_block_count().expect("failed to get current block height"); - let address = bitcoind - .client - .get_new_address(Some("test"), Some(AddressType::Legacy)) - .expect("failed to get new address") - .require_network(bitcoin::Network::Regtest) - .expect("failed to get new address"); - // TODO: expect this Result once the WouldBlock issue is resolved upstream. - let _block_hashes_res = bitcoind.client.generate_to_address(num as u64, &address); - wait_for_block(electrsd, cur_height as usize + num); - print!(" Done!"); - println!("\n"); -} - -pub fn wait_for_block(electrsd: &ElectrsD, min_height: usize) { - let mut header = match electrsd.client.block_headers_subscribe() { - Ok(header) => header, - Err(_) => { - // While subscribing should succeed the first time around, we ran into some cases where - // it didn't. Since we can't proceed without subscribing, we try again after a delay - // and panic if it still fails. - std::thread::sleep(Duration::from_secs(1)); - electrsd.client.block_headers_subscribe().expect("failed to subscribe to block headers") - } - }; - loop { - if header.height >= min_height { - break; - } - header = exponential_backoff_poll(|| { - electrsd.trigger().expect("failed to trigger electrsd"); - electrsd.client.ping().expect("failed to ping electrsd"); - electrsd.client.block_headers_pop().expect("failed to pop block header") - }); - } -} - -pub fn wait_for_tx(electrsd: &ElectrsD, txid: Txid) { - let mut tx_res = electrsd.client.transaction_get(&txid); - loop { - if tx_res.is_ok() { - break; - } - tx_res = exponential_backoff_poll(|| { - electrsd.trigger().unwrap(); - electrsd.client.ping().unwrap(); - Some(electrsd.client.transaction_get(&txid)) - }); - } -} - -pub fn wait_for_outpoint_spend(electrsd: &ElectrsD, outpoint: OutPoint) { - let tx = electrsd.client.transaction_get(&outpoint.txid).unwrap(); - let txout_script = tx.output.get(outpoint.vout as usize).unwrap().clone().script_pubkey; - let mut is_spent = !electrsd.client.script_get_history(&txout_script).unwrap().is_empty(); - loop { - if is_spent { - break; - } - - is_spent = exponential_backoff_poll(|| { - electrsd.trigger().unwrap(); - electrsd.client.ping().unwrap(); - Some(!electrsd.client.script_get_history(&txout_script).unwrap().is_empty()) - }); - } -} - -pub fn exponential_backoff_poll(mut poll: F) -> T -where - F: FnMut() -> Option, -{ - let mut delay = Duration::from_millis(64); - let mut tries = 0; - loop { - match poll() { - Some(data) => break data, - None if delay.as_millis() < 512 => { - delay = delay.mul_f32(2.0); - } - - None => {} - } - assert!(tries < 20, "Reached max tries."); - tries += 1; - std::thread::sleep(delay); - } -} - -pub fn premine_and_distribute_funds( - bitcoind: &BitcoinD, electrsd: &ElectrsD, addrs: Vec
, amount: Amount, -) { - generate_blocks_and_wait(bitcoind, electrsd, 101); - - for addr in addrs { - let txid = bitcoind - .client - .send_to_address(&addr, amount, None, None, None, None, None, None) - .unwrap(); - wait_for_tx(electrsd, txid); - } - - generate_blocks_and_wait(bitcoind, electrsd, 1); -} - -pub fn open_channel( - node_a: &Node, node_b: &Node, funding_amount_sat: u64, announce: bool, - electrsd: &ElectrsD, -) { - node_a - .connect_open_channel( - node_b.node_id(), - node_b.listening_addresses().unwrap().first().unwrap().clone(), - funding_amount_sat, - None, - None, - announce, - ) - .unwrap(); - assert!(node_a.list_peers().iter().find(|c| { c.node_id == node_b.node_id() }).is_some()); - - let funding_txo_a = expect_channel_pending_event!(node_a, node_b.node_id()); - let funding_txo_b = expect_channel_pending_event!(node_b, node_a.node_id()); - assert_eq!(funding_txo_a, funding_txo_b); - wait_for_tx(&electrsd, funding_txo_a.txid); -} diff --git a/tests/common.rs b/tests/common.rs index d1adb3f4b6..1af65dde8b 100644 --- a/tests/common.rs +++ b/tests/common.rs @@ -1,9 +1,15 @@ -#![cfg(any(cln_test, vss_test))] +#![cfg(any(test, cln_test, vss_test))] +#![allow(dead_code)] -use ldk_node::{Config, Event, LogLevel, Network, Node, NodeError, PaymentDirection, PaymentStatus}; +use ldk_node::io::sqlite_store::SqliteStore; +use ldk_node::{ + Builder, Config, Event, LogLevel, Network, Node, NodeError, PaymentDirection, PaymentStatus, +}; use lightning::ln::msgs::SocketAddress; use lightning::util::persist::KVStore; +use lightning::util::test_utils::TestStore; +use lightning_persister::fs_store::FilesystemStore; use bitcoin::{Address, Amount, OutPoint, Txid}; @@ -19,6 +25,7 @@ use rand::{thread_rng, Rng}; use std::env; use std::path::PathBuf; +use std::sync::{Arc, RwLock}; use std::time::Duration; macro_rules! expect_event { @@ -138,6 +145,48 @@ pub(crate) fn random_config() -> Config { config } +#[cfg(feature = "uniffi")] +type TestNode = Arc>; +#[cfg(not(feature = "uniffi"))] +type TestNode = Node; + +macro_rules! setup_builder { + ($builder: ident, $config: expr) => { + #[cfg(feature = "uniffi")] + let $builder = Builder::from_config($config.clone()); + #[cfg(not(feature = "uniffi"))] + let mut $builder = Builder::from_config($config.clone()); + }; +} + +pub(crate) use setup_builder; + +pub(crate) fn setup_two_nodes( + electrsd: &ElectrsD, allow_0conf: bool, +) -> (TestNode, TestNode) { + println!("== Node A =="); + let config_a = random_config(); + let node_a = setup_node(electrsd, config_a); + + println!("\n== Node B =="); + let mut config_b = random_config(); + if allow_0conf { + config_b.trusted_peers_0conf.push(node_a.node_id()); + } + let node_b = setup_node(electrsd, config_b); + (node_a, node_b) +} + +pub(crate) fn setup_node(electrsd: &ElectrsD, config: Config) -> TestNode { + let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap()); + setup_builder!(builder, config); + builder.set_esplora_server(esplora_url.clone()); + let test_sync_store = Arc::new(TestSyncStore::new(config.storage_dir_path.into())); + let node = builder.build_with_store(test_sync_store).unwrap(); + node.start().unwrap(); + node +} + pub(crate) fn generate_blocks_and_wait( bitcoind: &BitcoindClient, electrs: &E, num: usize, ) { @@ -245,8 +294,31 @@ pub(crate) fn premine_and_distribute_funds( generate_blocks_and_wait(bitcoind, electrs, 1); } +pub fn open_channel( + node_a: &TestNode, node_b: &TestNode, funding_amount_sat: u64, announce: bool, + electrsd: &ElectrsD, +) { + node_a + .connect_open_channel( + node_b.node_id(), + node_b.listening_addresses().unwrap().first().unwrap().clone(), + funding_amount_sat, + None, + None, + announce, + ) + .unwrap(); + assert!(node_a.list_peers().iter().find(|c| { c.node_id == node_b.node_id() }).is_some()); + + let funding_txo_a = expect_channel_pending_event!(node_a, node_b.node_id()); + let funding_txo_b = expect_channel_pending_event!(node_b, node_a.node_id()); + assert_eq!(funding_txo_a, funding_txo_b); + wait_for_tx(&electrsd.client, funding_txo_a.txid); +} + pub(crate) fn do_channel_full_cycle( - node_a: Node, node_b: Node, bitcoind: &BitcoindClient, electrsd: &E, allow_0conf: bool, + node_a: TestNode, node_b: TestNode, bitcoind: &BitcoindClient, electrsd: &E, + allow_0conf: bool, ) { let addr_a = node_a.new_onchain_address().unwrap(); let addr_b = node_b.new_onchain_address().unwrap(); @@ -481,3 +553,148 @@ pub(crate) fn do_channel_full_cycle( node_b.stop().unwrap(); println!("\nB stopped"); } + +// A `KVStore` impl for testing purposes that wraps all our `KVStore`s and asserts their synchronicity. +pub(crate) struct TestSyncStore { + serializer: RwLock<()>, + test_store: TestStore, + fs_store: FilesystemStore, + sqlite_store: SqliteStore, +} + +impl TestSyncStore { + pub(crate) fn new(dest_dir: PathBuf) -> Self { + let serializer = RwLock::new(()); + let mut fs_dir = dest_dir.clone(); + fs_dir.push("fs_store"); + let fs_store = FilesystemStore::new(fs_dir); + let mut sql_dir = dest_dir.clone(); + sql_dir.push("sqlite_store"); + let sqlite_store = SqliteStore::new( + sql_dir, + Some("test_sync_db".to_string()), + Some("test_sync_table".to_string()), + ) + .unwrap(); + let test_store = TestStore::new(false); + Self { serializer, fs_store, sqlite_store, test_store } + } + + fn do_list( + &self, primary_namespace: &str, secondary_namespace: &str, + ) -> std::io::Result> { + let fs_res = self.fs_store.list(primary_namespace, secondary_namespace); + let sqlite_res = self.sqlite_store.list(primary_namespace, secondary_namespace); + let test_res = self.test_store.list(primary_namespace, secondary_namespace); + + match fs_res { + Ok(mut list) => { + list.sort(); + + let mut sqlite_list = sqlite_res.unwrap(); + sqlite_list.sort(); + assert_eq!(list, sqlite_list); + + let mut test_list = test_res.unwrap(); + test_list.sort(); + assert_eq!(list, test_list); + + Ok(list) + } + Err(e) => { + assert!(sqlite_res.is_err()); + assert!(test_res.is_err()); + Err(e) + } + } + } +} + +impl KVStore for TestSyncStore { + fn read( + &self, primary_namespace: &str, secondary_namespace: &str, key: &str, + ) -> std::io::Result> { + let _guard = self.serializer.read().unwrap(); + + let fs_res = self.fs_store.read(primary_namespace, secondary_namespace, key); + let sqlite_res = self.sqlite_store.read(primary_namespace, secondary_namespace, key); + let test_res = self.test_store.read(primary_namespace, secondary_namespace, key); + + match fs_res { + Ok(read) => { + assert_eq!(read, sqlite_res.unwrap()); + assert_eq!(read, test_res.unwrap()); + Ok(read) + } + Err(e) => { + assert!(sqlite_res.is_err()); + assert_eq!(e.kind(), unsafe { sqlite_res.unwrap_err_unchecked().kind() }); + assert!(test_res.is_err()); + assert_eq!(e.kind(), unsafe { test_res.unwrap_err_unchecked().kind() }); + Err(e) + } + } + } + + fn write( + &self, primary_namespace: &str, secondary_namespace: &str, key: &str, buf: &[u8], + ) -> std::io::Result<()> { + let _guard = self.serializer.write().unwrap(); + let fs_res = self.fs_store.write(primary_namespace, secondary_namespace, key, buf); + let sqlite_res = self.sqlite_store.write(primary_namespace, secondary_namespace, key, buf); + let test_res = self.test_store.write(primary_namespace, secondary_namespace, key, buf); + + assert!(self + .do_list(primary_namespace, secondary_namespace) + .unwrap() + .contains(&key.to_string())); + + match fs_res { + Ok(()) => { + assert!(sqlite_res.is_ok()); + assert!(test_res.is_ok()); + Ok(()) + } + Err(e) => { + assert!(sqlite_res.is_err()); + assert!(test_res.is_err()); + Err(e) + } + } + } + + fn remove( + &self, primary_namespace: &str, secondary_namespace: &str, key: &str, lazy: bool, + ) -> std::io::Result<()> { + let _guard = self.serializer.write().unwrap(); + let fs_res = self.fs_store.remove(primary_namespace, secondary_namespace, key, lazy); + let sqlite_res = + self.sqlite_store.remove(primary_namespace, secondary_namespace, key, lazy); + let test_res = self.test_store.remove(primary_namespace, secondary_namespace, key, lazy); + + assert!(!self + .do_list(primary_namespace, secondary_namespace) + .unwrap() + .contains(&key.to_string())); + + match fs_res { + Ok(()) => { + assert!(sqlite_res.is_ok()); + assert!(test_res.is_ok()); + Ok(()) + } + Err(e) => { + assert!(sqlite_res.is_err()); + assert!(test_res.is_err()); + Err(e) + } + } + } + + fn list( + &self, primary_namespace: &str, secondary_namespace: &str, + ) -> std::io::Result> { + let _guard = self.serializer.read().unwrap(); + self.do_list(primary_namespace, secondary_namespace) + } +} diff --git a/tests/integration_tests_rust.rs b/tests/integration_tests_rust.rs new file mode 100644 index 0000000000..8127f3194b --- /dev/null +++ b/tests/integration_tests_rust.rs @@ -0,0 +1,274 @@ +mod common; + +use common::{ + do_channel_full_cycle, expect_event, generate_blocks_and_wait, open_channel, + premine_and_distribute_funds, random_config, setup_bitcoind_and_electrsd, setup_builder, + setup_node, setup_two_nodes, wait_for_tx, TestSyncStore, +}; + +use ldk_node::{Builder, Event, Network, NodeError}; + +use bitcoin::Amount; + +use std::sync::Arc; + +#[test] +fn channel_full_cycle() { + let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); + let (node_a, node_b) = setup_two_nodes(&electrsd, false); + do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false); +} + +#[test] +fn channel_full_cycle_0conf() { + let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); + let (node_a, node_b) = setup_two_nodes(&electrsd, true); + do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, true) +} + +#[test] +fn channel_open_fails_when_funds_insufficient() { + let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); + let (node_a, node_b) = setup_two_nodes(&electrsd, false); + + let addr_a = node_a.new_onchain_address().unwrap(); + let addr_b = node_b.new_onchain_address().unwrap(); + + let premine_amount_sat = 100_000; + + premine_and_distribute_funds( + &bitcoind.client, + &electrsd.client, + vec![addr_a, addr_b], + Amount::from_sat(premine_amount_sat), + ); + node_a.sync_wallets().unwrap(); + node_b.sync_wallets().unwrap(); + assert_eq!(node_a.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); + assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); + + println!("\nA -- connect_open_channel -> B"); + assert_eq!( + Err(NodeError::InsufficientFunds), + node_a.connect_open_channel( + node_b.node_id(), + node_b.listening_addresses().unwrap().first().unwrap().clone(), + 120000, + None, + None, + true + ) + ); +} + +#[test] +fn multi_hop_sending() { + let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); + let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap()); + + // Setup and fund 5 nodes + let mut nodes = Vec::new(); + for _ in 0..5 { + let config = random_config(); + setup_builder!(builder, config); + builder.set_esplora_server(esplora_url.clone()); + let node = builder.build().unwrap(); + node.start().unwrap(); + nodes.push(node); + } + + let addresses = nodes.iter().map(|n| n.new_onchain_address().unwrap()).collect(); + let premine_amount_sat = 5_000_000; + premine_and_distribute_funds( + &bitcoind.client, + &electrsd.client, + addresses, + Amount::from_sat(premine_amount_sat), + ); + + for n in &nodes { + n.sync_wallets().unwrap(); + assert_eq!(n.spendable_onchain_balance_sats().unwrap(), premine_amount_sat); + assert_eq!(n.next_event(), None); + } + + // Setup channel topology: + // (1M:0)- N2 -(1M:0) + // / \ + // N0 -(100k:0)-> N1 N4 + // \ / + // (1M:0)- N3 -(1M:0) + + open_channel(&nodes[0], &nodes[1], 100_000, true, &electrsd); + open_channel(&nodes[1], &nodes[2], 1_000_000, true, &electrsd); + // We need to sync wallets in-between back-to-back channel opens from the same node so BDK + // wallet picks up on the broadcast funding tx and doesn't double-spend itself. + // + // TODO: Remove once fixed in BDK. + nodes[1].sync_wallets().unwrap(); + open_channel(&nodes[1], &nodes[3], 1_000_000, true, &electrsd); + open_channel(&nodes[2], &nodes[4], 1_000_000, true, &electrsd); + open_channel(&nodes[3], &nodes[4], 1_000_000, true, &electrsd); + + generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6); + + for n in &nodes { + n.sync_wallets().unwrap(); + } + + expect_event!(nodes[0], ChannelReady); + expect_event!(nodes[1], ChannelReady); + expect_event!(nodes[1], ChannelReady); + expect_event!(nodes[1], ChannelReady); + expect_event!(nodes[2], ChannelReady); + expect_event!(nodes[2], ChannelReady); + expect_event!(nodes[3], ChannelReady); + expect_event!(nodes[3], ChannelReady); + expect_event!(nodes[4], ChannelReady); + expect_event!(nodes[4], ChannelReady); + + // Sleep a bit for gossip to propagate. + std::thread::sleep(std::time::Duration::from_secs(1)); + + let invoice = nodes[4].receive_payment(2_500_000, &"asdf", 9217).unwrap(); + nodes[0].send_payment(&invoice).unwrap(); + + expect_event!(nodes[4], PaymentReceived); + expect_event!(nodes[0], PaymentSuccessful); +} + +#[test] +fn connect_to_public_testnet_esplora() { + let mut config = random_config(); + config.network = Network::Testnet; + setup_builder!(builder, config); + builder.set_esplora_server("https://blockstream.info/testnet/api".to_string()); + let node = builder.build().unwrap(); + node.start().unwrap(); + node.stop().unwrap(); +} + +#[test] +fn start_stop_reinit() { + let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); + let config = random_config(); + + let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap()); + + let test_sync_store = Arc::new(TestSyncStore::new(config.storage_dir_path.clone().into())); + + setup_builder!(builder, config); + builder.set_esplora_server(esplora_url.clone()); + + let node = builder.build_with_store(Arc::clone(&test_sync_store)).unwrap(); + node.start().unwrap(); + + let expected_node_id = node.node_id(); + assert_eq!(node.start(), Err(NodeError::AlreadyRunning)); + + let funding_address = node.new_onchain_address().unwrap(); + + assert_eq!(node.total_onchain_balance_sats().unwrap(), 0); + + let expected_amount = Amount::from_sat(100000); + premine_and_distribute_funds( + &bitcoind.client, + &electrsd.client, + vec![funding_address], + expected_amount, + ); + + node.sync_wallets().unwrap(); + assert_eq!(node.spendable_onchain_balance_sats().unwrap(), expected_amount.to_sat()); + + let log_file_symlink = format!("{}/logs/ldk_node_latest.log", config.clone().storage_dir_path); + assert!(std::path::Path::new(&log_file_symlink).is_symlink()); + + node.stop().unwrap(); + assert_eq!(node.stop(), Err(NodeError::NotRunning)); + + node.start().unwrap(); + assert_eq!(node.start(), Err(NodeError::AlreadyRunning)); + + node.stop().unwrap(); + assert_eq!(node.stop(), Err(NodeError::NotRunning)); + drop(node); + + setup_builder!(builder, config); + builder.set_esplora_server(esplora_url.clone()); + + let reinitialized_node = builder.build_with_store(Arc::clone(&test_sync_store)).unwrap(); + reinitialized_node.start().unwrap(); + assert_eq!(reinitialized_node.node_id(), expected_node_id); + + assert_eq!( + reinitialized_node.spendable_onchain_balance_sats().unwrap(), + expected_amount.to_sat() + ); + + reinitialized_node.sync_wallets().unwrap(); + assert_eq!( + reinitialized_node.spendable_onchain_balance_sats().unwrap(), + expected_amount.to_sat() + ); + + reinitialized_node.stop().unwrap(); +} + +#[test] +fn onchain_spend_receive() { + let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); + let (node_a, node_b) = setup_two_nodes(&electrsd, false); + + let addr_a = node_a.new_onchain_address().unwrap(); + let addr_b = node_b.new_onchain_address().unwrap(); + + premine_and_distribute_funds( + &bitcoind.client, + &electrsd.client, + vec![addr_b.clone()], + Amount::from_sat(100000), + ); + + node_a.sync_wallets().unwrap(); + node_b.sync_wallets().unwrap(); + assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), 100000); + + assert_eq!(Err(NodeError::InsufficientFunds), node_a.send_to_onchain_address(&addr_b, 1000)); + + let txid = node_b.send_to_onchain_address(&addr_a, 1000).unwrap(); + generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6); + wait_for_tx(&electrsd.client, txid); + + node_a.sync_wallets().unwrap(); + node_b.sync_wallets().unwrap(); + + assert_eq!(node_a.spendable_onchain_balance_sats().unwrap(), 1000); + assert!(node_b.spendable_onchain_balance_sats().unwrap() > 98000); + assert!(node_b.spendable_onchain_balance_sats().unwrap() < 100000); + + let addr_b = node_b.new_onchain_address().unwrap(); + let txid = node_a.send_all_to_onchain_address(&addr_b).unwrap(); + generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6); + wait_for_tx(&electrsd.client, txid); + + node_a.sync_wallets().unwrap(); + node_b.sync_wallets().unwrap(); + + assert_eq!(node_a.total_onchain_balance_sats().unwrap(), 0); + assert!(node_b.spendable_onchain_balance_sats().unwrap() > 99000); + assert!(node_b.spendable_onchain_balance_sats().unwrap() < 100000); +} + +#[test] +fn sign_verify_msg() { + let (_bitcoind, electrsd) = setup_bitcoind_and_electrsd(); + let config = random_config(); + let node = setup_node(&electrsd, config); + + // Tests arbitrary message signing and later verification + let msg = "OK computer".as_bytes(); + let sig = node.sign_message(msg).unwrap(); + let pkey = node.node_id(); + assert!(node.verify_signature(msg, sig.as_str(), &pkey)); +} From 4b8220bf9633509620971dbb4e1e4123b2fb6a43 Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Mon, 18 Dec 2023 13:13:49 +0100 Subject: [PATCH 5/5] Manually download `bitcoind`/`electrs` for CI tests Previously, we used the auto-download feature of the `electrsd`/`bitcoind` crates. While convenient, they unnecessarily introduced a lot of dependecies (`zip`, `zstd`, `time`, etc.) to our test environment which needed pinning for the MSRV of 1.63. Here, we introduce a new `no_download` config flag allowing us to disable this auto-download feature in CI, where we now opt to download the corresponding binaries manually. We keep the default-auto-download as a convenience feature for running tests locally though. --- .github/workflows/rust.yml | 17 +++++++---- Cargo.toml | 7 ++++- scripts/download_bitcoind_electrs.sh | 43 ++++++++++++++++++++++++++++ 3 files changed, 61 insertions(+), 6 deletions(-) create mode 100755 scripts/download_bitcoind_electrs.sh diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index a76e1e6636..1b5ca7b439 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -46,13 +46,18 @@ jobs: cargo update -p proptest --precise "1.2.0" --verbose # proptest 1.3.0 requires rustc 1.64.0 cargo update -p reqwest --precise "0.11.20" --verbose # reqwest 0.11.21 broke 1.63.0 MSRV cargo update -p regex --precise "1.9.6" --verbose # regex 1.10.0 requires rustc 1.65.0 - cargo update -p jobserver --precise "0.1.26" --verbose # jobserver 0.1.27 requires rustc 1.66.0 - cargo update -p zstd-sys --precise "2.0.8+zstd.1.5.5" --verbose # zstd-sys 2.0.9+zstd.1.5.5 requires rustc 1.64.0 - cargo update -p petgraph --precise "0.6.3" --verbose # petgraph v0.6.4, requires rustc 1.64 or newer cargo update -p home --precise "0.5.5" --verbose # home v0.5.9, requires rustc 1.70 or newer - name: Set RUSTFLAGS to deny warnings if: "matrix.toolchain == 'stable'" run: echo "RUSTFLAGS=-D warnings" >> "$GITHUB_ENV" + - name: Download bitcoind/electrs and set environment variables + if: "matrix.platform != 'windows-latest'" + run: | + source ./scripts/download_bitcoind_electrs.sh + cp "$BITCOIND_EXE" "$HOME"/bitcoind + cp "$ELECTRS_EXE" "$HOME"/electrs + echo "BITCOIND_EXE=$HOME/bitcoind" >> "$GITHUB_ENV" + echo "ELECTRS_EXE=$HOME/electrs" >> "$GITHUB_ENV" - name: Build on Rust ${{ matrix.toolchain }} run: cargo build --verbose --color always - name: Build with UniFFI support on Rust ${{ matrix.toolchain }} @@ -69,10 +74,12 @@ jobs: run: cargo check --release --features uniffi --verbose --color always - name: Test on Rust ${{ matrix.toolchain }} if: "matrix.platform != 'windows-latest'" - run: cargo test + run: | + RUSTFLAGS="--cfg no_download" cargo test - name: Test with UniFFI support on Rust ${{ matrix.toolchain }} if: "matrix.platform != 'windows-latest' && matrix.build-uniffi" - run: cargo test --features uniffi + run: | + RUSTFLAGS="--cfg no_download" cargo test --features uniffi - name: Check formatting on Rust ${{ matrix.toolchain }} if: matrix.check-fmt run: rustup component add rustfmt && cargo fmt --all -- --check diff --git a/Cargo.toml b/Cargo.toml index cf1292a304..b831c1d75d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -76,12 +76,17 @@ winapi = { version = "0.3", features = ["winbase"] } [dev-dependencies] lightning = { version = "0.0.119", features = ["std", "_test_utils"] } #lightning = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main", features = ["std", "_test_utils"] } -electrsd = { version = "0.26.0", features = ["legacy", "esplora_a33e97e1", "bitcoind_25_0"] } electrum-client = { version = "0.15.1", default-features = true } bitcoincore-rpc = { version = "0.17.0", default-features = false } proptest = "1.0.0" regex = "1.5.6" +[target.'cfg(not(no_download))'.dev-dependencies] +electrsd = { version = "0.26.0", features = ["legacy", "esplora_a33e97e1", "bitcoind_25_0"] } + +[target.'cfg(no_download)'.dev-dependencies] +electrsd = { version = "0.26.0", features = ["legacy"] } + [target.'cfg(cln_test)'.dev-dependencies] clightningrpc = { version = "0.3.0-beta.8", default-features = false } diff --git a/scripts/download_bitcoind_electrs.sh b/scripts/download_bitcoind_electrs.sh new file mode 100755 index 0000000000..fcdb31891e --- /dev/null +++ b/scripts/download_bitcoind_electrs.sh @@ -0,0 +1,43 @@ +# Our Esplora-based tests require `electrs` and `bitcoind` +# binaries. Here, we download the binaries, validate them, and export their +# location via `ELECTRS_EXE`/`BITCOIND_EXE` which will be used by the +# `electrsd`/`bitcoind` crates in our tests. + +HOST_PLATFORM="$(rustc --version --verbose | grep "host:" | awk '{ print $2 }')" +ELECTRS_DL_ENDPOINT="https://github.com/RCasatta/electrsd/releases/download/electrs_releases" +ELECTRS_VERSION="esplora_a33e97e1a1fc63fa9c20a116bb92579bbf43b254" +BITCOIND_DL_ENDPOINT="https://bitcoincore.org/bin/" +BITCOIND_VERSION="25.1" +if [[ "$HOST_PLATFORM" == *linux* ]]; then + ELECTRS_DL_FILE_NAME=electrs_linux_"$ELECTRS_VERSION".zip + ELECTRS_DL_HASH="865e26a96e8df77df01d96f2f569dcf9622fc87a8d99a9b8fe30861a4db9ddf1" + BITCOIND_DL_FILE_NAME=bitcoin-"$BITCOIND_VERSION"-x86_64-linux-gnu.tar.gz + BITCOIND_DL_HASH="a978c407b497a727f0444156e397b50491ce862d1f906fef9b521415b3611c8b" +elif [[ "$HOST_PLATFORM" == *darwin* ]]; then + ELECTRS_DL_FILE_NAME=electrs_macos_"$ELECTRS_VERSION".zip + ELECTRS_DL_HASH="2d5ff149e8a2482d3658e9b386830dfc40c8fbd7c175ca7cbac58240a9505bcd" + BITCOIND_DL_FILE_NAME=bitcoin-"$BITCOIND_VERSION"-x86_64-apple-darwin.tar.gz + BITCOIND_DL_HASH="1acfde0ec3128381b83e3e5f54d1c7907871d324549129592144dd12a821eff1" +else + echo "\n\nUnsupported platform: $HOST_PLATFORM Exiting.." + exit 1 +fi + +DL_TMP_DIR=$(mktemp -d) +trap 'rm -rf -- "$DL_TMP_DIR"' EXIT + +pushd "$DL_TMP_DIR" +ELECTRS_DL_URL="$ELECTRS_DL_ENDPOINT"/"$ELECTRS_DL_FILE_NAME" +curl -L -o "$ELECTRS_DL_FILE_NAME" "$ELECTRS_DL_URL" +echo "$ELECTRS_DL_HASH $ELECTRS_DL_FILE_NAME"|shasum -a 256 -c +unzip "$ELECTRS_DL_FILE_NAME" +export ELECTRS_EXE="$DL_TMP_DIR"/electrs +chmod +x "$ELECTRS_EXE" + +BITCOIND_DL_URL="$BITCOIND_DL_ENDPOINT"/bitcoin-core-"$BITCOIND_VERSION"/"$BITCOIND_DL_FILE_NAME" +curl -L -o "$BITCOIND_DL_FILE_NAME" "$BITCOIND_DL_URL" +echo "$BITCOIND_DL_HASH $BITCOIND_DL_FILE_NAME"|shasum -a 256 -c +tar xzf "$BITCOIND_DL_FILE_NAME" +export BITCOIND_EXE="$DL_TMP_DIR"/bitcoin-"$BITCOIND_VERSION"/bin/bitcoind +chmod +x "$BITCOIND_EXE" +popd