Skip to content

Commit ab95762

Browse files
jkczyzjkczyz
committed
Replace expect_value_msat with expect_send
Modify all InvoicePayer unit tests to use expect_send instead of expect_value_msat, since the former can discern whether the send was for an invoice, spontaneous payment, or a retry. Updates tests to set payer expectations if they weren't already and assert these before returning a failure.
1 parent b4c7370 commit ab95762

File tree

1 file changed

+60
-60
lines changed

1 file changed

+60
-60
lines changed

‎lightning-invoice/src/payment.rs

Lines changed: 60 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -566,8 +566,9 @@ mod tests {
566566
let payment_preimage = PaymentPreimage([1; 32]);
567567
let invoice = invoice(payment_preimage);
568568
let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
569+
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
569570

570-
let payer = TestPayer::new();
571+
let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat));
571572
let router = TestRouter {};
572573
let scorer = RefCell::new(TestScorer::new());
573574
let logger = TestLogger::new();
@@ -595,8 +596,8 @@ mod tests {
595596
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
596597

597598
let payer = TestPayer::new()
598-
.expect_value_msat(final_value_msat)
599-
.expect_value_msat(final_value_msat / 2);
599+
.expect_send(Amount::ForInvoice(final_value_msat))
600+
.expect_send(Amount::OnRetry(final_value_msat / 2));
600601
let router = TestRouter {};
601602
let scorer = RefCell::new(TestScorer::new());
602603
let logger = TestLogger::new();
@@ -637,7 +638,9 @@ mod tests {
637638
let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
638639
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
639640

640-
let payer = TestPayer::new();
641+
let payer = TestPayer::new()
642+
.expect_send(Amount::OnRetry(final_value_msat / 2))
643+
.expect_send(Amount::OnRetry(final_value_msat / 2));
641644
let router = TestRouter {};
642645
let scorer = RefCell::new(TestScorer::new());
643646
let logger = TestLogger::new();
@@ -680,9 +683,9 @@ mod tests {
680683
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
681684

682685
let payer = TestPayer::new()
683-
.expect_value_msat(final_value_msat)
684-
.expect_value_msat(final_value_msat / 2)
685-
.expect_value_msat(final_value_msat / 2);
686+
.expect_send(Amount::ForInvoice(final_value_msat))
687+
.expect_send(Amount::OnRetry(final_value_msat / 2))
688+
.expect_send(Amount::OnRetry(final_value_msat / 2));
686689
let router = TestRouter {};
687690
let scorer = RefCell::new(TestScorer::new());
688691
let logger = TestLogger::new();
@@ -732,15 +735,17 @@ mod tests {
732735
let event_handled = core::cell::RefCell::new(false);
733736
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
734737

735-
let payer = TestPayer::new();
738+
let payment_preimage = PaymentPreimage([1; 32]);
739+
let invoice = invoice(payment_preimage);
740+
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
741+
742+
let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat));
736743
let router = TestRouter {};
737744
let scorer = RefCell::new(TestScorer::new());
738745
let logger = TestLogger::new();
739746
let invoice_payer =
740747
InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
741748

742-
let payment_preimage = PaymentPreimage([1; 32]);
743-
let invoice = invoice(payment_preimage);
744749
let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
745750
assert_eq!(*payer.attempts.borrow(), 1);
746751

@@ -783,15 +788,17 @@ mod tests {
783788
let event_handled = core::cell::RefCell::new(false);
784789
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
785790

786-
let payer = TestPayer::new();
791+
let payment_preimage = PaymentPreimage([1; 32]);
792+
let invoice = invoice(payment_preimage);
793+
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
794+
795+
let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat));
787796
let router = TestRouter {};
788797
let scorer = RefCell::new(TestScorer::new());
789798
let logger = TestLogger::new();
790799
let invoice_payer =
791800
InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
792801

793-
let payment_preimage = PaymentPreimage([1; 32]);
794-
let invoice = invoice(payment_preimage);
795802
let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
796803
assert_eq!(*payer.attempts.borrow(), 1);
797804

@@ -825,7 +832,8 @@ mod tests {
825832

826833
let payer = TestPayer::new()
827834
.fails_on_attempt(2)
828-
.expect_value_msat(final_value_msat);
835+
.expect_send(Amount::ForInvoice(final_value_msat))
836+
.expect_send(Amount::OnRetry(final_value_msat / 2));
829837
let router = TestRouter {};
830838
let scorer = RefCell::new(TestScorer::new());
831839
let logger = TestLogger::new();
@@ -855,15 +863,17 @@ mod tests {
855863
let event_handled = core::cell::RefCell::new(false);
856864
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
857865

858-
let payer = TestPayer::new();
866+
let payment_preimage = PaymentPreimage([1; 32]);
867+
let invoice = invoice(payment_preimage);
868+
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
869+
870+
let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat));
859871
let router = TestRouter {};
860872
let scorer = RefCell::new(TestScorer::new());
861873
let logger = TestLogger::new();
862874
let invoice_payer =
863875
InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
864876

865-
let payment_preimage = PaymentPreimage([1; 32]);
866-
let invoice = invoice(payment_preimage);
867877
let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
868878
assert_eq!(*payer.attempts.borrow(), 1);
869879

@@ -887,15 +897,19 @@ mod tests {
887897
let event_handled = core::cell::RefCell::new(false);
888898
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
889899

890-
let payer = TestPayer::new();
900+
let payment_preimage = PaymentPreimage([1; 32]);
901+
let invoice = invoice(payment_preimage);
902+
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
903+
904+
let payer = TestPayer::new()
905+
.expect_send(Amount::ForInvoice(final_value_msat))
906+
.expect_send(Amount::ForInvoice(final_value_msat));
891907
let router = TestRouter {};
892908
let scorer = RefCell::new(TestScorer::new());
893909
let logger = TestLogger::new();
894910
let invoice_payer =
895911
InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(0));
896912

897-
let payment_preimage = PaymentPreimage([1; 32]);
898-
let invoice = invoice(payment_preimage);
899913
let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
900914

901915
// Cannot repay an invoice pending payment.
@@ -946,15 +960,19 @@ mod tests {
946960

947961
#[test]
948962
fn fails_paying_invoice_with_sending_errors() {
949-
let payer = TestPayer::new().fails_on_attempt(1);
963+
let payment_preimage = PaymentPreimage([1; 32]);
964+
let invoice = invoice(payment_preimage);
965+
let final_value_msat = invoice.amount_milli_satoshis().unwrap();
966+
967+
let payer = TestPayer::new()
968+
.fails_on_attempt(1)
969+
.expect_send(Amount::ForInvoice(final_value_msat));
950970
let router = TestRouter {};
951971
let scorer = RefCell::new(TestScorer::new());
952972
let logger = TestLogger::new();
953973
let invoice_payer =
954974
InvoicePayer::new(&payer, router, &scorer, &logger, |_: &_| {}, RetryAttempts(0));
955975

956-
let payment_preimage = PaymentPreimage([1; 32]);
957-
let invoice = invoice(payment_preimage);
958976
match invoice_payer.pay_invoice(&invoice) {
959977
Err(PaymentError::Sending(_)) => {},
960978
Err(_) => panic!("unexpected error"),
@@ -972,7 +990,7 @@ mod tests {
972990
let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
973991
let final_value_msat = 100;
974992

975-
let payer = TestPayer::new().expect_value_msat(final_value_msat);
993+
let payer = TestPayer::new().expect_send(Amount::ForInvoice(final_value_msat));
976994
let router = TestRouter {};
977995
let scorer = RefCell::new(TestScorer::new());
978996
let logger = TestLogger::new();
@@ -1026,7 +1044,7 @@ mod tests {
10261044

10271045
let payer = TestPayer::new()
10281046
.expect_send(Amount::Spontaneous(final_value_msat))
1029-
.expect_send(Amount::ForInvoiceOrRetry(final_value_msat));
1047+
.expect_send(Amount::OnRetry(final_value_msat));
10301048
let router = TestRouter {};
10311049
let scorer = RefCell::new(TestScorer::new());
10321050
let logger = TestLogger::new();
@@ -1077,7 +1095,9 @@ mod tests {
10771095
let short_channel_id = Some(path[0].short_channel_id);
10781096

10791097
// Expect that scorer is given short_channel_id upon handling the event.
1080-
let payer = TestPayer::new();
1098+
let payer = TestPayer::new()
1099+
.expect_send(Amount::ForInvoice(final_value_msat))
1100+
.expect_send(Amount::OnRetry(final_value_msat / 2));
10811101
let router = TestRouter {};
10821102
let scorer = RefCell::new(TestScorer::new().expect_channel_failure(short_channel_id.unwrap()));
10831103
let logger = TestLogger::new();
@@ -1218,8 +1238,9 @@ mod tests {
12181238

12191239
#[derive(Clone, Debug, PartialEq, Eq)]
12201240
enum Amount {
1221-
ForInvoiceOrRetry(u64),
1241+
ForInvoice(u64),
12221242
Spontaneous(u64),
1243+
OnRetry(u64),
12231244
}
12241245

12251246
impl TestPayer {
@@ -1231,11 +1252,6 @@ mod tests {
12311252
}
12321253
}
12331254

1234-
fn expect_value_msat(self, value_msat: u64) -> Self {
1235-
self.expectations.borrow_mut().push_back(Amount::ForInvoiceOrRetry(value_msat));
1236-
self
1237-
}
1238-
12391255
fn expect_send(self, value_msat: Amount) -> Self {
12401256
self.expectations.borrow_mut().push_back(value_msat);
12411257
self
@@ -1249,13 +1265,13 @@ mod tests {
12491265
}
12501266
}
12511267

1252-
fn check_attempts(&self) -> bool {
1268+
fn check_attempts(&self) -> Result<PaymentId, PaymentSendFailure> {
12531269
let mut attempts = self.attempts.borrow_mut();
12541270
*attempts += 1;
12551271
match self.failing_on_attempt {
1256-
None => true,
1257-
Some(attempt) if attempt != *attempts => true,
1258-
Some(_) => false,
1272+
None => Ok(PaymentId([1; 32])),
1273+
Some(attempt) if attempt != *attempts => Ok(PaymentId([1; 32])),
1274+
Some(_) => Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed)),
12591275
}
12601276
}
12611277

@@ -1290,41 +1306,25 @@ mod tests {
12901306
}
12911307

12921308
fn send_payment(
1293-
&self,
1294-
route: &Route,
1295-
_payment_hash: PaymentHash,
1309+
&self, route: &Route, _payment_hash: PaymentHash,
12961310
_payment_secret: &Option<PaymentSecret>
12971311
) -> Result<PaymentId, PaymentSendFailure> {
1298-
if self.check_attempts() {
1299-
self.check_value_msats(Amount::ForInvoiceOrRetry(route.get_total_amount()));
1300-
Ok(PaymentId([1; 32]))
1301-
} else {
1302-
Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed))
1303-
}
1312+
self.check_value_msats(Amount::ForInvoice(route.get_total_amount()));
1313+
self.check_attempts()
13041314
}
13051315

13061316
fn send_spontaneous_payment(
1307-
&self,
1308-
route: &Route,
1309-
_payment_preimage: PaymentPreimage,
1317+
&self, route: &Route, _payment_preimage: PaymentPreimage,
13101318
) -> Result<PaymentId, PaymentSendFailure> {
1311-
if self.check_attempts() {
1312-
self.check_value_msats(Amount::Spontaneous(route.get_total_amount()));
1313-
Ok(PaymentId([1; 32]))
1314-
} else {
1315-
Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed))
1316-
}
1319+
self.check_value_msats(Amount::Spontaneous(route.get_total_amount()));
1320+
self.check_attempts()
13171321
}
13181322

13191323
fn retry_payment(
13201324
&self, route: &Route, _payment_id: PaymentId
13211325
) -> Result<(), PaymentSendFailure> {
1322-
if self.check_attempts() {
1323-
self.check_value_msats(Amount::ForInvoiceOrRetry(route.get_total_amount()));
1324-
Ok(())
1325-
} else {
1326-
Err(PaymentSendFailure::ParameterError(APIError::MonitorUpdateFailed))
1327-
}
1326+
self.check_value_msats(Amount::OnRetry(route.get_total_amount()));
1327+
self.check_attempts().map(|_| ())
13281328
}
13291329
}
13301330

0 commit comments

Comments
 (0)