public async Task Unit_CreateNewPayment_ExpectPaymentInResult()
        {
            Account newAccount = new Account {
                Name = "Test Account"
            };

            _context.Accounts.Add(newAccount);
            _context.SaveChanges();

            Transaction deposit = new Transaction {
                AccountId = newAccount.Id, Amount = 1000000, Date = new DateTime(2020, 1, 1), TransactionStatus = TransactionStatusEnum.Processed, TransactionType = TransactionTypeEnum.Deposit, CreationDate = new DateTime(2020, 1, 1), LastUpdateDate = new DateTime(2020, 1, 1)
            };

            _context.Transactions.Add(deposit);
            _context.SaveChanges();

            TransactionCreatorService creator = new TransactionCreatorService(_mockPaymentLogger.Object, _mapper, newAccount.Id, 10000, new DateTime(2020, 1, 1), _accountRepo, _transRepo, TransactionStatusEnum.Pending, TransactionTypeEnum.Withdrawal, Messages.Payment_FailedToCreate);
            ServiceResult             result  = await creator.CreateTransaction();

            result.Should().NotBeNull();
            result.StatusCode.Should().Be(StatusCodes.Status201Created);
            TransactionResultDto transaction = JsonConvert.DeserializeObject <TransactionResultDto>(result.ContentResult);

            transaction.Should().NotBeNull();
            transaction.AccountId.Should().Be(newAccount.Id);
            transaction.Amount.Should().Be(10000);
            transaction.Date.Should().Be(new DateTime(2020, 1, 1));
            transaction.TransactionStatus.Should().Be(TransactionStatusEnum.Pending.ToString());
        }
        public async Task Integration_CreateNewPayment_ExpectPaymentInResultAndRepository()
        {
            Account newAccount = new Account {
                Name = "Test Account"
            };

            _context.Accounts.Add(newAccount);
            _context.SaveChanges();
            // 10 Deposits of 1000
            for (int i = 0; i < 10; i++)
            {
                _context.Transactions.Add(new Transaction
                {
                    AccountId         = newAccount.Id,
                    Amount            = 1000,
                    TransactionStatus = TransactionStatusEnum.Processed,
                    TransactionType   = TransactionTypeEnum.Deposit,
                    Date           = new DateTime(2020, 1, 1),
                    CreationDate   = new DateTime(2020, 1, 1),
                    LastUpdateDate = new DateTime(2020, 1, 1)
                });
            }
            _context.SaveChanges();

            TransactionInsertDto payment = new TransactionInsertDto
            {
                AccountId = newAccount.Id,
                Amount    = 1000,
                Date      = new DateTime(2020, 1, 1)
            };

            var content       = JsonConvert.SerializeObject(payment);
            var stringContent = new StringContent(content, Encoding.UTF8, "application/json");
            var response      = await _client.PostAsync("/api/payment/create", stringContent);

            response.StatusCode.Should().Be(System.Net.HttpStatusCode.Created);
            var responseString = await response.Content.ReadAsStringAsync();

            TransactionResultDto PaymentResult = JsonConvert.DeserializeObject <TransactionResultDto>(responseString);

            PaymentResult.Should().NotBeNull();
            PaymentResult.AccountId.Should().Be(newAccount.Id);
            PaymentResult.Amount.Should().Be(payment.Amount);
            PaymentResult.Date.Should().Be((DateTime)payment.Date);
            PaymentResult.ClosedReason.Should().BeNull();
            PaymentResult.TransactionStatus.Should().Be(TransactionStatusEnum.Pending.ToString());

            Transaction PaymentFromDb = _context.Transactions.Find(PaymentResult.Id);

            PaymentFromDb.Should().NotBeNull();
            PaymentFromDb.Amount.Should().Be(payment.Amount);
            PaymentFromDb.Date.Should().Be((DateTime)payment.Date);
            PaymentFromDb.Id.Should().Be(PaymentResult.Id);
            PaymentFromDb.TransactionStatus.Should().Be(TransactionStatusEnum.Pending);
            PaymentFromDb.TransactionType.Should().Be(TransactionTypeEnum.Withdrawal);
        }
        public async Task Integration_CreateNewPayment_NoBalance_ExpectCreated_ButTransactionCreatedAndClosed()
        {
            Account newAccount = new Account {
                Name = "Test Account"
            };

            _context.Accounts.Add(newAccount);
            _context.SaveChanges();
            TransactionInsertDto payment = new TransactionInsertDto {
                AccountId = newAccount.Id, Date = new DateTime(2020, 1, 1), Amount = 1000
            };
            var content       = JsonConvert.SerializeObject(payment);
            var stringContent = new StringContent(content, Encoding.UTF8, "application/json");
            var response      = await _client.PostAsync("/api/payment/create", stringContent);

            response.StatusCode.Should().Be(System.Net.HttpStatusCode.Created);
            var responseString = await response.Content.ReadAsStringAsync();

            TransactionResultDto PaymentResult = JsonConvert.DeserializeObject <TransactionResultDto>(responseString);

            PaymentResult.Should().NotBeNull();
            PaymentResult.AccountId.Should().Be(newAccount.Id);
            PaymentResult.Amount.Should().Be(payment.Amount);
            PaymentResult.Date.Should().Be((DateTime)payment.Date);
            PaymentResult.ClosedReason.Should().Be(Messages.Payment_NotEnoughFundsReason);
            PaymentResult.TransactionStatus.Should().Be(TransactionStatusEnum.Closed.ToString());

            Transaction PaymentFromDb = _context.Transactions.Find(PaymentResult.Id);

            PaymentFromDb.Should().NotBeNull();
            PaymentFromDb.Amount.Should().Be(payment.Amount);
            PaymentFromDb.Date.Should().Be((DateTime)payment.Date);
            PaymentFromDb.Id.Should().Be(PaymentResult.Id);
            PaymentFromDb.TransactionStatus.Should().Be(TransactionStatusEnum.Closed);
            PaymentFromDb.TransactionType.Should().Be(TransactionTypeEnum.Withdrawal);
            PaymentFromDb.ClosedReason.Should().Be(Messages.Payment_NotEnoughFundsReason);
        }
        public async Task Integration_CreateNewDeposit_ExpectAccountInResultAndRepository()
        {
            Account newAccount = new Account {
                Name = "Test Account"
            };

            _context.Accounts.Add(newAccount);
            _context.SaveChanges();

            TransactionInsertDto deposit = new TransactionInsertDto
            {
                AccountId = newAccount.Id,
                Amount    = 1000,
                Date      = new DateTime(2020, 1, 1)
            };

            var content       = JsonConvert.SerializeObject(deposit);
            var stringContent = new StringContent(content, Encoding.UTF8, "application/json");
            var response      = await _client.PostAsync("/api/deposit/create", stringContent);

            response.StatusCode.Should().Be(System.Net.HttpStatusCode.Created);
            var responseString = await response.Content.ReadAsStringAsync();

            TransactionResultDto depositResult = JsonConvert.DeserializeObject <TransactionResultDto>(responseString);

            depositResult.Should().NotBeNull();
            depositResult.AccountId.Should().Be(newAccount.Id);
            Transaction depositFromDb = _context.Transactions.Find(depositResult.Id);

            depositFromDb.Should().NotBeNull();
            depositFromDb.Amount.Should().Be(deposit.Amount);
            depositFromDb.Date.Should().Be((DateTime)deposit.Date);
            depositFromDb.Id.Should().Be(depositResult.Id);
            depositFromDb.TransactionStatus.Should().Be(TransactionStatusEnum.Processed);
            depositFromDb.TransactionType.Should().Be(TransactionTypeEnum.Deposit);
        }