public async Task AddAccountUnitTests(
AddAccountRequest request,
Type exceptionType)
{
var userDbHandler = new Mock <IUserDbHandler>();
var accountDbHandler = new Mock <IAccountDbHandler>();
userDbHandler.Setup(h => h.GetUsersAsync()).ReturnsAsync(
new List <User>()
{
new User()
{
Id = 1, Name = "N1", Email = "[email protected]", Salary = 2000, Expenses = 100
},
new User()
{
Id = 2, Name = "M1", Email = "[email protected]", Salary = 5000, Expenses = 4500
}
});
var accountService = new AccountService(accountDbHandler.Object, userDbHandler.Object);
if (exceptionType == null)
{
await accountService.AddAccountAsync(request);
accountDbHandler.Verify(a => a.AddAccountAsync(It.IsAny <Account>()), Times.Once);
}
else
{
await Assert.ThrowsAsync(exceptionType, () => accountService.AddAccountAsync(request));
accountDbHandler.Verify(a => a.AddAccountAsync(It.IsAny <Account>()), Times.Never);
}
}
public async Task Create_User()
{
var testUsername = "******";
var testPassword = "******";
var hashedPassword = "******";
var mockHasher = new Mock <IHashing>();
var mockBarService = new Mock <IBarService>().Object;
var mockCocktailService = new Mock <ICocktailService>().Object;
var options = TestUtilities.GetOptions(nameof(Create_User));
mockHasher.Setup(m => m.Hash(testPassword))
.Returns(hashedPassword);
using (var actContext = new CocktailDatabaseContext(options))
{
var sut = new AccountService(actContext, mockHasher.Object, mockBarService, mockCocktailService);
await sut.AddAccountAsync(testUsername, "se taq", "se taq", testPassword, "se taq", "se taq", "se taq");
}
using (var assertContext = new CocktailDatabaseContext(options))
{
Assert.AreEqual(1, assertContext.Users.Count());
var user = await assertContext.Users.FirstOrDefaultAsync(u => u.UserName == testUsername);
Assert.IsNotNull(user);
Assert.AreEqual(hashedPassword, user.Password);
}
}
public async Task ThrowArgumentException_UserExists()
{
var testUsername = "******";
var testPassword = "******";
var hashedPassword = "******";
var mockHasher = new Mock <IHashing>();
var mockBarService = new Mock <IBarService>().Object;
var mockCocktailService = new Mock <ICocktailService>().Object;
var options = TestUtilities.GetOptions(nameof(ThrowArgumentException_UserExists));
mockHasher.Setup(m => m.Hash(testPassword))
.Returns(hashedPassword);
using (var actContext = new CocktailDatabaseContext(options))
{
var sut = new AccountService(actContext, mockHasher.Object, mockBarService, mockCocktailService);
await sut.AddAccountAsync(testUsername, "se taq", "se taq", testPassword, "se taq", "se taq", "se taq");
}
using (var assertContext = new CocktailDatabaseContext(options))
{
var sut = new AccountService(assertContext, mockHasher.Object, mockBarService, mockCocktailService);
await sut.AddAccountAsync(testUsername, "se taq", "se taq", testPassword, "se taq", "se taq", "se taq");
}
}
public async Task AccountService_AddAccountAsync_ArgumentNullException()
{
// Arrange
CreateAccount createAccountCommand = null;
AccountService accountService = new AccountService(DbContext);
// Act and assert
await Assert.ThrowsAsync <ArgumentNullException>(() => accountService.AddAccountAsync(createAccountCommand));
}
public async Task <IActionResult> CreateAccount(AccountCreateVM viewModel)
{
if (!ModelState.IsValid)
{
return(View(nameof(Login)));
}
await accountService.AddAccountAsync(viewModel);
return(RedirectToAction(nameof(Login)));
}
public async Task ThrowArgumentException_ShortPassword()
{
//arrange
string testPassword = "******";
var mockHasher = new Mock <IHashing>().Object;
var mockBarService = new Mock <IBarService>().Object;
var mockCocktailService = new Mock <ICocktailService>().Object;
var options = TestUtilities.GetOptions(nameof(ThrowArgumentException_ShortPassword));
using (var assertContext = new CocktailDatabaseContext(options))
{
var sut = new AccountService(assertContext, mockHasher, mockBarService, mockCocktailService);
await sut.AddAccountAsync("se taq", "se taq", "se taq", testPassword, "se taq", "se taq", "se taq");
}
}
public async Task AccountService_AddAccountAsync_SpecificAccount(CreateAccount command, string expectedLogin)
{
// Arrange
PrepareDbContextWithOneAvatar();
int accountsCountBefore = DbContext.Accounts.Count();
AccountService accountService = new AccountService(DbContext);
// Act
await accountService.AddAccountAsync(command);
var accountsCountAfter = DbContext.Accounts.Count();
var account = DbContext.Accounts.SingleOrDefault(x => x.Login == expectedLogin);
// Assert
Assert.NotNull(account);
Assert.Equal(accountsCountBefore + 1, accountsCountAfter);
Assert.Equal(expectedLogin, account.Login);
}
public async Task Add_Correct_Account()
{
var options = DatabaseOrganisation.GetOptions(nameof(Add_Correct_Account));
using (var arrangeContext = new ApplicationDbContext(options))
{
arrangeContext.Clients.Add(TestUtils.clientNoAccount);
arrangeContext.Currencies.Add(TestUtils.currencyEUR);
await arrangeContext.SaveChangesAsync();
var accountOneDTO = new AccountDTO();
var accountDTOMapperMock = new Mock <IDtoMapper <Account, AccountDTO> >();
var configMock = new Mock <IConfiguration>();
var sut = new AccountService(arrangeContext, accountDTOMapperMock.Object, null, null, null, configMock.Object);
accountDTOMapperMock.Setup(x => x.MapFrom(It.IsAny <Account>())).Returns(accountOneDTO);
configMock.Setup(m => m.GetSection("GlobalConstants:Balance").Value).Returns("10000");
var account = await sut.AddAccountAsync(TestUtils.clientNoAccount.Id, TestUtils.currencyEUR.Id);
Assert.IsInstanceOfType(account, typeof(AccountDTO));
Assert.AreEqual(arrangeContext.Accounts.Count(), 1);
}
//using (var assertContext = new ApplicationDbContext(options))
//{
// var accountOneDTO = TestUtils.accountDTO1;
// var accountDTOMapperMock = new Mock<IDtoMapper<Account, AccountDTO>>();
// accountDTOMapperMock.Setup(x => x.MapFrom(It.IsAny<Account>())).Returns(accountOneDTO);
// var sut = new AccountService(assertContext, accountDTOMapperMock.Object, null, null, null);
// var account = await sut.AddAccountAsync(TestUtils.clientNoAccount.Id, TestUtils.currencyEUR.Id);
// Assert.IsInstanceOfType(account, typeof(AccountDTO));
// Assert.AreEqual(assertContext.Accounts.Count(), 1);
//}
}