public async Task CreateTransactionsRight_Tests(decimal amount, string type)
{
var command = new CreateTransactionCommand()
{
AccountId = 1, Amount = amount, Type = type
};
var options = new DbContextOptionsBuilder <BankAppDataContext>()
.UseInMemoryDatabase(databaseName: "CreateTransactionsRight_Tests")
.Options;
using (var context = new BankAppDataContext(options))
{
await context.AddAsync(new Account()
{
AccountId = 1, Balance = 1000
});
await context.SaveChangesAsync(CancellationToken.None);
var handler = new CreateTransactionCommandHandler(context);
var result = await handler.Handle(command, CancellationToken.None);
decimal expected = 1100;
var account = await context.Accounts.SingleOrDefaultAsync(a => a.AccountId == 1);
var transactions = await context.Accounts.Include(a => a.Transactions).SingleOrDefaultAsync(a => a.AccountId == 1);
var count = transactions.Transactions.Count();
var actual = account.Balance;
Assert.Equal(expected, actual);
Assert.Equal(1, count);
}
}
public async void Should_Return_Unprocessable_If_No_Rows_Affected()
{
// ARRANGE
var validator = new CreateTransactionCommandValidator();
var transactionRepositoryMock = new Mock <ITransactionRepository>();
var loggerMock = new Mock <ILogger>();
var handler = new CreateTransactionCommandHandler(
transactionRepositoryMock.Object,
loggerMock.Object,
validator
);
transactionRepositoryMock.Setup(x => x.InsertTransaction(It.IsAny <Domain.Models.Transactions.Transaction>())).ReturnsAsync(0);
// ACT
var response = await handler.Handle(new CreateTransactionCommand()
{
Transaction = new Domain.Models.Transactions.Transaction()
{
TransactionId = "1"
}
}, new CancellationToken());
// ASSERT
Assert.Equal(CommandResultTypeEnum.UnprocessableEntity, response.Type);
transactionRepositoryMock.Verify(x => x.InsertTransaction(It.IsAny <Domain.Models.Transactions.Transaction>()), Times.Once);
}
public CreateTransactionCommandHandlerTests()
{
eventBusMock = new Mock <IEventBus>();
transactionRepositoryMock = new Mock <ITransactionWriteOnlyRepository>();
transactionRepositoryMock.Setup(x => x.Add(It.IsAny <Transaction>()))
.ReturnsAsync(true);
sut = new CreateTransactionCommandHandler(eventBusMock.Object, transactionRepositoryMock.Object);
}
public CreateTransactionCommandHandlerTests()
{
if (_mapper == null)
{
var mappingConfig = new MapperConfiguration(mc =>
{
mc.AddProfile(new MappingProfile());
});
var mapper = mappingConfig.CreateMapper();
_mapper = mapper;
}
_mockAccountRepository = new Mock <IAccountRepository>();
_mockTransactionRepository = new Mock <ITransactionRepository>();
_mockCurrencyConvertService = new Mock <ICurrencyConvertService>();
_createTransactionCommandHandler = new CreateTransactionCommandHandler(_mockAccountRepository.Object,
_mockTransactionRepository.Object, _mapper, _mockCurrencyConvertService.Object);
}
public async void Request_With_No_Id_Should_Return_Invalid_Input()
{
// ARRANGE
var validator = new CreateTransactionCommandValidator();
var transactionRepositoryMock = new Mock <ITransactionRepository>();
var loggerMock = new Mock <ILogger>();
var handler = new CreateTransactionCommandHandler(
transactionRepositoryMock.Object,
loggerMock.Object,
validator
);
// ACT
var response = await handler.Handle(new CreateTransactionCommand()
{
Transaction = new Domain.Models.Transactions.Transaction()
}, new CancellationToken());
// ASSERT
Assert.Equal(CommandResultTypeEnum.InvalidInput, response.Type);
}
public async Task CreateTransaction_Tests(decimal amount, string type)
{
var command = new CreateTransactionCommand()
{
AccountId = 1, Amount = amount, Type = type
};
var options = new DbContextOptionsBuilder <BankAppDataContext>()
.UseInMemoryDatabase(databaseName: "CreateTransaction_Tests")
.Options;
using (var context = new BankAppDataContext(options))
{
context.Accounts.Add(new Account()
{
AccountId = 1, Balance = 1000
});
var handler = new CreateTransactionCommandHandler(context);
var result = await handler.Handle(command, CancellationToken.None);
Assert.False(result.Success);
}
}
