private void SetConcreteSearch(SearchSpecificationDto searchSpecification)
{
if (searchSpecification.Status != null)
{
searchIssuesBox.ConcreteSearch(typeof(SearchIssuesByStatus), searchSpecification);
}
else
{
searchIssuesBox.ConcreteSearch(typeof(SearchIssuesWithoutClosed), searchSpecification);
}
if (searchSpecification.Departament != null)
{
searchIssuesBox.ConcreteSearch(typeof(SearchIssuesByDepartament), searchSpecification);
}
if (searchSpecification.Title != null)
{
searchIssuesBox.ConcreteSearch(typeof(SearchIssuesByTitle), searchSpecification);
}
if (searchSpecification.DeclarantLastName != null)
{
searchIssuesBox.ConcreteSearch(typeof(SearchIssuesByDeclarantLastName), searchSpecification);
}
if (searchSpecification.Priority != null)
{
searchIssuesBox.ConcreteSearch(typeof(SearchIssuesByPriority), searchSpecification);
}
}
public async Task GetIssuesByExampleType()
{
//Arrange
var searchSpecification = new SearchSpecificationDto();
var type = typeof(SearchIssuesWithoutClosed);
var issueCount = new IssueCount {
FilteredIssue = 2
};
var filteredIssueList = new FilteredIssueListDto {
Count = issueCount, Issues = GetIssueList()
};
var service = new IssueService(unitOfWork.Object, searchIssuesBox.Object, issueRepository.Object);
searchIssuesBox.Setup(x => x.ConcreteSearch(It.IsAny <Type>(), searchSpecification)).Verifiable();
searchIssuesBox.Setup(x => x.Search(x => x.Id != 0, searchSpecification)).Returns(Task.FromResult(filteredIssueList));
unitOfWork.Setup(x => x.Mapper().Map <List <GetIssueListDto> >(filteredIssueList.Issues)).Returns(GetIssueListDto());
//Act
var action = await service.GetIssues(searchSpecification);
//Assert
Assert.NotNull(action.Data);
searchIssuesBox.Verify(x => x.ConcreteSearch(It.IsAny <Type>(), searchSpecification), Times.Once);
}
public async Task GetIssuesOkObjectResponse()
{
//Arrange
int pageIndex = 1;
int pageSize = 2;
var issueCount = new IssueCount {
FilteredIssue = 2
};
var searchSpecification
= new SearchSpecificationDto {
PageIndex = pageIndex, PageSize = pageSize, SearchFor = SearchFor.AllIssues
};
issueService.Setup(x => x.GetIssues(searchSpecification))
.Returns(Task.FromResult(GetPaginatedItems(pageIndex, issueCount, pageSize)));
var controller = new IssueController(issueService.Object);
//Act
var action = await controller.GetIssues(searchSpecification) as OkObjectResult;
var item = action.Value as PaginatedItemsDto <GetIssueListDto, IssueCount>;
//Arrange
Assert.Equal(200, action.StatusCode);
Assert.Equal(2, item.Data.Count());
}
public void ConcreteSearch <T>(T typeOfSearch, SearchSpecificationDto searchSpecification) where T : class
{
var concreteSearches = new Hashtable();
var type = typeOfSearch;
if (!concreteSearches.ContainsKey(type))
{
var concreteSearch = Activator.CreateInstance(type as Type, searchSpecification);
concreteSearches.Add(type, concreteSearch);
}
var selectedSearch = concreteSearches[type] as IConcreteSearch;
predicates.Add(selectedSearch.getTypeOfSearch());
}
public void ConcreteSearchTest()
{
//Arrange
var type = typeof(SearchIssuesByStatus);
var searchSpecification = new SearchSpecificationDto();
var service = new SearchSpecificationBox(searchBy.Object);
//Act
try
{
service.ConcreteSearch(type, searchSpecification);
return;
}
catch (Exception)
{
//Assert
Assert.False(true);
}
}
public async Task SearchTestAsync()
{
//Arrange
var searchSpecification = new SearchSpecificationDto();
var service = new SearchSpecificationBox(searchBy.Object);
var issueCount = new IssueCount()
{
FilteredIssue = 2
};
var filteredIssueList = new FilteredIssueListDto()
{
Count = issueCount
};
searchBy.Setup(x => x.SearchIssues(x => x.Id != 0, It.IsAny <Expression <Func <Issue, bool> > >(), searchSpecification))
.Returns(Task.FromResult(filteredIssueList));
//Act
var action = await service.Search(x => x.Id != 0, searchSpecification);
//Assert
Assert.Equal(2, action.Count.FilteredIssue);
}
private Expression <Func <Issue, bool> > SetSearchForSpecification(SearchSpecificationDto searchSpecification)
{
Expression <Func <Issue, bool> > searchFor = null;
switch (searchSpecification.SearchFor)
{
case SearchFor.UserIssues:
searchFor = x => x.DeclarantId == searchSpecification.UserId;
break;
case SearchFor.SupportIssues:
searchFor = x => x.SupportIssues.Where(x => x.SupportId == searchSpecification.UserId).Any();
break;
case SearchFor.AllIssues:
searchFor = x => x.Id != 0;
break;
default:
break;
}
return(searchFor);
}
public SearchIssuesWithoutClosed(SearchSpecificationDto searchSpecification)
{
this.searchSpecification = searchSpecification;
}
public SearchIssuesByStatus(SearchSpecificationDto searchSpecification)
{
this.searchSpecification = searchSpecification;
}
public SearchIssuesByPriority(SearchSpecificationDto searchSpecification)
{
this.searchSpecification = searchSpecification;
}
public SearchIssuesByDepartament(SearchSpecificationDto searchSpecification)
{
this.searchSpecification = searchSpecification;
}
public SearchIssuesByTitle(SearchSpecificationDto searchSpecification)
{
this.searchSpecification = searchSpecification;
}
public async Task <PaginatedItemsDto <GetIssueListDto, IssueCount> > GetIssues(SearchSpecificationDto searchSpecification)
{
SetConcreteSearch(searchSpecification);
var searchFor = SetSearchForSpecification(searchSpecification);
var filteredIssueList = await searchIssuesBox.Search(searchFor, searchSpecification);
var issuesToReturn = unitOfWork.Mapper().Map <List <GetIssueListDto> >(filteredIssueList.Issues);
return(new PaginatedItemsDto <GetIssueListDto, IssueCount>(searchSpecification.PageIndex, filteredIssueList.Count,
issuesToReturn, searchSpecification.PageSize));
}
public virtual async Task <FilteredIssueListDto> SearchIssues(Expression <Func <Issue, bool> > searchFor,
Expression <Func <Issue, bool> > specification, SearchSpecificationDto searchSpecification)
{
FilteredIssueListDto filteredIssueList = new FilteredIssueListDto();
IssueCount issueCount = new IssueCount();
var specificationValue = specification.Compile();
var searchForValue = searchFor.Compile();
filteredIssueList.Issues = await issueRepository.GetIssues(x => specificationValue(x) && searchForValue(x),
searchSpecification.PageIndex, searchSpecification.PageSize);
issueCount.FilteredIssue = await issueRepository.CountIssues(x => specificationValue(x) && searchForValue(x));
await CountSpecificStatusIssues(issueCount, searchForValue);
filteredIssueList.Count = issueCount;
return(filteredIssueList);
}
public SearchIssuesByDeclarantLastName(SearchSpecificationDto searchSpecification)
{
this.searchSpecification = searchSpecification;
}
public async Task <IActionResult> GetIssues([FromQuery] SearchSpecificationDto searchSpecification)
{
return(Ok(await issueService.GetIssues(searchSpecification)));
}
public SearchByTest()
{
issueRepository = new Mock <IIssueRepository>();
searchSpecification = new SearchSpecificationDto();
}
public async Task <FilteredIssueListDto> Search(Expression <Func <Issue, bool> > searchFor, SearchSpecificationDto searchSpecification)
{
Expression <Func <Issue, bool> > expression = x => predicates.All(all => all(x));
var issues = await searchBy.SearchIssues(searchFor, expression, searchSpecification);
predicates.Clear();
return(issues);
}
