public async Task Create_WithdrawExistingAccount_ShouldReturnTransactions()
{
var request = new WithdrawCreateRequest
{
AccountId = 1,
Ammount = 100,
CustomerId = 2,
Details = "Test",
};
var transferTransactions = WithdrawTransactions(request);
_mockMediator
.Setup(m => m.Send(It.Is <WithdrawCreateRequest>(t => t.AccountId == request.AccountId &&
t.Ammount == request.Ammount &&
t.CustomerId == request.CustomerId &&
t.Details == request.Details), default))
.ReturnsAsync(transferTransactions)
.Verifiable();
var controller = new WithdrawController(_mockMediator.Object);
var result = await controller.Create(request);
_mockMediator.Verify();
Assert.True(typeof(CreatedAtActionResult) == result.Result.GetType());
}
public async Task Create_WithdrawNonExistingAccount_ShouldReturnNotFound()
{
var request = new WithdrawCreateRequest
{
AccountId = 1,
Ammount = 100,
CustomerId = 2,
Details = "Test",
};
_mockMediator
.Setup(m => m.Send(It.Is <WithdrawCreateRequest>(t => t.AccountId == request.AccountId &&
t.Ammount == request.Ammount &&
t.CustomerId == request.CustomerId &&
t.Details == request.Details), default))
.ThrowsAsync(new NotFoundException())
.Verifiable();
var controller = new WithdrawController(_mockMediator.Object);
var result = await controller.Create(request);
_mockMediator.Verify();
Assert.True(typeof(NotFoundObjectResult) == result.Result.GetType());
}
private static void ValidateWithdrawal(WithdrawCreateRequest request, AccountModel account, TransactionType transactionType)
{
var ammountToWithdraw = request.Ammount + transactionType.FixedCharge.Value;
var balanceAfterWithdrawal = account.Balance - ammountToWithdraw;
if (balanceAfterWithdrawal < 0)
{
throw new BusinessException("Your account cannot have a negative balance.");
}
}
public async Task <IEnumerable <TransactionModel> > Handle(WithdrawCreateRequest request, CancellationToken cancellationToken)
{
var withdrawTransactionType = _repository.TransactionTypeRepository.FindSingle(tt => tt.Code == "W");
AccountModel account = await GetAccount(request, cancellationToken);
ValidateWithdrawal(request, account, withdrawTransactionType);
IEnumerable <TransactionModel> withdrawTransaction = await CreateWithdrawalTransaction(request, account, withdrawTransactionType);
return(withdrawTransaction);
}
public async Task <ActionResult <IEnumerable <TransactionModel> > > Create([FromBody, Required] WithdrawCreateRequest request)
{
try
{
var result = await _mediator.Send(request);
return(CreatedAtAction(nameof(Create), result));
}
catch (BusinessException businessException)
{
return(Conflict(new { message = businessException.Message }));
}
catch (NotFoundException notFoundException)
{
return(NotFound(new { message = notFoundException.Message }));
}
}
public async Task Handle_CreateWithdrawNegativeBalance_ShouldReturnBusinessException()
{
var handler = new WithdrawCreateHandler(_mockMediator.Object, _mockRepo.Object);
var request = new WithdrawCreateRequest {
AccountId = 1, CustomerId = 1, Ammount = 200
};
var account = GetTestAccount();
_mockMediator
.Setup(m => m.Send(It.Is <AccountGetRequest>(a => a.AccountId == account.Id), default))
.Returns(Task.FromResult(account))
.Verifiable();
MockWithdrawTransactionType();
await Assert.ThrowsAsync <BusinessException>(() => handler.Handle(request, default));
_mockMediator.Verify();
}
public async Task Handle_CreateWithdrawl_ShouldReturnTransaction()
{
var handler = new WithdrawCreateHandler(_mockMediator.Object, _mockRepo.Object);
var request = new WithdrawCreateRequest {
AccountId = 1, CustomerId = 1, Ammount = 10
};
var account = GetTestAccount();
var withdrawalType = GetWithdrawType();
var withdrawTransactions = handler.BuildWithdrawalTransactions(request, account, withdrawalType);
MockWithdrawTransactionType();
MockMediator(withdrawTransactions, account);
var result = await handler.Handle(request, default);
_mockMediator.Verify();
Assert.IsAssignableFrom <IEnumerable <TransactionModel> >(result);
Assert.Equal(2, result.Count());
}
public List <TransactionModel> BuildWithdrawalTransactions(WithdrawCreateRequest request, AccountModel account, TransactionType withdrawalTransactionType)
{
var withdrawalTransaction = new TransactionModel
{
AccountId = account.Id,
Ammount = -request.Ammount,
Details = request.Details,
TransactionTypeId = withdrawalTransactionType.Id
};
var withdrawalSurcharge = new TransactionModel
{
AccountId = account.Id,
Ammount = -withdrawalTransactionType.FixedCharge.Value,
Details = $"Bank withdrawal surcharge of ${withdrawalTransactionType.FixedCharge.Value}",
TransactionTypeId = withdrawalTransactionType.Id
};
return(new List <TransactionModel> {
withdrawalTransaction, withdrawalSurcharge
});
}
private List <TransactionModel> WithdrawTransactions(WithdrawCreateRequest request)
{
return(new List <TransactionModel>
{
new TransactionModel
{
AccountId = request.AccountId.Value,
Ammount = -request.Ammount,
Date = DateTime.Now,
Details = request.Details,
OperationId = 1,
TransactionTypeId = 2
},
new TransactionModel
{
AccountId = request.AccountId.Value,
Ammount = -4,
Date = DateTime.Now,
Details = request.Details,
OperationId = 1,
TransactionTypeId = 2
},
});
}
private async Task <IEnumerable <TransactionModel> > CreateWithdrawalTransaction(WithdrawCreateRequest request, AccountModel account, TransactionType withdrawalTransactionType)
{
List <TransactionModel> transactionsToCreate = BuildWithdrawalTransactions(request, account, withdrawalTransactionType);
var transactions = await _mediator.Send(new TransactionCreateRequest
{
Transactions = transactionsToCreate,
OperationDetails = $"Withdrawal: ammount ${request.Ammount} "
});
return(transactions);
}
private async Task <AccountModel> GetAccount(WithdrawCreateRequest request, CancellationToken cancellationToken)
{
return(await _mediator.Send(new AccountGetRequest { AccountId = request.AccountId.Value, CustomerId = request.CustomerId }, cancellationToken));
}
