public async Task Handle_CustomersExists_ReturnCustomers(
[Frozen] Mock <IRepository <Entities.Customer> > customerRepoMock,
GetCustomersQueryHandler sut,
List <Entities.Customer> customers,
GetCustomersQuery query
)
{
// Arrange
customerRepoMock.Setup(x => x.CountAsync(
It.IsAny <CountCustomersSpecification>(),
It.IsAny <CancellationToken>()
))
.ReturnsAsync(customers.Count);
//Act
var result = await sut.Handle(query, CancellationToken.None);
//Assert
result.Should().NotBeNull();
customerRepoMock.Verify(x => x.ListAsync(
It.IsAny <ISpecification <Entities.Customer> >(),
It.IsAny <CancellationToken>()
));
customerRepoMock.Verify(x => x.CountAsync(
It.IsAny <ISpecification <Entities.Customer> >(),
It.IsAny <CancellationToken>()
));
result.TotalCustomers.Should().Be(customers.Count);
}
public async Task GetCustomers_ShouldReturnCustomers_WhenGivenCustomers(
[Frozen] Mock <IMediator> mockMediator,
List <Core.Handlers.GetCustomer.StoreCustomerDto> customers,
[Greedy] CustomerController sut,
GetCustomersQuery query
)
{
//Arrange
var dto = new GetCustomersDto
{
TotalCustomers = customers.Count,
Customers = customers.ToList <Core.Handlers.GetCustomer.CustomerDto>()
};
mockMediator.Setup(x => x.Send(It.IsAny <GetCustomersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(dto);
//Act
var actionResult = await sut.GetCustomers(query);
//Assert
var okObjectResult = actionResult as OkObjectResult;
okObjectResult.Should().NotBeNull();
var response = okObjectResult.Value as Models.GetCustomers.GetCustomersResult;
response.TotalCustomers.Should().Be(customers.Count);
response.Customers.Count.Should().Be(customers.Count);
response.Customers[0].AccountNumber.Should().Be(customers[0].AccountNumber);
response.Customers[1].AccountNumber.Should().Be(customers[1].AccountNumber);
}
public async Task <List <CustomerDto> > Handle(GetCustomersQuery request, CancellationToken cancellationToken)
{
var result = (
from customers in _context.Customers
join countries in _context.Countries on customers.CountryId equals countries.Id
join categoryCustomers in _context.CategoryCustomers on customers.CategoryCustomerId equals categoryCustomers.Id
join priceTiers in _context.PriceTiers on customers.PriceTierId equals priceTiers.Id
join termsOfPayments in _context.TermsOfPayments on customers.TermsOfPaymentId equals termsOfPayments.Id
select new CustomerDto
{
Id = customers.Id,
Name = customers.Name,
Email = customers.Email,
City = customers.City,
Country = countries.Name,
CategoryCustomerId = categoryCustomers.Id,
CategoryCustomer = categoryCustomers.Name,
PriceTierId = priceTiers.Id,
PriceTier = priceTiers.Name,
TaxLocation = customers.TaxLocation,
TermsOfPaymentId = termsOfPayments.Id,
TermsOfPayment = termsOfPayments.Name
}).ToList();
var customerPaymentHistoricist = _context.CustomerPaymentHistories.ToList();
result.ForEach(x => x.TheyOwnYou = customerPaymentHistoricist.Where(y => y.CustomerId == x.Id).Select(z => z.TheyOwnYou).ToList().Sum());
result.ForEach(x => x.YouOwnThem = customerPaymentHistoricist.Where(y => y.CustomerId == x.Id).Select(z => z.YouOwnThem).ToList().Sum());
result.ForEach(x => x.Balance = customerPaymentHistoricist.Where(y => y.CustomerId == x.Id).Select(z => z.Balance).ToList().Sum());
return(await Task.FromResult(result));
}
public ActionResult Get()
{
// Send the query
var query = new GetCustomersQuery();
var customers = query.Run();
return(Ok(customers));
}
public async Task <IEnumerable <CustomerDto> > Handle(GetCustomersQuery request, CancellationToken cancellationToken)
{
var customers = await _context.Customers.ToListAsync();
var customersDto = _mapper.Map <IEnumerable <CustomerDto> >(customers);
return(customersDto);
}
public async Task <List <Customer> > Handle(GetCustomersQuery request, CancellationToken cancellationToken)
{
var myTask = Task.Run(() => _customerRepository.GetAll());
List <Customer> result = await myTask;
return(result);
}
public Task <List <Customer> > GetCustomersAsync(GetCustomersQuery query)
{
var customers = this.customers
.Where(c => BuildGetCustomersFilter(c, query))
.Select(c => c.Value)
.ToList();
return(Task.FromResult(customers));
}
public void TestValidate_ValidQuery_NoValidationError(
GetCustomersQueryValidator sut,
GetCustomersQuery query
)
{
//Act
var result = sut.TestValidate(query);
result.ShouldNotHaveValidationErrorFor(query => query.PageIndex);
result.ShouldNotHaveValidationErrorFor(query => query.PageSize);
}
public async Task <IReadOnlyCollection <CustomerDTO> > Handle(GetCustomersQuery request, CancellationToken cancellationToken)
{
var entities = await _customerRepository.GetAllAsync();
return(entities.Select(c => new CustomerDTO
{
Name = c.Name,
Email = c.Email
})
.ToList());
}
public Task <IEnumerable <CustomerReponse> > Handle(
GetCustomersQuery request,
CancellationToken cancellationToken)
{
var response = _customerRepository.GetAll();
var viewModel = response.Select(c =>
new CustomerReponse(c.Id, c.Name, c.DocumentNumber));
return(Task.FromResult(viewModel));
}
public async Task <IEnumerable <CustomerDto> > Handle(GetCustomersQuery request, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var persons = applicationDataContext.Persons
.AsQueryable()
.Include(c => c.Addresses)
.Include(c => c.BillingAddress)
.Include(c => c.ShippingAddress);
return(mapper.ProjectTo <CustomerDto>(persons));
}
public void TestValidate_InvalidPageSize_ValidationErrorForPageSize(
GetCustomersQueryValidator sut,
GetCustomersQuery query
)
{
//Arrange
query.PageSize = 0;
var result = sut.TestValidate(query);
result.ShouldHaveValidationErrorFor(query => query.PageSize);
}
public async Task <Collection <Customer> > Get(CustomerFilter customerFilter)
{
GetCustomersQuery query = new GetCustomersQuery(uow, customerFilter);
List <Customer> items = await mapper.ProjectTo <Customer>(query.Build()).ToListAsync();
var result = new Collection <Customer>(items, query.Count(), customerFilter);
// demo purpose only
if (items.Count < result.TotalItems)
{
modelStateAccessor.InfoMessages.Add("Use pagination for showing all records.");
}
return(result);
}
public async Task <GetAllCustomersResponse> Handle(GetAllCustomersRequest request, CancellationToken cancellationToken)
{
var query = new GetCustomersQuery()
{
CompanyId = request.AuthenticatorCompanyId
};
var customers = await queryExecutor.Execute(query);
var mappedCustomers = mapper.Map <List <CustomerDto> >(customers);
return(new GetAllCustomersResponse()
{
Data = mappedCustomers
});
}
public async Task <BaseDto <IList <CustomerInput> > > Handle(GetCustomersQuery request, CancellationToken cancellationToken) =>
new BaseDto <IList <CustomerInput> >
{
Message = "Success retrieve customer datas",
Status = true,
Data = await _context.customers.OrderBy(x => x.id).Select(result => new CustomerInput
{
full_name = result.full_name,
username = result.username,
password = result.password,
email = result.email,
birthdate = result.birthdate,
gender = result.gender,
phone_number = result.phone_number
}).ToListAsync()
};
public void ShouldReturnAllCustomers()
{
var options = new DbContextOptionsBuilder <NorthwindContext>()
.UseInMemoryDatabase(databaseName: "ShouldReturnAllCustomers")
.Options;
var context = new NorthwindContext(options);
Seed(context);
var query = new GetCustomersQuery(context);
var result = query.Execute();
Assert.Equal(6, result.Count);
}
public void ShouldOrderCustomersByName()
{
var options = new DbContextOptionsBuilder <NorthwindContext>()
.UseInMemoryDatabase(databaseName: "ShouldOrderCustomersByName")
.Options;
var context = new NorthwindContext(options);
Seed(context);
var query = new GetCustomersQuery(context);
var result = query.Execute();
Assert.Equal("Beth Smith", result.First().Name);
}
private static void DisplayCustomers(NorthwindContext context)
{
var query = new GetCustomersQuery(context);
var customers = query.Execute();
if (!customers.Any())
{
Console.WriteLine("No customers.");
}
foreach (var customer in customers)
{
Console.WriteLine($"{customer.Id}: {customer.Name}");
}
Console.WriteLine();
}
public async Task <IEnumerable <CustomersDto> > Handle(GetCustomersQuery request, CancellationToken cancellationToken)
{
var result = await(from customer in _context.Customers
select new CustomersDto
{
CustomerId = customer.CustomerId,
CompanyName = customer.CompanyName,
ContactTitle = customer.ContactTitle,
ContactName = customer.ContactName,
Address = customer.Address,
City = customer.City,
Region = customer.Region
}).ToListAsync(cancellationToken);
return(result);
//return await Task.FromResult<IEnumerable<CustomersDto>>(null);
}
public void Handle_NoCustomersExists_ThrowArgumentNullException(
[Frozen] Mock <IRepository <Entities.Customer> > customerRepoMock,
GetCustomersQueryHandler sut,
GetCustomersQuery query
)
{
// Arrange
customerRepoMock.Setup(x => x.ListAsync(
It.IsAny <GetCustomersPaginatedSpecification>(),
It.IsAny <CancellationToken>()
))
.ReturnsAsync((List <Entities.Customer>)null);
//Act
Func <Task> func = async() => await sut.Handle(query, CancellationToken.None);
//Assert
func.Should().Throw <ArgumentNullException>()
.WithMessage("Value cannot be null. (Parameter 'customers')");
}
public async Task ValidateAsync_InvalidQuery_ValidationResultIsNotValid()
{
// Arrange
var validator = new GetCustomersQueryValidator();
var query = new GetCustomersQuery(
new List <Guid> {
Guid.Empty
},
new List <string>(),
new List <int>(),
new List <long>(),
new List <string>());
// Act
var result = await validator.ValidateAsync(query);
// Assert
result.Should().NotBeNull();
result.IsValid.Should().BeFalse();
result.Errors.Should().NotBeEmpty();
}
public async Task GetCustomers_ShouldReturnNotFound_WhenGivenNoCustomers(
[Frozen] Mock <IMediator> mockMediator,
[Greedy] CustomerController sut,
GetCustomersQuery query
)
{
//Arrange
mockMediator.Setup(x => x.Send(
It.IsAny <GetCustomersQuery>(),
It.IsAny <CancellationToken>()
))
.ReturnsAsync((GetCustomersDto)null);
//Act
var actionResult = await sut.GetCustomers(query);
//Assert
var notFoundResult = actionResult as NotFoundResult;
notFoundResult.Should().NotBeNull();
}
public async Task ValidateAsync_ValidQuery_ValidationResultIsValid()
{
// Arrange
var validator = new GetCustomersQueryValidator();
var query = new GetCustomersQuery(
new List <Guid> {
Guid.Parse("34DE200F-EDCF-4590-9BD1-00318E826164")
},
new List <string>(),
new List <int>(),
new List <long>(),
new List <string>());
// Act
var result = await validator.ValidateAsync(query);
// Assert
result.Should().NotBeNull();
result.IsValid.Should().BeTrue();
result.Errors.Should().BeEmpty();
}
public async Task Handle_ValidQuery_CustomersReturned()
{
// Arrange
const int customersCount = 10;
var query = new GetCustomersQuery();
var customers = this.fixture
.Build <Customer>()
.CreateMany(customersCount)
.ToList();
this.repositoryMock
.Setup(r => r.GetCustomersAsync(It.IsAny <GetCustomersQuery>()))
.ReturnsAsync(customers);
// Act
var result = await this.handler.Handle(query, CancellationToken.None);
// Assert
result.Should().NotBeNull();
result.Should().AllBeOfType <CustomerDto>();
this.repositoryMock.VerifyAll();
}
public async Task <ActionResult> Get()
{
var customer = new GetCustomersQuery();
return(Ok(await _mediatr.Send(customer)));
}
public async Task <List <Customer> > Handle(GetCustomersQuery request, CancellationToken cancellationToken)
{
return(_customerRepository.GetAll().ToList());
}
public async Task <IEnumerable <CustomerDto> > Handle(GetCustomersQuery request, CancellationToken cancellationToken)
{
return((await _customerRepository.GetCustomersAsync())
.Select(CustomerDto.FromDomain)
.ToList());
}
public async Task <IDataResult <IEnumerable <Customer> > > Handle(GetCustomersQuery request, CancellationToken cancellationToken)
{
return(new SuccessDataResult <IEnumerable <Customer> >(await _customerMongoRepository.GetListAsync()));
}
public async Task <ActionResult <GetCustomersDto> > Get()
{
var result = new GetCustomersQuery();
return(Ok(await meciater.Send(result)));
}
public async Task <ActionResult <GetCustomersDto> > Handle(GetCustomersQuery request, CancellationToken cancellationToken)
{
var obj = await _context.Customers.ProjectTo <GetCustomerDto>(_mapper.ConfigurationProvider).ToListAsync();
return(new OkObjectResult(obj));
}
