btcpayserver/BTCPayServer.Tests/PaymentRequestTests.cs

using System;
using System.Linq;
using System.Threading.Tasks;
using BTCPayServer.Controllers;
using BTCPayServer.Data;
using BTCPayServer.Models.PaymentRequestViewModels;
using BTCPayServer.Services.Invoices;
using BTCPayServer.Services.PaymentRequests;
using Microsoft.AspNetCore.Mvc;
using NBitpayClient;
using Xunit;
using Xunit.Abstractions;

namespace BTCPayServer.Tests
{
    [Collection(nameof(NonParallelizableCollectionDefinition))]
    public class PaymentRequestTests : UnitTestBase
    {
        public PaymentRequestTests(ITestOutputHelper helper) : base(helper)
        {
        }

        [Fact]
        [Trait("Integration", "Integration")]
        public async Task CanCreateViewUpdateAndDeletePaymentRequest()
        {
            using (var tester = CreateServerTester())
            {
                await tester.StartAsync();
                var user = tester.NewAccount();
                await user.GrantAccessAsync();
                user.RegisterDerivationScheme("BTC");

                var user2 = tester.NewAccount();

                await user2.GrantAccessAsync();

                var paymentRequestController = user.GetController<PaymentRequestController>();
                var guestpaymentRequestController = user2.GetController<PaymentRequestController>();

                var request = new UpdatePaymentRequestViewModel
                {
                    Title = "original juice",
                    Currency = "BTC",
                    Amount = 1,
                    StoreId = user.StoreId,
                    Description = "description"
                };
                var id = Assert
                    .IsType<RedirectToActionResult>(await paymentRequestController.EditPaymentRequest(null, request))
                    .RouteValues.Values.Last().ToString();

                paymentRequestController.HttpContext.SetPaymentRequestData(new PaymentRequestData { Id = id, StoreDataId = request.StoreId });

                // Permission guard for guests editing 
                Assert
                    .IsType<NotFoundResult>(guestpaymentRequestController.EditPaymentRequest(user.StoreId, id));

                request.Title = "update";
                Assert.IsType<RedirectToActionResult>(await paymentRequestController.EditPaymentRequest(id, request));

                Assert.Equal(request.Title,
                    Assert.IsType<ViewPaymentRequestViewModel>(Assert
                        .IsType<ViewResult>(await paymentRequestController.ViewPaymentRequest(id)).Model).Title);

                Assert.False(string.IsNullOrEmpty(id));

                Assert.IsType<ViewPaymentRequestViewModel>(Assert
                    .IsType<ViewResult>(await paymentRequestController.ViewPaymentRequest(id)).Model);

                // Archive
                Assert
                    .IsType<RedirectToActionResult>(await paymentRequestController.TogglePaymentRequestArchival(id));
                Assert.True(Assert
                    .IsType<ViewPaymentRequestViewModel>(Assert
                        .IsType<ViewResult>(await paymentRequestController.ViewPaymentRequest(id)).Model).Archived);

                Assert.Empty(Assert
                    .IsType<ListPaymentRequestsViewModel>(Assert
                        .IsType<ViewResult>(await paymentRequestController.GetPaymentRequests(user.StoreId)).Model).Items);

                // Unarchive
                Assert
                    .IsType<RedirectToActionResult>(await paymentRequestController.TogglePaymentRequestArchival(id));

                Assert.False(Assert
                    .IsType<ViewPaymentRequestViewModel>(Assert
                        .IsType<ViewResult>(await paymentRequestController.ViewPaymentRequest(id)).Model).Archived);

                Assert.Single(Assert
                    .IsType<ListPaymentRequestsViewModel>(Assert
                        .IsType<ViewResult>(await paymentRequestController.GetPaymentRequests(user.StoreId)).Model).Items);
            }
        }

