Skip to content

Commit facf996

Browse files
TheBlueMattTheBlueMatt
committed
Refactor test utils and add a simple MPP send/claim test.
1 parent 4668a55 commit facf996

File tree

2 files changed

+151
-105
lines changed

2 files changed

+151
-105
lines changed

‎lightning/src/ln/functional_test_utils.rs

Lines changed: 117 additions & 103 deletions
Original file line numberDiff line numberDiff line change
@@ -758,51 +758,55 @@ macro_rules! expect_payment_failed {
758758
}
759759
}
760760

761-
pub fn send_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: Option<[u8; 32]>) {
762-
let mut payment_event = {
763-
origin_node.node.send_payment(route, our_payment_hash, our_payment_secret.as_ref()).unwrap();
764-
check_added_monitors!(origin_node, 1);
765-
766-
let mut events = origin_node.node.get_and_clear_pending_msg_events();
767-
assert_eq!(events.len(), 1);
768-
SendEvent::from_event(events.remove(0))
769-
};
770-
let mut prev_node = origin_node;
771-
772-
for (idx, &node) in expected_route.iter().enumerate() {
773-
assert_eq!(node.node.get_our_node_id(), payment_event.node_id);
774-
775-
node.node.handle_update_add_htlc(&prev_node.node.get_our_node_id(), &payment_event.msgs[0]);
776-
check_added_monitors!(node, 0);
777-
commitment_signed_dance!(node, prev_node, payment_event.commitment_msg, false);
778-
779-
expect_pending_htlcs_forwardable!(node);
780-
781-
if idx == expected_route.len() - 1 {
782-
let events_2 = node.node.get_and_clear_pending_events();
783-
assert_eq!(events_2.len(), 1);
784-
match events_2[0] {
785-
Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
786-
assert_eq!(our_payment_hash, *payment_hash);
787-
assert_eq!(our_payment_secret, *payment_secret);
788-
assert_eq!(amt, recv_value);
789-
},
790-
_ => panic!("Unexpected event"),
761+
pub fn send_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_paths: &[&[&Node<'a, 'b, 'c>]], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: Option<[u8; 32]>) {
762+
origin_node.node.send_payment(route, our_payment_hash, our_payment_secret.as_ref()).unwrap();
763+
check_added_monitors!(origin_node, expected_paths.len());
764+
765+
let mut events = origin_node.node.get_and_clear_pending_msg_events();
766+
assert_eq!(events.len(), expected_paths.len());
767+
for (path_idx, (ev, expected_route)) in events.drain(..).zip(expected_paths.iter()).enumerate() {
768+
let mut payment_event = SendEvent::from_event(ev);
769+
let mut prev_node = origin_node;
770+
771+
for (idx, &node) in expected_route.iter().enumerate() {
772+
assert_eq!(node.node.get_our_node_id(), payment_event.node_id);
773+
774+
node.node.handle_update_add_htlc(&prev_node.node.get_our_node_id(), &payment_event.msgs[0]);
775+
check_added_monitors!(node, 0);
776+
commitment_signed_dance!(node, prev_node, payment_event.commitment_msg, false);
777+
778+
expect_pending_htlcs_forwardable!(node);
779+
780+
if idx == expected_route.len() - 1 {
781+
let events_2 = node.node.get_and_clear_pending_events();
782+
if path_idx == expected_paths.len() - 1 {
783+
assert_eq!(events_2.len(), 1);
784+
match events_2[0] {
785+
Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
786+
assert_eq!(our_payment_hash, *payment_hash);
787+
assert_eq!(our_payment_secret, *payment_secret);
788+
assert_eq!(amt, recv_value);
789+
},
790+
_ => panic!("Unexpected event"),
791+
}
792+
} else {
793+
assert!(events_2.is_empty());
794+
}
795+
} else {
796+
let mut events_2 = node.node.get_and_clear_pending_msg_events();
797+
assert_eq!(events_2.len(), 1);
798+
check_added_monitors!(node, 1);
799+
payment_event = SendEvent::from_event(events_2.remove(0));
800+
assert_eq!(payment_event.msgs.len(), 1);
791801
}
792-
} else {
793-
let mut events_2 = node.node.get_and_clear_pending_msg_events();
794-
assert_eq!(events_2.len(), 1);
795-
check_added_monitors!(node, 1);
796-
payment_event = SendEvent::from_event(events_2.remove(0));
797-
assert_eq!(payment_event.msgs.len(), 1);
798-
}
799802

800-
prev_node = node;
803+
prev_node = node;
804+
}
801805
}
802806
}
803807

804808
pub fn send_along_route_with_hash<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64, our_payment_hash: PaymentHash) {
805-
send_along_route_with_secret(origin_node, route, expected_route, recv_value, our_payment_hash, None);
809+
send_along_route_with_secret(origin_node, route, &[expected_route], recv_value, our_payment_hash, None);
806810
}
807811

808812
pub fn send_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash) {
@@ -811,86 +815,96 @@ pub fn send_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route
811815
(our_payment_preimage, our_payment_hash)
812816
}
813817

