Skip to content

Open-source eCommerce platform for C# and ASP.NET Core 10 with MongoDB. Build multi-store shops and multi-vendor marketplaces with B2B/B2C, REST API, plugins, Vue 3 and Docker.

7.9 KB
Raw Blame
using Grand.Data.Tests.LiteDb;
using Grand.Data.Tests.MongoDb;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Grand.Data.Tests;

/// <summary>
///     Covers the query execution primitives on <see cref="IRepository{T}" />. The paging arithmetic has to stay
///     identical to what the paged list produced before execution moved out of the domain project, so every
///     assertion here is on TotalCount / TotalPages / page contents rather than on how the query ran.
/// </summary>
[TestClass]
public class RepositoryPagedQueryTests
{
    private const string Mongo = "MongoDB";
    private const string LiteDb = "LiteDB";

    private IRepository<SampleCollection> _liteDb;
    private IRepository<SampleCollection> _mongoRepository;

    [TestInitialize]
    public async Task Init()
    {
        _mongoRepository = new MongoDBRepositoryTest<SampleCollection>();
        _liteDb = new LiteDBRepositoryMock<SampleCollection>();

        foreach (var repository in new[] { _mongoRepository, _liteDb })
            for (var i = 1; i <= 25; i++)
                await repository.InsertAsync(new SampleCollection { Name = $"sample {i:00}", Count = i });
    }

    private IRepository<SampleCollection> Repository(string provider)
    {
        return provider == Mongo ? _mongoRepository : _liteDb;
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task PagedAsync_FirstPage_ReturnsPageAndTotals(string provider)
    {
        var repository = Repository(provider);
        var query = repository.Table.OrderBy(x => x.Count);

        var result = await repository.PagedAsync(query, 0, 10);

        Assert.AreEqual(25, result.TotalCount);
        Assert.AreEqual(3, result.TotalPages);
        Assert.AreEqual(0, result.PageIndex);
        Assert.AreEqual(10, result.PageSize);
        Assert.AreEqual(10, result.Count);
        Assert.AreEqual(1, result.First().Count);
        Assert.IsFalse(result.HasPreviousPage);
        Assert.IsTrue(result.HasNextPage);
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task PagedAsync_LastPartialPage_ReturnsRemainder(string provider)
    {
        var repository = Repository(provider);
        var query = repository.Table.OrderBy(x => x.Count);

        var result = await repository.PagedAsync(query, 2, 10);

        Assert.AreEqual(25, result.TotalCount);
        Assert.AreEqual(5, result.Count);
        Assert.AreEqual(21, result.First().Count);
        Assert.IsTrue(result.HasPreviousPage);
        Assert.IsFalse(result.HasNextPage);
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task PagedAsync_PageBeyondRange_ReturnsEmptyPageWithTotals(string provider)
    {
        var repository = Repository(provider);
        var query = repository.Table.OrderBy(x => x.Count);

        var result = await repository.PagedAsync(query, 99, 10);

        Assert.AreEqual(0, result.Count);
        Assert.AreEqual(25, result.TotalCount);
        Assert.AreEqual(3, result.TotalPages);
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task PagedAsync_NoMatches_ReturnsEmpty(string provider)
    {
        var repository = Repository(provider);
        var query = repository.Table.Where(x => x.Count > 1000);

        var result = await repository.PagedAsync(query, 0, 10);

        Assert.AreEqual(0, result.Count);
        Assert.AreEqual(0, result.TotalCount);
        Assert.AreEqual(0, result.TotalPages);
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task PagedAsync_NonPositivePageSize_NormalizesToOne(string provider)
    {
        var repository = Repository(provider);
        var query = repository.Table.OrderBy(x => x.Count);

        var result = await repository.PagedAsync(query, 0, 0);

        Assert.AreEqual(1, result.PageSize);
        Assert.AreEqual(1, result.Count);
        Assert.AreEqual(25, result.TotalPages);
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task PagedAsync_Projection_ReturnsProjectedPage(string provider)
    {
        var repository = Repository(provider);
        var query = repository.Table.OrderBy(x => x.Count).Select(x => x.Name);

        var result = await repository.PagedAsync(query, 0, 5);

        Assert.AreEqual(25, result.TotalCount);
        Assert.AreEqual(5, result.Count);
        Assert.AreEqual("sample 01", result.First());
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task ToListAsync_ReturnsAllMatches(string provider)
    {
        var repository = Repository(provider);

        var result = await repository.ToListAsync(repository.Table.Where(x => x.Count <= 3));

        Assert.AreEqual(3, result.Count);
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task CountAsync_ReturnsNumberOfMatches(string provider)
    {
        var repository = Repository(provider);

        Assert.AreEqual(3, await repository.CountAsync(repository.Table.Where(x => x.Count <= 3)));
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task FirstOrDefaultAsync_ReturnsFirstMatchInQueryOrder(string provider)
    {
        var repository = Repository(provider);

        var result = await repository.FirstOrDefaultAsync(
            repository.Table.Where(x => x.Count <= 3).OrderByDescending(x => x.Count));

        Assert.AreEqual(3, result.Count);
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task FirstOrDefaultAsync_NoMatches_ReturnsDefault(string provider)
    {
        var repository = Repository(provider);

        Assert.IsNull(await repository.FirstOrDefaultAsync(repository.Table.Where(x => x.Count > 1000)));
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task FirstOrDefaultAsync_Projection_ReturnsProjectedValue(string provider)
    {
        var repository = Repository(provider);

        var result =
            await repository.FirstOrDefaultAsync(repository.Table.OrderBy(x => x.Count).Select(x => x.Name));

        Assert.AreEqual("sample 01", result);
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task AnyAsync_ReturnsWhetherAnythingMatches(string provider)
    {
        var repository = Repository(provider);

        Assert.IsTrue(await repository.AnyAsync(repository.Table.Where(x => x.Count <= 3)));
        Assert.IsFalse(await repository.AnyAsync(repository.Table.Where(x => x.Count > 1000)));
    }

    [TestMethod]
    [DataRow(Mongo)]
    [DataRow(LiteDb)]
    public async Task PagedAsync_NullQuery_Throws(string provider)
    {
        var repository = Repository(provider);

        await Assert.ThrowsExactlyAsync<ArgumentNullException>(() =>
            repository.PagedAsync<SampleCollection>(null, 0, 10));
    }

    /// <summary>
    ///     Handing the Mongo repository a sequence that is already in memory is a programming error - it means the
    ///     caller materialised the query before the repository could run it, which is the blocking pattern these
    ///     methods exist to remove. It has to fail loudly rather than quietly enumerate and look like it worked.
    /// </summary>
    [TestMethod]
    public async Task MongoRepository_InMemoryQuery_ThrowsInsteadOfEnumerating()
    {
        var items = Enumerable.Range(1, 25).Select(i => new SampleCollection { Count = i }).ToList();

        await Assert.ThrowsExactlyAsync<ArgumentException>(() =>
            _mongoRepository.ToListAsync(items.AsQueryable().Where(x => x.Count <= 4)));
        await Assert.ThrowsExactlyAsync<ArgumentException>(() =>
            _mongoRepository.PagedAsync(items.AsQueryable().OrderBy(x => x.Count), 0, 10));
        await Assert.ThrowsExactlyAsync<ArgumentException>(() =>
            _mongoRepository.FirstOrDefaultAsync(items.AsQueryable().Where(x => x.Count <= 4)));
        await Assert.ThrowsExactlyAsync<ArgumentException>(() =>
            _mongoRepository.AnyAsync(items.AsQueryable().Where(x => x.Count <= 4)));
    }
}