Skip to content

Commit 7d4a8a5

Browse files
naumenkogsnaumenkogs
committed
Make older compilers happy about ownership in tests
1 parent c25e09e commit 7d4a8a5

File tree

2 files changed

+135
-98
lines changed

2 files changed

+135
-98
lines changed

‎lightning/src/ln/chanmon_update_fail_tests.rs

Lines changed: 114 additions & 85 deletions
Original file line numberDiff line numberDiff line change
@@ -64,10 +64,12 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
6464

6565
*nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
6666

67-
let network_graph = &nodes[0].network_graph;
68-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
69-
unwrap_send_err!(nodes[0].node.send_payment(&route, payment_hash_1, &None), false, APIError::MonitorUpdateFailed, {});
70-
check_added_monitors!(nodes[0], 1);
67+
{
68+
let network_graph = &nodes[0].network_graph;
69+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
70+
unwrap_send_err!(nodes[0].node.send_payment(&route, payment_hash_1, &None), false, APIError::MonitorUpdateFailed, {});
71+
check_added_monitors!(nodes[0], 1);
72+
}
7173

7274
assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
7375
assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
@@ -108,11 +110,13 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
108110

109111
// Now set it to failed again...
110112
let (_, payment_hash_2) = get_payment_preimage_hash!(&nodes[0]);
111-
*nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
112-
let network_graph = &nodes[0].network_graph;
113-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
114-
unwrap_send_err!(nodes[0].node.send_payment(&route, payment_hash_2, &None), false, APIError::MonitorUpdateFailed, {});
115-
check_added_monitors!(nodes[0], 1);
113+
{
114+
*nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
115+
let network_graph = &nodes[0].network_graph;
116+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
117+
unwrap_send_err!(nodes[0].node.send_payment(&route, payment_hash_2, &None), false, APIError::MonitorUpdateFailed, {});
118+
check_added_monitors!(nodes[0], 1);
119+
}
116120

117121
assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
118122
assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
@@ -171,12 +175,13 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
171175

172176
// Now try to send a second payment which will fail to send
173177
let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
174-
175-
*nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
176-
let network_graph = &nodes[0].network_graph;
177-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
178-
unwrap_send_err!(nodes[0].node.send_payment(&route, payment_hash_2, &None), false, APIError::MonitorUpdateFailed, {});
179-
check_added_monitors!(nodes[0], 1);
178+
{
179+
*nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
180+
let network_graph = &nodes[0].network_graph;
181+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
182+
unwrap_send_err!(nodes[0].node.send_payment(&route, payment_hash_2, &None), false, APIError::MonitorUpdateFailed, {});
183+
check_added_monitors!(nodes[0], 1);
184+
}
180185

181186
assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
182187
assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
@@ -501,10 +506,12 @@ fn test_monitor_update_fail_cs() {
501506
let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
502507

503508
let (payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
504-
let network_graph = &nodes[0].network_graph;
505-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
506-
nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
507-
check_added_monitors!(nodes[0], 1);
509+
{
510+
let network_graph = &nodes[0].network_graph;
511+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
512+
nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
513+
check_added_monitors!(nodes[0], 1);
514+
}
508515

509516
let send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
510517
nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]);
@@ -587,10 +594,12 @@ fn test_monitor_update_fail_no_rebroadcast() {
587594
let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
588595

589596
let (payment_preimage_1, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
590-
let network_graph = &nodes[0].network_graph;
591-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
592-
nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
593-
check_added_monitors!(nodes[0], 1);
597+
{
598+
let network_graph = &nodes[0].network_graph;
599+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
600+
nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
601+
check_added_monitors!(nodes[0], 1);
602+
}
594603

595604
let send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
596605
nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]);
@@ -634,19 +643,22 @@ fn test_monitor_update_raa_while_paused() {
634643
let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported()).2;
635644