814-
pub fn claim_payment_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], skip_last: bool, our_payment_preimage: PaymentPreimage, our_payment_secret: Option<[u8; 32]>, expected_amount: u64) {
815-
assert!(expected_route.last().unwrap().node.claim_funds(our_payment_preimage, &our_payment_secret, expected_amount));
816-
check_added_monitors!(expected_route.last().unwrap(), 1);
818+
pub fn claim_payment_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_paths: &[&[&Node<'a, 'b, 'c>]], skip_last: bool, our_payment_preimage: PaymentPreimage, our_payment_secret: Option<[u8; 32]>, expected_amount: u64) {
819+
for path in expected_paths.iter() {
820+
assert_eq!(path.last().unwrap().node.get_our_node_id(), expected_paths[0].last().unwrap().node.get_our_node_id());
821+
}
822+
assert!(expected_paths[0].last().unwrap().node.claim_funds(our_payment_preimage, &our_payment_secret, expected_amount));
823+
check_added_monitors!(expected_paths[0].last().unwrap(), expected_paths.len());
817824

818-
let mut next_msgs: Option<(msgs::UpdateFulfillHTLC, msgs::CommitmentSigned)> = None;
819-
let mut expected_next_node = expected_route.last().unwrap().node.get_our_node_id();
820-
macro_rules! get_next_msgs {
821-
($node: expr) => {
822-
{
823-
let events = $node.node.get_and_clear_pending_msg_events();
824-
assert_eq!(events.len(), 1);
825-
match events[0] {
826-
MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => {
827-
assert!(update_add_htlcs.is_empty());
828-
assert_eq!(update_fulfill_htlcs.len(), 1);
829-
assert!(update_fail_htlcs.is_empty());
830-
assert!(update_fail_malformed_htlcs.is_empty());
831-
assert!(update_fee.is_none());
832-
expected_next_node = node_id.clone();
833-
Some((update_fulfill_htlcs[0].clone(), commitment_signed.clone()))
834-
},
835-
_ => panic!("Unexpected event"),
836-
}
825+
macro_rules! msgs_from_ev {
826+
($ev: expr) => {
827+
match $ev {
828+
&MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => {
829+
assert!(update_add_htlcs.is_empty());
830+
assert_eq!(update_fulfill_htlcs.len(), 1);
831+
assert!(update_fail_htlcs.is_empty());
832+
assert!(update_fail_malformed_htlcs.is_empty());
833+
assert!(update_fee.is_none());
834+
((update_fulfill_htlcs[0].clone(), commitment_signed.clone()), node_id.clone())
835+
},
836+
_ => panic!("Unexpected event"),
837837
}
838838
}
839839
}
840+
let mut per_path_msgs: Vec<((msgs::UpdateFulfillHTLC, msgs::CommitmentSigned), PublicKey)> = Vec::with_capacity(expected_paths.len());
841+
let events = expected_paths[0].last().unwrap().node.get_and_clear_pending_msg_events();
842+
assert_eq!(events.len(), expected_paths.len());
843+
for ev in events.iter() {
844+
per_path_msgs.push(msgs_from_ev!(ev));
845+
}
840846

841-
macro_rules! last_update_fulfill_dance {
842-
($node: expr, $prev_node: expr) => {
843-
{
844-
$node.node.handle_update_fulfill_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0);
845-
check_added_monitors!($node, 0);
846-
assert!($node.node.get_and_clear_pending_msg_events().is_empty());
847-
commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false);
847+
for (expected_route, (path_msgs, next_hop)) in expected_paths.iter().zip(per_path_msgs.drain(..)) {
848+
let mut next_msgs = Some(path_msgs);
849+
let mut expected_next_node = next_hop;
850+
851+
macro_rules! last_update_fulfill_dance {
852+
($node: expr, $prev_node: expr) => {
853+
{
854+
$node.node.handle_update_fulfill_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0);
855+
check_added_monitors!($node, 0);
856+
assert!($node.node.get_and_clear_pending_msg_events().is_empty());
857+
commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false);
858+
}
848859
}
849860
}
850-
}
851-
macro_rules! mid_update_fulfill_dance {
852-
($node: expr, $prev_node: expr, $new_msgs: expr) => {
853-
{
854-
$node.node.handle_update_fulfill_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0);
855-
check_added_monitors!($node, 1);
856-
let new_next_msgs = if $new_msgs {
857-
get_next_msgs!($node)
858-
} else {
859-
assert!($node.node.get_and_clear_pending_msg_events().is_empty());
860-
None
861-
};
862-
commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false);
863-
next_msgs = new_next_msgs;
861+
macro_rules! mid_update_fulfill_dance {
862+
($node: expr, $prev_node: expr, $new_msgs: expr) => {
863+
{
864+
$node.node.handle_update_fulfill_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0);
865+
check_added_monitors!($node, 1);
866+
let new_next_msgs = if $new_msgs {
867+
let events = $node.node.get_and_clear_pending_msg_events();
868+
assert_eq!(events.len(), 1);
869+
let (res, nexthop) = msgs_from_ev!(&events[0]);
870+
expected_next_node = nexthop;
871+
Some(res)
872+
} else {
873+
assert!($node.node.get_and_clear_pending_msg_events().is_empty());
874+
None
875+
};
876+
commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false);
877+
next_msgs = new_next_msgs;
878+
}
864879
}
865880
}
866-
}
867881

868-
let mut prev_node = expected_route.last().unwrap();
869-
for (idx, node) in expected_route.iter().rev().enumerate() {
870-
assert_eq!(expected_next_node, node.node.get_our_node_id());
871-
let update_next_msgs = !skip_last || idx != expected_route.len() - 1;
872-
if next_msgs.is_some() {
873-
mid_update_fulfill_dance!(node, prev_node, update_next_msgs);
874-
} else if update_next_msgs {
875-
next_msgs = get_next_msgs!(node);
876-
} else {
877-
assert!(node.node.get_and_clear_pending_msg_events().is_empty());
878-
}
879-
if !skip_last && idx == expected_route.len() - 1 {
880-
assert_eq!(expected_next_node, origin_node.node.get_our_node_id());
881-
}
882+
let mut prev_node = expected_route.last().unwrap();
883+
for (idx, node) in expected_route.iter().rev().enumerate().skip(1) {
884+
assert_eq!(expected_next_node, node.node.get_our_node_id());
885+
let update_next_msgs = !skip_last || idx != expected_route.len() - 1;
886+
if next_msgs.is_some() {
887+
mid_update_fulfill_dance!(node, prev_node, update_next_msgs);
888+
} else {
889+
assert!(!update_next_msgs);
890+
assert!(node.node.get_and_clear_pending_msg_events().is_empty());
891+
}
892+
if !skip_last && idx == expected_route.len() - 1 {
893+
assert_eq!(expected_next_node, origin_node.node.get_our_node_id());
894+
}
882895

883-
prev_node = node;
884-
}
896+
prev_node = node;
897+
}
885898

886-
if !skip_last {
887-
last_update_fulfill_dance!(origin_node, expected_route.first().unwrap());
888-
expect_payment_sent!(origin_node, our_payment_preimage);
899+
if !skip_last {
900+
last_update_fulfill_dance!(origin_node, expected_route.first().unwrap());
901+
expect_payment_sent!(origin_node, our_payment_preimage);
902+
}
889903
}
890904
}
891905

892906
pub fn claim_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], skip_last: bool, our_payment_preimage: PaymentPreimage, expected_amount: u64) {
893-
claim_payment_along_route_with_secret(origin_node, expected_route, skip_last, our_payment_preimage, None, expected_amount);
907+
claim_payment_along_route_with_secret(origin_node, &[expected_route], skip_last, our_payment_preimage, None, expected_amount);
894908
}
895909

