public async Task GetTest()
{
//Arrange
var customer = new CustomerMngt.Domain.Entities.Customer
{
Id = 1,
Password = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "FirstName",
Updated = DateTime.Now,
Created = DateTime.Now
};
//Act
var mockRepository = new Mock <ICustomerRepository>();
var mockPassword = new Mock <IPasswordHasher>();
var filter = new CustomerFilter {
Id = 1
};
mockRepository.Setup(x => x.GetByFilterAsync(filter)).ReturnsAsync(customer);
var mockService = new CustomerService(mockRepository.Object, mockPassword.Object);
var result = await mockService.GetByFilterAsync(filter);
//Assert
Assert.Equal(customer.Id, result.Id);
}
public async Task IsAvailableEmailTest()
{
//Arrange
var customer = new CustomerMngt.Domain.Entities.Customer
{
Id = 1,
Password = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "First Name"
};
//Act
var mockRepository = new Mock <ICustomerRepository>();
var mockPassword = new Mock <IPasswordHasher>();
var filter = new CustomerFilter {
Email = customer.Email
};
mockRepository.Setup(x => x.GetByFilterAsync(filter)).ReturnsAsync(customer);
//Assert
var mockService = new CustomerService(mockRepository.Object, mockPassword.Object);
var existingEmail = await mockService.IsAvailableEmailAsync(customer.Email);
Assert.True(existingEmail);
}
public async Task CreateTest()
{
//Arrange
var customer = new CustomerMngt.Domain.Entities.Customer
{
Id = 1,
Password = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "First Name"
};
var customerRequestDto = new CustomerRequestDto
{
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "First Name",
Password = "******",
ConfirmPassword = "******",
};
//Act
const long id = 1;
var mockService = new Mock <ICustomerService>();
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(x => x.Map <CustomerMngt.Domain.Entities.Customer>(customerRequestDto)).Returns(customer);
mockService.Setup(x => x.CreateAsync(customer)).ReturnsAsync(id);
//Assert
var mockFacade = new CustomerFacade(mockService.Object, mockMapper.Object);
var result = await mockFacade.CreateAsync(customerRequestDto);
Assert.Equal(id, result);
}
public async Task GetListTest()
{
var connection = CreateSqLiteConnection();
connection.Open();
try
{
var options = SetDbContextOptionsBuilder(connection);
await using var context = new CustomerMngtContext(options);
Assert.True(await context.Database.EnsureCreatedAsync());
//Arrange
var customerOne = new CustomerMngt.Domain.Entities.Customer
{
Password = "******",
Email = "*****@*****.**",
Surname = "Surname1",
FirstName = "FirstName1",
Updated = DateTime.Now,
Created = DateTime.Now
};
var customerTwo = new CustomerMngt.Domain.Entities.Customer
{
Password = "******",
Email = "*****@*****.**",
Surname = "Surname2",
FirstName = "FirstName2",
Updated = DateTime.Now,
Created = DateTime.Now
};
//Act
var repository = new CustomerRepository(context);
repository.Add(customerOne);
repository.Add(customerTwo);
await repository.SaveChangesAsync();
//Assert
var filter = new CustomerFilter {
Email = "test"
};
var result = await repository.GetListByFilterAsync(filter);
Assert.Equal(2, result.Count);
}
finally
{
connection.Close();
}
}
public async Task DeleteTest()
{
var connection = CreateSqLiteConnection();
connection.Open();
try
{
var options = SetDbContextOptionsBuilder(connection);
await using var context = new CustomerMngtContext(options);
Assert.True(await context.Database.EnsureCreatedAsync());
//Arrange
var newCustomer = new CustomerMngt.Domain.Entities.Customer
{
Password = "******",
Email = "*****@*****.**",
Surname = "Surname1",
FirstName = "FirstName1",
Updated = DateTime.Now,
Created = DateTime.Now
};
//Act
var repository = new CustomerRepository(context);
repository.Add(newCustomer);
await repository.SaveChangesAsync();
var filterStored = new CustomerFilter {
Id = newCustomer.Id
};
var storedCustomer = await repository.GetByFilterAsync(filterStored);
repository.Remove(storedCustomer);
await repository.SaveChangesAsync();
//Assert
var filterNonExistentUser = new CustomerFilter {
Id = newCustomer.Id
};
var nonExistentUser = await repository.GetByFilterAsync(filterNonExistentUser);
Assert.Null(nonExistentUser);
}
finally
{
connection.Close();
}
}
public async Task DuplicatedEmailTest()
{
var connection = CreateSqLiteConnection();
connection.Open();
try
{
var options = SetDbContextOptionsBuilder(connection);
await using var context = new CustomerMngtContext(options);
Assert.True(await context.Database.EnsureCreatedAsync());
//Arrange
var customerOne = new CustomerMngt.Domain.Entities.Customer
{
Password = "******",
Email = "*****@*****.**",
Surname = "Surname1",
FirstName = "FirstName1",
Created = DateTime.Now
};
var customerTwo = new CustomerMngt.Domain.Entities.Customer
{
Password = "******",
Email = "*****@*****.**",
Surname = "Surname2",
FirstName = "FirstName2",
Created = DateTime.Now
};
//Act
var repository = new CustomerRepository(context);
repository.Add(customerOne);
await repository.SaveChangesAsync();
//Assert
repository.Add(customerTwo);
var exception =
await Assert.ThrowsAsync <DbUpdateException>(() => repository.SaveChangesAsync());
Assert.NotNull(exception);
}
finally
{
connection.Close();
}
}
public async Task GetListTest()
{
//Arrange
var customerOne = new CustomerMngt.Domain.Entities.Customer
{
Id = 1,
Password = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "FirstName",
Updated = DateTime.Now,
Created = DateTime.Now
};
var customerTwo = new CustomerMngt.Domain.Entities.Customer
{
Id = 2,
Password = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "FirstName",
Updated = DateTime.Now,
Created = DateTime.Now
};
var customers = new List <CustomerMngt.Domain.Entities.Customer>
{
customerOne,
customerTwo
};
//Act
var mockRepository = new Mock <ICustomerRepository>();
var mockPassword = new Mock <IPasswordHasher>();
var filter = new CustomerFilter {
PageSize = 10, CurrentPage = 1
};
mockRepository.Setup(x => x.CountByFilterAsync(filter))
.ReturnsAsync(customers.Count);
mockRepository.Setup(x => x.GetListByFilterAsync(filter))
.ReturnsAsync(customers);
var mockService = new CustomerService(mockRepository.Object, mockPassword.Object);
var result = await mockService.GetListByFilterAsync(filter);
//Assert
Assert.Equal(2, result.Count);
}
public async Task GetTest()
{
//Arrange
var customer = new CustomerMngt.Domain.Entities.Customer
{
Id = 1,
Password = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "First Name"
};
var customerResponseDto = new CustomerResponseDto
{
Id = 1,
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "First Name",
FullName = "First Name Surname"
};
var filterDto = new CustomerFilterDto {
Id = 1
};
var filter = new CustomerFilter {
Id = 1
};
//Act
var mockService = new Mock <ICustomerService>();
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(x => x.Map <CustomerResponseDto>(customer)).Returns(customerResponseDto);
mockMapper.Setup(x => x.Map <CustomerFilter>(filterDto)).Returns(filter);
mockService.Setup(x => x.GetByFilterAsync(filter)).ReturnsAsync(customer);
//Assert
var mockFacade = new CustomerFacade(mockService.Object, mockMapper.Object);
var result = await mockFacade.GetByFilterAsync(filterDto);
Assert.Equal(customer.Id, result.Id);
}
public async Task CreateInvalidFirstNameMinLengthTest()
{
//Arrange
var customer = new CustomerMngt.Domain.Entities.Customer
{
Password = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "F"
};
//Act
var mockRepository = new Mock <ICustomerRepository>();
var mockPassword = new Mock <IPasswordHasher>();
var mockService = new CustomerService(mockRepository.Object, mockPassword.Object);
var exception = await Assert.ThrowsAsync <ValidationException>(() => mockService.CreateAsync(customer));
//Assert
Assert.NotNull(exception);
}
public async Task UpdateTest()
{
//Arrange
var customerRequestDto = new CustomerRequestDto
{
Password = "******",
ConfirmPassword = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "First Name"
};
var customer = new CustomerMngt.Domain.Entities.Customer
{
Password = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "First Name"
};
const long id = 1;
//Act
var mockService = new Mock <ICustomerService>();
var mockMapper = new Mock <IMapper>();
//Assert
mockMapper.Setup(x => x.Map <CustomerMngt.Domain.Entities.Customer>(customerRequestDto)).Returns(customer);
var mockFacade = new CustomerFacade(mockService.Object, mockMapper.Object);
try
{
await Assert.ThrowsAsync <Exception>(() => mockFacade.UpdateAsync(id, customerRequestDto));
}
catch (AssertActualExpectedException exception)
{
Assert.Equal("(No exception was thrown)", exception.Actual);
}
}
public async Task UpdateInvalidCustomerNotFoundTest()
{
//Arrange
const long id = 1;
var customer = new CustomerMngt.Domain.Entities.Customer
{
Id = 1,
Password = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "First Name"
};
//Act
var mockRepository = new Mock <ICustomerRepository>();
var mockPassword = new Mock <IPasswordHasher>();
var mockService = new CustomerService(mockRepository.Object, mockPassword.Object);
var exception = await Assert.ThrowsAsync <EntityNotFoundException>(() => mockService.UpdateAsync(id, customer));
//Assert
Assert.NotNull(exception);
}
public async Task GetListTest()
{
//Arrange
var customerOne = new CustomerMngt.Domain.Entities.Customer
{
Id = 1,
Password = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "Ronaldo",
Updated = DateTime.Now,
Created = DateTime.Now
};
var customerTwo = new CustomerMngt.Domain.Entities.Customer
{
Id = 2,
Password = "******",
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "Ronaldinho",
Updated = DateTime.Now,
Created = DateTime.Now
};
var customers = new List <CustomerMngt.Domain.Entities.Customer>
{
customerOne,
customerTwo
};
var pagination = new Pagination <CustomerMngt.Domain.Entities.Customer>
{
PageSize = 10,
CurrentPage = 1,
Count = 2,
Result = customers
};
var customerOneDto = new CustomerResponseDto
{
Id = 1,
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "Ronaldo"
};
var customerTwoDto = new CustomerResponseDto
{
Id = 2,
Email = "*****@*****.**",
Surname = "Surname",
FirstName = "Ronaldinho"
};
var customersDto = new List <CustomerResponseDto>
{
customerOneDto,
customerTwoDto
};
var paginationDto = new PaginationDto <CustomerResponseDto>
{
PageSize = 10,
CurrentPage = 1,
Count = 2,
TotalPages = 1,
Result = customersDto
};
var filterDto = new CustomerFilterDto {
Id = 1
};
var filter = new CustomerFilter {
Id = 1
};
//Act
var mockService = new Mock <ICustomerService>();
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(x => x.Map <CustomerFilter>(filterDto)).Returns(filter);
mockMapper.Setup(x => x.Map <PaginationDto <CustomerResponseDto> >(pagination)).Returns(paginationDto);
mockService.Setup(x => x.GetListByFilterAsync(filter)).ReturnsAsync(pagination);
//Assert
var mockFacade = new CustomerFacade(mockService.Object, mockMapper.Object);
var result = await mockFacade.GetListByFilterAsync(filterDto);
Assert.Equal(paginationDto.Count, result.Count);
}