636645
send_payment(&nodes[0], &[&nodes[1]], 5000000, 5_000_000);
637-
638646
let (payment_preimage_1, our_payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
639-
let network_graph = &nodes[0].network_graph;
640-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
641-
nodes[0].node.send_payment(&route, our_payment_hash_1, &None).unwrap();
642-
check_added_monitors!(nodes[0], 1);
647+
{
648+
let network_graph = &nodes[0].network_graph;
649+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
650+
nodes[0].node.send_payment(&route, our_payment_hash_1, &None).unwrap();
651+
check_added_monitors!(nodes[0], 1);
652+
}
643653
let send_event_1 = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
644654

645655
let (payment_preimage_2, our_payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
646-
let network_graph = &nodes[1].network_graph;
647-
let route = nodes[1].router.get_route(network_graph, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
648-
nodes[1].node.send_payment(&route, our_payment_hash_2, &None).unwrap();
649-
check_added_monitors!(nodes[1], 1);
656+
{
657+
let network_graph = &nodes[1].network_graph;
658+
let route = nodes[1].router.get_route(network_graph, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
659+
nodes[1].node.send_payment(&route, our_payment_hash_2, &None).unwrap();
660+
check_added_monitors!(nodes[1], 1);
661+
}
650662
let send_event_2 = SendEvent::from_event(nodes[1].node.get_and_clear_pending_msg_events().remove(0));
651663

652664
nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event_1.msgs[0]);
@@ -732,10 +744,12 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
732744
// While the second channel is AwaitingRAA, forward a second payment to get it into the
733745
// holding cell.
734746
let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
735-
let network_graph = &nodes[0].network_graph;
736-
let route = nodes[0].router.get_route(network_graph, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
737-
nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
738-
check_added_monitors!(nodes[0], 1);
747+
{
748+
let network_graph = &nodes[0].network_graph;
749+
let route = nodes[0].router.get_route(network_graph, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
750+
nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
751+
check_added_monitors!(nodes[0], 1);
752+
}
739753

740754
let mut send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
741755
nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]);
@@ -756,12 +770,13 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
756770

757771
// Attempt to forward a third payment but fail due to the second channel being unavailable
758772
// for forwarding.
759-
760773
let (_, payment_hash_3) = get_payment_preimage_hash!(nodes[0]);
761-
let network_graph = &nodes[0].network_graph;
762-
let route = nodes[0].router.get_route(network_graph, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
763-
nodes[0].node.send_payment(&route, payment_hash_3, &None).unwrap();
764-
check_added_monitors!(nodes[0], 1);
774+
{
775+
let network_graph = &nodes[0].network_graph;
776+
let route = nodes[0].router.get_route(network_graph, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
777+
nodes[0].node.send_payment(&route, payment_hash_3, &None).unwrap();
778+
check_added_monitors!(nodes[0], 1);
779+
}
765780

766781
*nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(()); // We succeed in updating the monitor for the first channel
767782
send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
@@ -1058,12 +1073,14 @@ fn raa_no_response_awaiting_raa_state() {
10581073
// immediately after a CS. By setting failing the monitor update failure from the CS (which
10591074
// requires only an RAA response due to AwaitingRAA) we can deliver the RAA and require the CS
10601075
// generation during RAA while in monitor-update-failed state.
1061-
let network_graph = &nodes[0].network_graph;
1062-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1063-
nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap();
1064-
check_added_monitors!(nodes[0], 1);
1065-
nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
1066-
check_added_monitors!(nodes[0], 0);
1076+
{
1077+
let network_graph = &nodes[0].network_graph;
1078+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1079+
nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap();
1080+
check_added_monitors!(nodes[0], 1);
1081+
nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
1082+
check_added_monitors!(nodes[0], 0);
1083+
}
10671084

10681085
let mut events = nodes[0].node.get_and_clear_pending_msg_events();
10691086
assert_eq!(events.len(), 1);
@@ -1110,12 +1127,13 @@ fn raa_no_response_awaiting_raa_state() {
11101127
// We send a third payment here, which is somewhat of a redundant test, but the
11111128
// chanmon_fail_consistency test required it to actually find the bug (by seeing out-of-sync
11121129
// commitment transaction states) whereas here we can explicitly check for it.
1113-
let network_graph = &nodes[0].network_graph;
1114-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1115-
nodes[0].node.send_payment(&route, payment_hash_3, &None).unwrap();
1116-
check_added_monitors!(nodes[0], 0);
1117-
assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1118-
1130+
{
1131+
let network_graph = &nodes[0].network_graph;
1132+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1133+
nodes[0].node.send_payment(&route, payment_hash_3, &None).unwrap();
1134+
check_added_monitors!(nodes[0], 0);
1135+
assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1136+
}
11191137
nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_responses.0);
11201138
check_added_monitors!(nodes[0], 1);
11211139
let mut events = nodes[0].node.get_and_clear_pending_msg_events();
@@ -1200,10 +1218,12 @@ fn claim_while_disconnected_monitor_update_fail() {
12001218
// Send a second payment from A to B, resulting in a commitment update that gets swallowed with
12011219
// the monitor still failed
12021220
let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1203-
let network_graph = &nodes[0].network_graph;
1204-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1205-
nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
1206-
check_added_monitors!(nodes[0], 1);
1221+
{
1222+
let network_graph = &nodes[0].network_graph;
1223+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1224+
nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
1225+
check_added_monitors!(nodes[0], 1);
1226+
}
12071227

12081228
let as_updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
12091229
nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &as_updates.update_add_htlcs[0]);
@@ -1293,10 +1313,12 @@ fn monitor_failed_no_reestablish_response() {
12931313
// Route the payment and deliver the initial commitment_signed (with a monitor update failure
12941314
// on receipt).
12951315
let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
1296-
let network_graph = &nodes[0].network_graph;
1297-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1298-
nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap();
1299-
check_added_monitors!(nodes[0], 1);
1316+
{
1317+
let network_graph = &nodes[0].network_graph;
1318+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1319+
nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap();
1320+
check_added_monitors!(nodes[0], 1);
1321+
}
13001322

13011323
*nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
13021324
let mut events = nodes[0].node.get_and_clear_pending_msg_events();
@@ -1364,10 +1386,12 @@ fn first_message_on_recv_ordering() {
13641386
// Route the first payment outbound, holding the last RAA for B until we are set up so that we
13651387
// can deliver it and fail the monitor update.
13661388
let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
1367-
let network_graph = &nodes[0].network_graph;
1368-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1369-
nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap();
1370-
check_added_monitors!(nodes[0], 1);
1389+
{
1390+
let network_graph = &nodes[0].network_graph;
1391+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1392+
nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap();
1393+
check_added_monitors!(nodes[0], 1);
1394+
}
13711395

13721396
let mut events = nodes[0].node.get_and_clear_pending_msg_events();
13731397
assert_eq!(events.len(), 1);
@@ -1387,11 +1411,12 @@ fn first_message_on_recv_ordering() {
13871411

13881412
// Route the second payment, generating an update_add_htlc/commitment_signed
13891413
let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1390-
let network_graph = &nodes[0].network_graph;
1391-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1392-
nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
1393-
1394-
check_added_monitors!(nodes[0], 1);
1414+
{
1415+
let network_graph = &nodes[0].network_graph;
1416+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1417+
nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
1418+
check_added_monitors!(nodes[0], 1);
1419+
}
13951420
let mut events = nodes[0].node.get_and_clear_pending_msg_events();
13961421
assert_eq!(events.len(), 1);
13971422
let payment_event = SendEvent::from_event(events.pop().unwrap());
@@ -1465,10 +1490,12 @@ fn test_monitor_update_fail_claim() {
14651490
check_added_monitors!(nodes[1], 1);
14661491

14671492
let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1468-
let network_graph = &nodes[2].network_graph;
1469-
let route = nodes[2].router.get_route(network_graph, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1470-
nodes[2].node.send_payment(&route, payment_hash_2, &None).unwrap();
1471-
check_added_monitors!(nodes[2], 1);
1493+
{
1494+
let network_graph = &nodes[2].network_graph;
1495+
let route = nodes[2].router.get_route(network_graph, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1496+
nodes[2].node.send_payment(&route, payment_hash_2, &None).unwrap();
1497+
check_added_monitors!(nodes[2], 1);
1498+
}
14721499

14731500
// Successfully update the monitor on the 1<->2 channel, but the 0<->1 channel should still be
14741501
// paused, so forward shouldn't succeed until we call channel_monitor_updated().
@@ -1547,10 +1574,12 @@ fn test_monitor_update_on_pending_forwards() {
15471574
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
15481575

15491576
let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1550-
let network_graph = &nodes[2].network_graph;
1551-
let route = nodes[2].router.get_route(network_graph, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1552-
nodes[2].node.send_payment(&route, payment_hash_2, &None).unwrap();
1553-
check_added_monitors!(nodes[2], 1);
1577+
{
1578+
let network_graph = &nodes[2].network_graph;
1579+
let route = nodes[2].router.get_route(network_graph, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1580+
nodes[2].node.send_payment(&route, payment_hash_2, &None).unwrap();
1581+
check_added_monitors!(nodes[2], 1);
1582+
}
15541583

15551584
let mut events = nodes[2].node.get_and_clear_pending_msg_events();
15561585
assert_eq!(events.len(), 1);
@@ -1607,11 +1636,12 @@ fn monitor_update_claim_fail_no_response() {
16071636

16081637
// Now start forwarding a second payment, skipping the last RAA so B is in AwaitingRAA
16091638
let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1610-
let network_graph = &nodes[0].network_graph;
1611-
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1612-
nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
1613-
1614-
check_added_monitors!(nodes[0], 1);
1639+
{
1640+
let network_graph = &nodes[0].network_graph;
1641+
let route = nodes[0].router.get_route(network_graph, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1642+
nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
1643+
check_added_monitors!(nodes[0], 1);
1644+
}
16151645

16161646
let mut events = nodes[0].node.get_and_clear_pending_msg_events();
16171647
assert_eq!(events.len(), 1);
@@ -1772,8 +1802,7 @@ fn test_path_paused_mpp() {
17721802

17731803
let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
17741804
let payment_secret = PaymentSecret([0xdb; 32]);
1775-
let network_graph = &nodes[0].network_graph;
1776-
let mut route = nodes[0].router.get_route(network_graph, &nodes[3].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
1805+
let mut route = nodes[0].router.get_route(&nodes[0].network_graph, &nodes[3].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
17771806

17781807
// Set us up to take multiple routes, one 0 -> 1 -> 3 and one 0 -> 2 -> 3:
17791808
let path = route.paths[0].clone();

0 commit comments

Comments
 (0)