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());
}
private async Task CountSpecificStatusIssues(IssueCount issueCount, Func <Issue, bool> searchForValue)
{
issueCount.NewIssue = await issueRepository.CountIssues(x => x.Status == Status.New && searchForValue(x));
issueCount.OpenIssue = await issueRepository.CountIssues(x => x.Status == Status.Open && searchForValue(x));
issueCount.ProgressIssue = await issueRepository.CountIssues(x => x.Status == Status.Progress && searchForValue(x));
issueCount.PendingIssue = await issueRepository.CountIssues(x => x.Status == Status.Pending && searchForValue(x));
}
/// <summary>
/// Ts the generate issue count list from reader.
/// </summary>
/// <param name="returnData">The return data.</param>
/// <param name="issueCountList">The issue count list.</param>
private static void GenerateIssueCountListFromReader(IDataReader returnData, ref List <IssueCount> issueCountList)
{
while (returnData.Read())
{
var issueCount = new IssueCount(
returnData.GetValue(2),
(string)returnData.GetValue(0),
(int)returnData.GetValue(1),
(string)returnData.GetValue(3)
);
issueCountList.Add(issueCount);
}
}
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 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 PaginatedItemsDto <GetIssueListDto, IssueCount> GetPaginatedItems(int pageIndex, IssueCount issueCount, int pageSize)
{
var issueList = new List <GetIssueListDto>()
{
new GetIssueListDto {
Status = Status.New, Declarant = "1", Id = 1, Title = "test1", Departament = "production"
},
new GetIssueListDto {
Status = Status.New, Declarant = "1", Id = 2, Title = "test2", Departament = "production"
},
};
return(new PaginatedItemsDto <GetIssueListDto, IssueCount>(pageIndex, issueCount, issueList, pageSize));
}
