public async Task Should_Sorting_Works_Properly(
Mock <IMemoryDatabaseProvider <TestDbContext> > mockProvider,
List <Book> source)
{
// Arrange
string sorting = nameof(Book.Title) + " DESC";
var queryable = source.AsQueryable();
var repository = new MockingMemoryRepository <TestDbContext, Book, Guid>(mockProvider.Object, queryable);
var sut = CreateAppService(repository);
var filter = new BookFilterDto {
Sorting = sorting
};
// Act
var actual = await sut.GetListAsync(filter);
var expectedItems = queryable.ApplyFilter(filter).ToList();
var expectedCount = filter.ApplyFilterWithoutPaginationAndOrdering(queryable).Count();
// Assert
actual.Items.ShouldNotBeNull();
actual.TotalCount.ShouldBe(expectedCount);
actual.Items.Count.ShouldBe(expectedItems.Count);
for (int i = 0; i < actual.Items.Count; i++)
{
actual.Items[i].Title.ShouldBe(expectedItems[i].Title);
}
}
public async Task <PageResult <GetBookDto> > GetBookByPage(BookFilterDto input)
{
var counts = 0;
var results = _bookRepository
.GetAll()
.WhereIf(!String.IsNullOrEmpty(input.BookName), x => x.Name.Contains(input.BookName))
.Select(c => new GetBookDto
{
Id = c.Id,
Name = c.Name,
PriceBorrow = c.PriceBorrow,
Category = c.Category.Name,
Author = c.Author.Name,
Publisher = c.Publisher.Name,
YearPublic = c.YearPublic
});
counts = results.Count();
var result = new PageResult <GetBookDto>
{
Count = counts,
PageIndex = input.PageIndex,
PageSize = input.PageSize,
Items = await results.Skip((input.PageIndex - 1) *input.PageSize).Take(input.PageSize).ToListAsync()
};
return(result);
}
public async Task Should_Filter_Work_Properly(
Mock <IMemoryDatabaseProvider <TestDbContext> > mockProvider,
List <Book> source)
{
// Arrange
string sorting = "Title DESC";
string searchText = "ab";
var query = source.AsQueryable();
var repository = new MockingMemoryRepository <TestDbContext, Book, Guid>(mockProvider.Object, query);
var sut = CreateAppService(repository);
var filter = new BookFilterDto {
Sorting = sorting, Filter = searchText
};
// Act
var actual = await sut.GetListAsync(filter);
var expected = query
// ToLowerContainsComparison attribute should generate exactly following expression:
.Where(x => x.Title.ToLowerInvariant().Contains(searchText.ToLowerInvariant()))
.OrderByDescending(x => x.Title)
.Skip(filter.SkipCount)
.Take(filter.MaxResultCount)
.ToList();
actual.ShouldNotBeNull();
actual.Items.ShouldNotBeNull();
actual.Items.Count.ShouldBe(expected.Count);
for (int i = 0; i < actual.Items.Count; i++)
{
actual.Items[i].Title.ShouldBe(expected[i].Title); // Id cannot be mocked. All ids are same.
}
}
public async Task Should_Sorting_Work_Properly(
Mock <IMemoryDatabaseProvider <TestDbContext> > mockProvider,
List <Book> source)
{
// Arrange
string sorting = "Title DESC";
var query = source.AsQueryable();
var repository = new MockingMemoryRepository <TestDbContext, Book, Guid>(mockProvider.Object, query);
var sut = CreateAppService(repository);
var filter = new BookFilterDto {
Sorting = sorting
};
// Act
var actual = await sut.GetListAsync(filter);
var expected = query
.OrderByDescending(x => x.Title)
.Skip(filter.SkipCount)
.Take(filter.MaxResultCount)
.ToList();
actual.ShouldNotBeNull();
actual.Items.ShouldNotBeNull();
actual.Items.Count.ShouldBe(expected.Count);
for (int i = 0; i < actual.Items.Count; i++)
{
actual.Items[i].Title.ShouldBe(expected[i].Title); // Id cannot be mocked. All ids are same.
}
}
public void Test_ListAsync()
{
WithService(async(service) =>
{
foreach (var i in Enumerable.Range(1, 9))
{
var book = new Book()
{
Title = $"b{i}:seq{i % 2}", Description = $"{i % 2}"
};
service.Repo.Insert(book);
}
await service.Uow.SaveChangesAsync();
var filter = new BookFilterDto()
{
};
// use sync to fix X.PagedList Task.Run issue
var resultT = service.ListAsync(filter);
resultT.Wait();
var result = resultT.Result;
// with pages
Assert.Equal(9, result.MetaData.TotalItemCount);
Assert.Equal(2, result.List.Count);
Assert.Equal(5, result.MetaData.PageCount);
Assert.Equal(1, result.MetaData.PageNumber);
// select page
var filter2 = new BookFilterDto()
{
Page = 3
};
// use sync to fix X.PagedList Task.Run issue
var result2T = service.ListAsync(filter2);
result2T.Wait();
var result2 = result2T.Result;
Assert.Equal(9, result2.MetaData.TotalItemCount);
Assert.Equal(2, result2.List.Count);
Assert.Equal(5, result2.MetaData.PageCount);
Assert.Equal(3, result2.MetaData.PageNumber);
Assert.Equal("b5:seq1,b4:seq0", string.Join(",", result2.List.Select(e => e.Title)));
// use filter
var filter3 = new BookFilterDto()
{
Title = "seq1"
};
// use sync to fix X.PagedList Task.Run issue
var result3T = service.ListAsync(filter3);
result3T.Wait();
var result3 = result3T.Result;
Assert.Equal(5, result3.MetaData.TotalItemCount);
Assert.Equal(2, result3.List.Count);
Assert.Equal(3, result3.MetaData.PageCount);
Assert.Equal("b9:seq1,b7:seq1", string.Join(",", result3.List.Select(e => e.Title)));
});
}
public async Task Should_RangeFilter_Work_Properly(
Mock <IMemoryDatabaseProvider <TestDbContext> > mockProvider,
List <Book> source)
{
// Arrange
string sorting = "Title DESC";
var query = source.AsQueryable();
var repository = new MockingMemoryRepository <TestDbContext, Book, Guid>(mockProvider.Object, query);
var sut = CreateAppService(repository);
var filter = new BookFilterDto
{
Sorting = sorting,
PublishDate = new Range <DateTime>()
{
Min = DateTime.UtcNow
}
};
// Act
var actual = await sut.GetListAsync(filter);
var expected = query
// TRange type should generate exactly following expression:
.Where(x => x.PublishDate >= filter.PublishDate.Min)
.OrderByDescending(x => x.Title)
.Skip(filter.SkipCount)
.Take(filter.MaxResultCount)
.ToList();
actual.ShouldNotBeNull();
actual.Items.ShouldNotBeNull();
actual.Items.Count.ShouldBe(expected.Count);
for (int i = 0; i < actual.Items.Count; i++)
{
actual.Items[i].Title.ShouldBe(expected[i].Title); // Id cannot be mocked. All ids are same.
}
}
public async Task Should_Pagination_Works_Properly(
Mock <IMemoryDatabaseProvider <TestDbContext> > mockProvider,
List <Book> source)
{
// Arrange
int skip = 3, take = 2;
var repository = new MockingMemoryRepository <TestDbContext, Book, Guid>(mockProvider.Object, source.AsQueryable());
var sut = CreateAppService(repository);
var filter = new BookFilterDto {
SkipCount = skip, MaxResultCount = take
};
// Act
var actual = await sut.GetListAsync(filter);
var expectedItems = source.AsQueryable().ApplyFilter(filter).ToList();
var expectedCount = source.Count;
// Assert
actual.Items.ShouldNotBeNull();
actual.TotalCount.ShouldBe(expectedCount);
actual.Items.Count.ShouldBe(expectedItems.Count);
}
public RecordSet <BookDto> Get([FromQuery] BookFilterDto filterDto)
{
var filter = _mapper.Map <BookFilter>(filterDto);
return(filter.ToRecordSet <Book, BookDto>(_dataSource, _mapper));
}
