- fn retries_payment_path_for_unknown_payment() {
- let event_handled = core::cell::RefCell::new(false);
- let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
-
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
- let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
- let final_value_msat = invoice.amount_milli_satoshis().unwrap();
-
- let payer = TestPayer::new();
- let router = TestRouter {};
- let scorer = RefCell::new(TestScorer::new());
- let logger = TestLogger::new();
- let invoice_payer =
- InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
-
- let payment_id = Some(PaymentId([1; 32]));
- let event = Event::PaymentPathFailed {
- payment_id,
- payment_hash,
- network_update: None,
- rejected_by_dest: false,
- all_paths_failed: false,
- path: TestRouter::path_for_value(final_value_msat),
- short_channel_id: None,
- retry: Some(TestRouter::retry_for_invoice(&invoice)),
- };
- invoice_payer.handle_event(&event);
- assert_eq!(*event_handled.borrow(), false);
- assert_eq!(*payer.attempts.borrow(), 1);
-
- invoice_payer.handle_event(&event);
- assert_eq!(*event_handled.borrow(), false);
- assert_eq!(*payer.attempts.borrow(), 2);
-
- invoice_payer.handle_event(&Event::PaymentSent {
- payment_id, payment_preimage, payment_hash, fee_paid_msat: None
- });
- assert_eq!(*event_handled.borrow(), true);
- assert_eq!(*payer.attempts.borrow(), 2);
- }
-
- #[test]
- fn fails_paying_invoice_after_max_retries() {
- let event_handled = core::cell::RefCell::new(false);
- let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
-
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
- let final_value_msat = invoice.amount_milli_satoshis().unwrap();
-
- let payer = TestPayer::new()
- .expect_value_msat(final_value_msat)
- .expect_value_msat(final_value_msat / 2)
- .expect_value_msat(final_value_msat / 2);
- let router = TestRouter {};
- let scorer = RefCell::new(TestScorer::new());
- let logger = TestLogger::new();
- let invoice_payer =
- InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
-
- let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
- assert_eq!(*payer.attempts.borrow(), 1);
-
- let event = Event::PaymentPathFailed {
- payment_id,
- payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
- network_update: None,
- rejected_by_dest: false,
- all_paths_failed: true,
- path: TestRouter::path_for_value(final_value_msat),
- short_channel_id: None,
- retry: Some(TestRouter::retry_for_invoice(&invoice)),
- };
- invoice_payer.handle_event(&event);
- assert_eq!(*event_handled.borrow(), false);
- assert_eq!(*payer.attempts.borrow(), 2);
-
- let event = Event::PaymentPathFailed {
- payment_id,
- payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
- network_update: None,
- rejected_by_dest: false,
- all_paths_failed: false,
- path: TestRouter::path_for_value(final_value_msat / 2),
- short_channel_id: None,
- retry: Some(RouteParameters {
- final_value_msat: final_value_msat / 2, ..TestRouter::retry_for_invoice(&invoice)
- }),
- };
- invoice_payer.handle_event(&event);
- assert_eq!(*event_handled.borrow(), false);
- assert_eq!(*payer.attempts.borrow(), 3);
-
- invoice_payer.handle_event(&event);
- assert_eq!(*event_handled.borrow(), true);
- assert_eq!(*payer.attempts.borrow(), 3);
- }
-
- #[test]
- fn fails_paying_invoice_with_missing_retry_params() {
- let event_handled = core::cell::RefCell::new(false);
- let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
-
- let payer = TestPayer::new();
- let router = TestRouter {};
- let scorer = RefCell::new(TestScorer::new());
- let logger = TestLogger::new();
- let invoice_payer =
- InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
-
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
- let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
- assert_eq!(*payer.attempts.borrow(), 1);
-
- let event = Event::PaymentPathFailed {
- payment_id,
- payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
- network_update: None,
- rejected_by_dest: false,
- all_paths_failed: false,
- path: vec![],
- short_channel_id: None,
- retry: None,
- };
- invoice_payer.handle_event(&event);
- assert_eq!(*event_handled.borrow(), true);
- assert_eq!(*payer.attempts.borrow(), 1);
- }
-
- #[test]
- fn fails_paying_invoice_after_expiration() {
- let event_handled = core::cell::RefCell::new(false);
- let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
-
- let payer = TestPayer::new();
- let router = TestRouter {};
- let scorer = RefCell::new(TestScorer::new());
- let logger = TestLogger::new();
- let invoice_payer =
- InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
-
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = expired_invoice(payment_preimage);
- if let PaymentError::Invoice(msg) = invoice_payer.pay_invoice(&invoice).unwrap_err() {
- assert_eq!(msg, "Invoice expired prior to send");
- } else { panic!("Expected Invoice Error"); }
- }
-
- #[test]
- fn fails_retrying_invoice_after_expiration() {
- let event_handled = core::cell::RefCell::new(false);
- let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
-
- let payer = TestPayer::new();
- let router = TestRouter {};
- let scorer = RefCell::new(TestScorer::new());
- let logger = TestLogger::new();
- let invoice_payer =
- InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
-
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
- let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
- assert_eq!(*payer.attempts.borrow(), 1);
-
- let mut retry_data = TestRouter::retry_for_invoice(&invoice);
- retry_data.payee.expiry_time = Some(SystemTime::now()
- .checked_sub(Duration::from_secs(2)).unwrap()
- .duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs());
- let event = Event::PaymentPathFailed {
- payment_id,
- payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
- network_update: None,
- rejected_by_dest: false,
- all_paths_failed: false,
- path: vec![],
- short_channel_id: None,
- retry: Some(retry_data),
- };
- invoice_payer.handle_event(&event);
- assert_eq!(*event_handled.borrow(), true);
- assert_eq!(*payer.attempts.borrow(), 1);
- }
-
- #[test]
- fn fails_paying_invoice_after_retry_error() {
- let event_handled = core::cell::RefCell::new(false);
- let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
-
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
- let final_value_msat = invoice.amount_milli_satoshis().unwrap();
-
- let payer = TestPayer::new()
- .fails_on_attempt(2)
- .expect_value_msat(final_value_msat);
- let router = TestRouter {};
- let scorer = RefCell::new(TestScorer::new());
- let logger = TestLogger::new();
- let invoice_payer =
- InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
-
- let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
- assert_eq!(*payer.attempts.borrow(), 1);
-
- let event = Event::PaymentPathFailed {
- payment_id,
- payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
- network_update: None,
- rejected_by_dest: false,
- all_paths_failed: false,
- path: TestRouter::path_for_value(final_value_msat / 2),
- short_channel_id: None,
- retry: Some(TestRouter::retry_for_invoice(&invoice)),
- };
- invoice_payer.handle_event(&event);
- assert_eq!(*event_handled.borrow(), true);
- assert_eq!(*payer.attempts.borrow(), 2);
- }
-
- #[test]
- fn fails_paying_invoice_after_rejected_by_payee() {
- let event_handled = core::cell::RefCell::new(false);
- let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
-
- let payer = TestPayer::new();
- let router = TestRouter {};
- let scorer = RefCell::new(TestScorer::new());
- let logger = TestLogger::new();
- let invoice_payer =
- InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(2));
-
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
- let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
- assert_eq!(*payer.attempts.borrow(), 1);
-
- let event = Event::PaymentPathFailed {
- payment_id,
- payment_hash: PaymentHash(invoice.payment_hash().clone().into_inner()),
- network_update: None,
- rejected_by_dest: true,
- all_paths_failed: false,
- path: vec![],
- short_channel_id: None,
- retry: Some(TestRouter::retry_for_invoice(&invoice)),
- };
- invoice_payer.handle_event(&event);
- assert_eq!(*event_handled.borrow(), true);
- assert_eq!(*payer.attempts.borrow(), 1);
- }
-
- #[test]
- fn fails_repaying_invoice_with_pending_payment() {
- let event_handled = core::cell::RefCell::new(false);
- let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
-
- let payer = TestPayer::new();
- let router = TestRouter {};
- let scorer = RefCell::new(TestScorer::new());
- let logger = TestLogger::new();
- let invoice_payer =
- InvoicePayer::new(&payer, router, &scorer, &logger, event_handler, RetryAttempts(0));
-
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
- let payment_id = Some(invoice_payer.pay_invoice(&invoice).unwrap());
-
- // Cannot repay an invoice pending payment.
- match invoice_payer.pay_invoice(&invoice) {
- Err(PaymentError::Invoice("payment pending")) => {},
- Err(_) => panic!("unexpected error"),
- Ok(_) => panic!("expected invoice error"),
- }
-
- // Can repay an invoice once cleared from cache.
- let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
- invoice_payer.remove_cached_payment(&payment_hash);
- assert!(invoice_payer.pay_invoice(&invoice).is_ok());
-
- // Cannot retry paying an invoice if cleared from cache.
- invoice_payer.remove_cached_payment(&payment_hash);
- let event = Event::PaymentPathFailed {
- payment_id,
- payment_hash,
- network_update: None,
- rejected_by_dest: false,
- all_paths_failed: false,
- path: vec![],
- short_channel_id: None,
- retry: Some(TestRouter::retry_for_invoice(&invoice)),
- };
- invoice_payer.handle_event(&event);
- assert_eq!(*event_handled.borrow(), true);
- }
-
- #[test]
- fn fails_paying_invoice_with_routing_errors() {
- let payer = TestPayer::new();
- let router = FailingRouter {};
- let scorer = RefCell::new(TestScorer::new());
- let logger = TestLogger::new();
- let invoice_payer =
- InvoicePayer::new(&payer, router, &scorer, &logger, |_: &_| {}, RetryAttempts(0));
-
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
- match invoice_payer.pay_invoice(&invoice) {
- Err(PaymentError::Routing(_)) => {},
- Err(_) => panic!("unexpected error"),
- Ok(_) => panic!("expected routing error"),
- }
- }
-
- #[test]
- fn fails_paying_invoice_with_sending_errors() {
- let payer = TestPayer::new().fails_on_attempt(1);
- let router = TestRouter {};
- let scorer = RefCell::new(TestScorer::new());
- let logger = TestLogger::new();
- let invoice_payer =
- InvoicePayer::new(&payer, router, &scorer, &logger, |_: &_| {}, RetryAttempts(0));
-
- let payment_preimage = PaymentPreimage([1; 32]);
- let invoice = invoice(payment_preimage);
- match invoice_payer.pay_invoice(&invoice) {
- Err(PaymentError::Sending(_)) => {},
- Err(_) => panic!("unexpected error"),
- Ok(_) => panic!("expected sending error"),
- }
- }
-
- #[test]
- fn pays_zero_value_invoice_using_amount() {
- let event_handled = core::cell::RefCell::new(false);
- let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
-