        [Fact(Timeout = 60 * 2 * 1000)]
        [Trait("Integration", "Integration")]
        public async Task CanPayPaymentRequestWhenPossible()
        {
            using (var tester = CreateServerTester())
            {
                await tester.StartAsync();
                var user = tester.NewAccount();
                await user.GrantAccessAsync();
                user.RegisterDerivationScheme("BTC");

                var paymentRequestController = user.GetController<PaymentRequestController>();

                Assert.IsType<NotFoundResult>(
                    await paymentRequestController.PayPaymentRequest(Guid.NewGuid().ToString()));


                var request = new UpdatePaymentRequestViewModel()
                {
                    Title = "original juice",
                    Currency = "BTC",
                    Amount = 1,
                    StoreId = user.StoreId,
                    Description = "description"
                };
                var response = Assert
                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result)
                    .RouteValues.Last();

                var invoiceId = Assert
                    .IsType<OkObjectResult>(
                        await paymentRequestController.PayPaymentRequest(response.Value.ToString(), false)).Value
                    .ToString();

                var actionResult = Assert
                    .IsType<RedirectToActionResult>(
                        await paymentRequestController.PayPaymentRequest(response.Value.ToString()));

                Assert.Equal("Checkout", actionResult.ActionName);
                Assert.Equal("Invoice", actionResult.ControllerName);
                Assert.Contains(actionResult.RouteValues,
                    pair => pair.Key == "Id" && pair.Value.ToString() == invoiceId);

                var invoice = user.BitPay.GetInvoice(invoiceId, Facade.Merchant);
                Assert.Equal(1, invoice.Price);

                request = new UpdatePaymentRequestViewModel()
                {
                    Title = "original juice with expiry",
                    Currency = "BTC",
                    Amount = 1,
                    ExpiryDate = DateTime.Today.Subtract(TimeSpan.FromDays(2)),
                    StoreId = user.StoreId,
                    Description = "description"
                };

                response = Assert
                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result)
                    .RouteValues.Last();

                Assert
                    .IsType<BadRequestObjectResult>(
                        await paymentRequestController.PayPaymentRequest(response.Value.ToString(), false));
            }
        }

        [Fact(Timeout = 60 * 2 * 1000)]
        [Trait("Integration", "Integration")]
        public async Task CanCancelPaymentWhenPossible()
        {
            using (var tester = CreateServerTester())
            {
                await tester.StartAsync();
                var user = tester.NewAccount();
                user.GrantAccess();
                user.RegisterDerivationScheme("BTC");

                var paymentRequestController = user.GetController<PaymentRequestController>();

                Assert.IsType<NotFoundResult>(await
                    paymentRequestController.CancelUnpaidPendingInvoice(Guid.NewGuid().ToString(), false));

                var request = new UpdatePaymentRequestViewModel()
                {
                    Title = "original juice",
                    Currency = "BTC",
                    Amount = 1,
                    StoreId = user.StoreId,
                    Description = "description"
                };
                var response = Assert
                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result)
                    .RouteValues.Last();
                var invoiceId = response.Value.ToString();
                await paymentRequestController.PayPaymentRequest(invoiceId, false);
                Assert.IsType<BadRequestObjectResult>(await
                    paymentRequestController.CancelUnpaidPendingInvoice(invoiceId, false));

                request.AllowCustomPaymentAmounts = true;

                response = Assert
                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result)
                    .RouteValues.Last();

                var paymentRequestId = response.Value.ToString();

                invoiceId = Assert
                    .IsType<OkObjectResult>(await paymentRequestController.PayPaymentRequest(paymentRequestId, false))
                    .Value
                    .ToString();

                var actionResult = Assert
                    .IsType<RedirectToActionResult>(
                        await paymentRequestController.PayPaymentRequest(response.Value.ToString()));

                Assert.Equal("Checkout", actionResult.ActionName);
                Assert.Equal("Invoice", actionResult.ControllerName);
                Assert.Contains(actionResult.RouteValues,
                    pair => pair.Key == "Id" && pair.Value.ToString() == invoiceId);

                var invoice = user.BitPay.GetInvoice(invoiceId, Facade.Merchant);
                Assert.Equal(InvoiceState.ToString(InvoiceStatusLegacy.New), invoice.Status);
                Assert.IsType<OkObjectResult>(await
                    paymentRequestController.CancelUnpaidPendingInvoice(paymentRequestId, false));

                invoice = user.BitPay.GetInvoice(invoiceId, Facade.Merchant);
                Assert.Equal(InvoiceState.ToString(InvoiceStatusLegacy.Invalid), invoice.Status);

                Assert.IsType<BadRequestObjectResult>(await
                    paymentRequestController.CancelUnpaidPendingInvoice(paymentRequestId, false));

                invoiceId = Assert
                    .IsType<OkObjectResult>(await paymentRequestController.PayPaymentRequest(paymentRequestId, false))
                    .Value
                    .ToString();

                await user.BitPay.GetInvoiceAsync(invoiceId, Facade.Merchant);

                //a hack to generate invoices for the payment request is to manually create an invoice with an order id that matches:
                user.BitPay.CreateInvoice(new Invoice(1, "USD")
                {
                    OrderId = PaymentRequestRepository.GetOrderIdForPaymentRequest(paymentRequestId)
                });
                //shouldn't crash
                await paymentRequestController.ViewPaymentRequest(paymentRequestId);
                await paymentRequestController.CancelUnpaidPendingInvoice(paymentRequestId);
            }
        }
    }
}