public async Task Then_a_payment_is_created()
        {
            //Arrange
            var command = new CreatePaymentCommand(_incentive.Id, _incentive.PendingPayments.First().Id,
                                                   _firstCollectionPeriod.AcademicYear, _firstCollectionPeriod.PeriodNumber);

            _mockIncentiveDomainRespository.Setup(x => x.Find(command.ApprenticeshipIncentiveId)).ReturnsAsync(_incentive);

            // Act
            await _sut.Handle(command);

            // Assert
            _incentive.Payments.Count.Should().Be(1);
        }
        public async Task ShouldSavePaymentToDatabaseEvenIfBankAcquirerDoesNotSucceed()
        {
            var acquiringBankResult = Result.Failure <Guid>(FakeAcquiringBankErrors.AmountMustBeLessThan10000);

            _mockAcquiringBankService.Setup(a => a.ProcessPayment(It.IsAny <Payment>())).ReturnsAsync(acquiringBankResult);

            var sut = new CreatePaymentCommandHandler(_mockAcquiringBankService.Object,
                                                      _mockPaymentHistoryRepository.Object, _mockMetrics.Object, _mockLogger.Object,
                                                      _mockEventStoreClient.Object);

            var command = new CreatePaymentCommand()
            {
                Amount      = 44044.44M,
                Currency    = Currency.GBP.ToString(),
                CardNumber  = "1234-5678-8765-4321",
                CVV         = 321,
                ExpiryMonth = 10,
                ExpiryYear  = 20,
                FirstName   = "Jim",
                Surname     = "Jimson"
            };

            var result = await sut.Handle(command, default);

            _mockAcquiringBankService.Verify(a => a.ProcessPayment(It.IsAny <Payment>()), Times.Once());
            _mockPaymentHistoryRepository.Verify(p => p.InsertPayment(It.IsAny <Payment>()), Times.Once());
            Assert.False(result.IsSuccess);
        }
        public async Task ShouldSendPaymentToAcquiringBankAndSaveInDB()
        {
            var acquiringBankResult = Result.Ok(Guid.NewGuid());

            _mockAcquiringBankService.Setup(a => a.ProcessPayment(It.IsAny <Payment>())).ReturnsAsync(acquiringBankResult);
            _mockPaymentHistoryRepository.Setup(p => p.InsertPayment(It.IsAny <Payment>())).ReturnsAsync(Result.Ok(Guid.NewGuid()));

            var sut = new CreatePaymentCommandHandler(_mockAcquiringBankService.Object,
                                                      _mockPaymentHistoryRepository.Object, _mockMetrics.Object,
                                                      _mockLogger.Object, _mockEventStoreClient.Object);

            var command = new CreatePaymentCommand()
            {
                Amount      = 4404.44M,
                Currency    = Currency.GBP.ToString(),
                CardNumber  = "1234-5678-8765-4321",
                CVV         = 321,
                ExpiryMonth = 10,
                ExpiryYear  = 20,
                FirstName   = "Jim",
                Surname     = "Jimson"
            };

            var result = await sut.Handle(command, default);

            _mockAcquiringBankService.Verify(a => a.ProcessPayment(It.IsAny <Payment>()), Times.Once());
            _mockPaymentHistoryRepository.Verify(p => p.InsertPayment(It.IsAny <Payment>()), Times.Once());
            Assert.True(result.IsSuccess);
        }
Exemplo n.º 4
0
        public void Handle_GivenMoreThanBalanceAmount_ShouldCreateClosedPayment()
        {
            var sut     = new CreatePaymentCommandHandler(_context, _mediator.Object, CurrentUser);
            var request = new CreatePaymentCommand
            {
                Amount = 100000,
                Date   = DateTime.Now
            };

            var result = sut.Handle(request, CancellationToken.None).Result;

            Assert.AreNotEqual(Guid.Empty, result);
            var record = _context.Payments.SingleOrDefault(i => i.Id == result);

            Assert.IsNotNull(record);
            Assert.AreEqual(PaymentStatus.Closed, record.Status);
        }
Exemplo n.º 5
0
        public async Task Handle_ShouldPersistPayment()
        {
            var command = new CreatePaymentCommand
            {
                Name = "Do yet another thing."
            };

            var sut = new CreatePaymentCommandHandler(_repository);

            var result = await sut.Handle(command, CancellationToken.None);

            var entity = await _repository.GetByIdAsync(result);

            entity.Should().NotBeNull();
            entity.Name.Should().Be(command.Name);
            entity.IsComplete.Should().BeFalse();
        }