896910
pub fn claim_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], our_payment_preimage: PaymentPreimage, expected_amount: u64) {

‎lightning/src/ln/functional_tests.rs

Lines changed: 34 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7260,10 +7260,42 @@ fn test_simple_payment_secret() {
72607260
let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
72617261
let (_, payment_secret) = get_payment_preimage_hash!(&nodes[0]);
72627262
let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
7263-
send_along_route_with_secret(&nodes[0], route, &[&nodes[1], &nodes[2]], 100000, payment_hash, Some(payment_secret.0));
7263+
send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[2]]], 100000, payment_hash, Some(payment_secret.0));
72647264
// Claiming with all the correct values but the wrong secret should result in nothing...
72657265
assert_eq!(nodes[2].node.claim_funds(payment_preimage, &None, 100_000), false);
72667266
assert_eq!(nodes[2].node.claim_funds(payment_preimage, &Some([42; 32]), 100_000), false);
72677267
// ...but with the right secret we should be able to claim all the way back
7268-
claim_payment_along_route_with_secret(&nodes[0], &[&nodes[1], &nodes[2]], false, payment_preimage, Some(payment_secret.0), 100_000);
7268+
claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[2]]], false, payment_preimage, Some(payment_secret.0), 100_000);
7269+
}
7270+
7271+
#[test]
7272+
fn test_simple_mpp() {
7273+
// Simple test of sending a multi-path payment.
7274+
let chanmon_cfgs = create_chanmon_cfgs(4);
7275+
let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
7276+
let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
7277+
let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
7278+
7279+
let chan_1_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
7280+
let chan_2_id = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
7281+
let chan_3_id = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
7282+
let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::supported(), InitFeatures::supported()).0.contents.short_channel_id;
7283+
7284+
let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
7285+
let (_, payment_secret) = get_payment_preimage_hash!(&nodes[0]);
7286+
let mut route = nodes[0].router.get_route(&nodes[3].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
7287+
let path = route.paths[0].clone();
7288+
route.paths.push(path);
7289+
route.paths[0][0].pubkey = nodes[1].node.get_our_node_id();
7290+
route.paths[0][0].short_channel_id = chan_1_id;
7291+
route.paths[0][1].short_channel_id = chan_3_id;
7292+
route.paths[1][0].pubkey = nodes[2].node.get_our_node_id();
7293+
route.paths[1][0].short_channel_id = chan_2_id;
7294+
route.paths[1][1].short_channel_id = chan_4_id;
7295+
send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], 200_000, payment_hash, Some(payment_secret.0));
7296+
// Claiming with all the correct values but the wrong secret should result in nothing...
7297+
assert_eq!(nodes[3].node.claim_funds(payment_preimage, &None, 200_000), false);
7298+
assert_eq!(nodes[3].node.claim_funds(payment_preimage, &Some([42; 32]), 200_000), false);
7299+
// ...but with the right secret we should be able to claim all the way back
7300+
claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage, Some(payment_secret.0), 200_000);
72697301
}

0 commit comments

Comments
 (0)