From f9ea630611e80445424b0f864c1bcd21a121a024 Mon Sep 17 00:00:00 2001 From: Sean Garrett Date: Sun, 2 Jul 2023 14:10:55 +0100 Subject: [PATCH] unit tests for keyed readonly repo --- .../AnyAsyncTests.cs | 101 ++++++++++++++++ .../AnyTests.cs | 100 ++++++++++++++++ .../CountAsyncTests.cs | 108 +++++++++++++++++ .../CountTests.cs | 105 ++++++++++++++++ .../GetAllAsyncTests.cs | 112 ++++++++++++++++++ .../GetAllTests.cs | 111 +++++++++++++++++ .../GetByIdAsyncTests.cs | 109 +++++++++++++++++ .../GetByIdTests.cs | 109 +++++++++++++++++ .../GetByMaxAsyncTests.cs | 112 ++++++++++++++++++ .../GetByMaxTests.cs | 111 +++++++++++++++++ .../GetByMinAsyncTests.cs | 112 ++++++++++++++++++ .../GetByMinTests.cs | 111 +++++++++++++++++ .../GetMaxValueAsyncTests.cs | 108 +++++++++++++++++ .../GetMaxValueTests.cs | 107 +++++++++++++++++ .../GetMinValueAsyncTests.cs | 108 +++++++++++++++++ .../GetMinValueTests.cs | 107 +++++++++++++++++ .../GetOneAsyncTests.cs | 110 +++++++++++++++++ .../GetOneTests.cs | 110 +++++++++++++++++ .../GetSortedPaginatedAsyncTests.cs | 2 +- .../GroupByTests.cs | 2 +- .../BaseMongoRepository.TKey.ReadOnly.cs | 2 +- 21 files changed, 1954 insertions(+), 3 deletions(-) create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/AnyAsyncTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/AnyTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/CountAsyncTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/CountTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetAllAsyncTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetAllTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByIdAsyncTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByIdTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMaxAsyncTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMaxTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMinAsyncTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMinTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMaxValueAsyncTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMaxValueTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMinValueAsyncTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMinValueTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetOneAsyncTests.cs create mode 100644 CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetOneTests.cs rename CoreUnitTests/{ReadOnlyMongoRepositoryTests => KeyedReadOnlyMongoRepositoryTests}/GetSortedPaginatedAsyncTests.cs (99%) rename CoreUnitTests/{ReadOnlyMongoRepositoryTests => KeyedReadOnlyMongoRepositoryTests}/GroupByTests.cs (99%) diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/AnyAsyncTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/AnyAsyncTests.cs new file mode 100644 index 0000000..6ba8dae --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/AnyAsyncTests.cs @@ -0,0 +1,101 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class AnyAsyncTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + + [Fact] + public async Task WithFilter_GetsResult() + { + // Arrange + SetupReader(); + + // Act + var result = await Sut.AnyAsync(filter); + + // Assert + result.Should().BeTrue(); + Reader.Verify( + x => x.AnyAsync(filter, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndCancellationToken_GetsResult() + { + // Arrange + var token = new CancellationToken(true); + + SetupReader(); + + // Act + var result = await Sut.AnyAsync(filter, token); + + // Assert + result.Should().BeTrue(); + Reader.Verify( + x => x.AnyAsync(filter, null, token), + Times.Once); + } + + [Fact] + public async Task WithFilterAndPartitionKey_GetsResult() + { + // Arrange + var partitionKey = Fixture.Create(); + + SetupReader(); + + // Act + var result = await Sut.AnyAsync(filter, partitionKey); + + // Assert + result.Should().BeTrue(); + Reader.Verify( + x => x.AnyAsync(filter, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndPartitionKeyAndCancellationToken_GetsResult() + { + // Arrange + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(); + + // Act + var result = await Sut.AnyAsync(filter, partitionKey, token); + + // Assert + result.Should().BeTrue(); + Reader.Verify( + x => x.AnyAsync(filter, partitionKey, token), + Times.Once); + } + + private void SetupReader() + { + Reader = new Mock(); + Reader + .Setup( + x => x.AnyAsync( + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .ReturnsAsync(true); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/AnyTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/AnyTests.cs new file mode 100644 index 0000000..af13658 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/AnyTests.cs @@ -0,0 +1,100 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class AnyTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + + [Fact] + public void WithFilter_GetsResult() + { + // Arrange + SetupReader(); + + // Act + var result = Sut.Any(filter); + + // Assert + result.Should().BeTrue(); + Reader.Verify( + x => x.Any(filter, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndCancellationToken_GetsResult() + { + // Arrange + var token = new CancellationToken(true); + + SetupReader(); + + // Act + var result = Sut.Any(filter, token); + + // Assert + result.Should().BeTrue(); + Reader.Verify( + x => x.Any(filter, null, token), + Times.Once); + } + + [Fact] + public void WithFilterAndPartitionKey_GetsResult() + { + // Arrange + var partitionKey = Fixture.Create(); + + SetupReader(); + + // Act + var result = Sut.Any(filter, partitionKey); + + // Assert + result.Should().BeTrue(); + Reader.Verify( + x => x.Any(filter, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndPartitionKeyAndCancellationToken_GetsResult() + { + // Arrange + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(); + + // Act + var result = Sut.Any(filter, partitionKey, token); + + // Assert + result.Should().BeTrue(); + Reader.Verify( + x => x.Any(filter, partitionKey, token), + Times.Once); + } + + private void SetupReader() + { + Reader = new Mock(); + Reader + .Setup( + x => x.Any( + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .Returns(true); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/CountAsyncTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/CountAsyncTests.cs new file mode 100644 index 0000000..96723f7 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/CountAsyncTests.cs @@ -0,0 +1,108 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class CountAsyncTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + + [Fact] + public async Task WithFilter_GetsOne() + { + // Arrange + var count = Fixture.Create(); + + SetupReader(count); + + // Act + var result = await Sut.CountAsync(filter); + + // Assert + result.Should().Be(count); + Reader.Verify( + x => x.CountAsync(filter, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndCancellationToken_GetsOne() + { + // Arrange + var count = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(count); + + // Act + var result = await Sut.CountAsync(filter, token); + + // Assert + result.Should().Be(count); + Reader.Verify( + x => x.CountAsync(filter, null, token), + Times.Once); + } + + [Fact] + public async Task WithFilterAndPartitionKey_GetsOne() + { + // Arrange + var count = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(count); + + // Act + var result = await Sut.CountAsync(filter, partitionKey); + + // Assert + result.Should().Be(count); + Reader.Verify( + x => x.CountAsync(filter, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndPartitionKeyAndCancellationToken_GetsOne() + { + // Arrange + var count = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(count); + + // Act + var result = await Sut.CountAsync(filter, partitionKey, token); + + // Assert + result.Should().Be(count); + Reader.Verify( + x => x.CountAsync(filter, partitionKey, token), + Times.Once); + } + + private void SetupReader(long count) + { + Reader = new Mock(); + Reader + .Setup( + x => x.CountAsync( + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .ReturnsAsync(count); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/CountTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/CountTests.cs new file mode 100644 index 0000000..a84fe1c --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/CountTests.cs @@ -0,0 +1,105 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class CountTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + + [Fact] + public void WithFilter_GetsOne() + { + // Arrange + var count = Fixture.Create(); + + SetupReader(count); + + // Act + var result = Sut.Count(filter); + + // Assert + result.Should().Be(count); + Reader.Verify( + x => x.Count(filter, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndCancellationToken_GetsOne() + { + // Arrange + var count = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(count); + + // Act + var result = Sut.Count(filter, token); + + // Assert + result.Should().Be(count); + Reader.Verify( + x => x.Count(filter, null, token), + Times.Once); + } + + [Fact] + public void WithFilterAndPartitionKey_GetsOne() + { + // Arrange + var count = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(count); + + // Act + var result = Sut.Count(filter, partitionKey); + + // Assert + result.Should().Be(count); + Reader.Verify( + x => x.Count(filter, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndPartitionKeyAndCancellationToken_GetsOne() + { + // Arrange + var count = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(count); + + // Act + var result = Sut.Count(filter, partitionKey, token); + + // Assert + result.Should().Be(count); + Reader.Verify( + x => x.Count(filter, partitionKey, token), + Times.Once); + } + + private void SetupReader(long count) + { + Reader = new Mock(); + Reader + .Setup( + x => x.Count( + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .Returns(count); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetAllAsyncTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetAllAsyncTests.cs new file mode 100644 index 0000000..a871c08 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetAllAsyncTests.cs @@ -0,0 +1,112 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetAllAsyncTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + + [Fact] + public async Task WithFilter_GetsOne() + { + // Arrange + var document = Fixture.CreateMany().ToList(); + + SetupReader(document); + + // Act + var result = await Sut.GetAllAsync(filter); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetAllAsync(filter, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.CreateMany().ToList(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = await Sut.GetAllAsync(filter, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetAllAsync(filter, null, token), + Times.Once); + } + + [Fact] + public async Task WithFilterAndPartitionKey_GetsOne() + { + // Arrange + var document = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + + SetupReader(document); + + // Act + var result = await Sut.GetAllAsync(filter, partitionKey); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetAllAsync(filter, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndPartitionKeyAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = await Sut.GetAllAsync(filter, partitionKey, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetAllAsync(filter, partitionKey, token), + Times.Once); + } + + private void SetupReader(List documents) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetAllAsync( + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .ReturnsAsync(documents); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetAllTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetAllTests.cs new file mode 100644 index 0000000..3ff29bb --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetAllTests.cs @@ -0,0 +1,111 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Threading; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetAllTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + + [Fact] + public void WithFilter_GetsOne() + { + // Arrange + var document = Fixture.CreateMany().ToList(); + + SetupReader(document); + + // Act + var result = Sut.GetAll(filter); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetAll(filter, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.CreateMany().ToList(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = Sut.GetAll(filter, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetAll(filter, null, token), + Times.Once); + } + + [Fact] + public void WithFilterAndPartitionKey_GetsOne() + { + // Arrange + var document = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + + SetupReader(document); + + // Act + var result = Sut.GetAll(filter, partitionKey); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetAll(filter, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndPartitionKeyAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = Sut.GetAll(filter, partitionKey, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetAll(filter, partitionKey, token), + Times.Once); + } + + private void SetupReader(List documents) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetAll( + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .Returns(documents); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByIdAsyncTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByIdAsyncTests.cs new file mode 100644 index 0000000..d51f1be --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByIdAsyncTests.cs @@ -0,0 +1,109 @@ +using System; +using System.Linq; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetByIdAsyncTests : TestKeyedReadOnlyMongoRepositoryContext +{ + [Fact] + public async Task WithId_Gets() + { + // Arrange + var document = Fixture.Create(); + + SetupReader(document); + + // Act + var result = await Sut.GetByIdAsync(document.Id); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByIdAsync(document.Id, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithIdAndCancellationToken_Gets() + { + // Arrange + var document = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = await Sut.GetByIdAsync(document.Id, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByIdAsync(document.Id, null, token), + Times.Once); + } + + [Fact] + public async Task WithIdAndPartitionKey_Gets() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(document); + + // Act + var result = await Sut.GetByIdAsync(document.Id, partitionKey); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByIdAsync(document.Id, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithIdAndPartitionKeyAndCancellationToken_Gets() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = await Sut.GetByIdAsync(document.Id, partitionKey, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByIdAsync(document.Id, partitionKey, token), + Times.Once); + } + + private void SetupReader(TestDocument document) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetByIdAsync( + It.IsAny(), + It.IsAny(), + It.IsAny())) + .ReturnsAsync(document); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByIdTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByIdTests.cs new file mode 100644 index 0000000..c7e39a3 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByIdTests.cs @@ -0,0 +1,109 @@ +using System; +using System.Linq; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetByIdTests : TestKeyedReadOnlyMongoRepositoryContext +{ + [Fact] + public void WithId_Gets() + { + // Arrange + var document = Fixture.Create(); + + SetupReader(document); + + // Act + var result = Sut.GetById(document.Id); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetById(document.Id, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithIdAndCancellationToken_Gets() + { + // Arrange + var document = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = Sut.GetById(document.Id, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetById(document.Id, null, token), + Times.Once); + } + + [Fact] + public void WithIdAndPartitionKey_Gets() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(document); + + // Act + var result = Sut.GetById(document.Id, partitionKey); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetById(document.Id, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithIdAndPartitionKeyAndCancellationToken_Gets() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = Sut.GetById(document.Id, partitionKey, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetById(document.Id, partitionKey, token), + Times.Once); + } + + private void SetupReader(TestDocument document) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetById( + It.IsAny(), + It.IsAny(), + It.IsAny())) + .Returns(document); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMaxAsyncTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMaxAsyncTests.cs new file mode 100644 index 0000000..508e637 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMaxAsyncTests.cs @@ -0,0 +1,112 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetByMaxAsyncTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + private readonly Expression> selector = document => document.SomeValue; + + [Fact] + public async Task WithFilterAndSelector_GetsOne() + { + // Arrange + var document = Fixture.Create(); + + SetupReader(document); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMaxAsync(filter, selector, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMaxAsync(filter, selector, null, token), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKey_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(document); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector, partitionKey); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMaxAsync(filter, selector, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector, partitionKey, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMaxAsync(filter, selector, partitionKey, token), + Times.Once); + } + + private void SetupReader(TestDocument document) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetByMaxAsync( + It.IsAny>>(), + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .ReturnsAsync(document); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMaxTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMaxTests.cs new file mode 100644 index 0000000..987bca6 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMaxTests.cs @@ -0,0 +1,111 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetByMaxTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + private readonly Expression> selector = document => document.SomeValue; + + [Fact] + public void WithFilterAndSelector_GetsOne() + { + // Arrange + var document = Fixture.Create(); + + SetupReader(document); + + // Act + var result = Sut.GetByMax(filter, selector); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMax(filter, selector, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = Sut.GetByMax(filter, selector, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMax(filter, selector, null, token), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndPartitionKey_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(document); + + // Act + var result = Sut.GetByMax(filter, selector, partitionKey); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMax(filter, selector, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = Sut.GetByMax(filter, selector, partitionKey, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMax(filter, selector, partitionKey, token), + Times.Once); + } + + private void SetupReader(TestDocument document) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetByMax( + It.IsAny>>(), + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .Returns(document); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMinAsyncTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMinAsyncTests.cs new file mode 100644 index 0000000..fc2e3c7 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMinAsyncTests.cs @@ -0,0 +1,112 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetByMinAsyncTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + private readonly Expression> selector = document => document.SomeValue; + + [Fact] + public async Task WithFilterAndSelector_GetsOne() + { + // Arrange + var document = Fixture.Create(); + + SetupReader(document); + + // Act + var result = await Sut.GetByMinAsync(filter, selector); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMinAsync(filter, selector, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = await Sut.GetByMinAsync(filter, selector, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMinAsync(filter, selector, null, token), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKey_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(document); + + // Act + var result = await Sut.GetByMinAsync(filter, selector, partitionKey); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMinAsync(filter, selector, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = await Sut.GetByMinAsync(filter, selector, partitionKey, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMinAsync(filter, selector, partitionKey, token), + Times.Once); + } + + private void SetupReader(TestDocument document) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetByMinAsync( + It.IsAny>>(), + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .ReturnsAsync(document); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMinTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMinTests.cs new file mode 100644 index 0000000..e3eacee --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetByMinTests.cs @@ -0,0 +1,111 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetByMinTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + private readonly Expression> selector = document => document.SomeValue; + + [Fact] + public void WithFilterAndSelector_GetsOne() + { + // Arrange + var document = Fixture.Create(); + + SetupReader(document); + + // Act + var result = Sut.GetByMin(filter, selector); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMin(filter, selector, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = Sut.GetByMin(filter, selector, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMin(filter, selector, null, token), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndPartitionKey_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(document); + + // Act + var result = Sut.GetByMin(filter, selector, partitionKey); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMin(filter, selector, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = Sut.GetByMin(filter, selector, partitionKey, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetByMin(filter, selector, partitionKey, token), + Times.Once); + } + + private void SetupReader(TestDocument document) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetByMin( + It.IsAny>>(), + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .Returns(document); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMaxValueAsyncTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMaxValueAsyncTests.cs new file mode 100644 index 0000000..f9fe0c8 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMaxValueAsyncTests.cs @@ -0,0 +1,108 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetMaxValueAsyncTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + private readonly Expression> selector = document => document.SomeValue; + + [Fact] + public async Task WithFilterAndSelector_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + + SetupReader(value); + + // Act + var result = await Sut.GetMaxValueAsync(filter, selector); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMaxValueAsync(filter, selector, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndCancellationToken_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(value); + + // Act + var result = await Sut.GetMaxValueAsync(filter, selector, token); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMaxValueAsync(filter, selector, null, token), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKey_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(value); + + // Act + var result = await Sut.GetMaxValueAsync(filter, selector, partitionKey); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMaxValueAsync(filter, selector, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(value); + + // Act + var result = await Sut.GetMaxValueAsync(filter, selector, partitionKey, token); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMaxValueAsync(filter, selector, partitionKey, token), + Times.Once); + } + + private void SetupReader(int value) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetMaxValueAsync( + It.IsAny>>(), + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .ReturnsAsync(value); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMaxValueTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMaxValueTests.cs new file mode 100644 index 0000000..06af072 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMaxValueTests.cs @@ -0,0 +1,107 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetMaxValueTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + private readonly Expression> selector = document => document.SomeValue; + + [Fact] + public void WithFilterAndSelector_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + + SetupReader(value); + + // Act + var result = Sut.GetMaxValue(filter, selector); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMaxValue(filter, selector, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndCancellationToken_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(value); + + // Act + var result = Sut.GetMaxValue(filter, selector, token); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMaxValue(filter, selector, null, token), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndPartitionKey_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(value); + + // Act + var result = Sut.GetMaxValue(filter, selector, partitionKey); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMaxValue(filter, selector, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(value); + + // Act + var result = Sut.GetMaxValue(filter, selector, partitionKey, token); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMaxValue(filter, selector, partitionKey, token), + Times.Once); + } + + private void SetupReader(int value) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetMaxValue( + It.IsAny>>(), + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .Returns(value); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMinValueAsyncTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMinValueAsyncTests.cs new file mode 100644 index 0000000..4e0cc5d --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMinValueAsyncTests.cs @@ -0,0 +1,108 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetMinValueAsyncTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + private readonly Expression> selector = document => document.SomeValue; + + [Fact] + public async Task WithFilterAndSelector_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + + SetupReader(value); + + // Act + var result = await Sut.GetMinValueAsync(filter, selector); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMinValueAsync(filter, selector, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndCancellationToken_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(value); + + // Act + var result = await Sut.GetMinValueAsync(filter, selector, token); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMinValueAsync(filter, selector, null, token), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKey_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(value); + + // Act + var result = await Sut.GetMinValueAsync(filter, selector, partitionKey); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMinValueAsync(filter, selector, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsMaxValue() + { + // Arrange + var value = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(value); + + // Act + var result = await Sut.GetMinValueAsync(filter, selector, partitionKey, token); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMinValueAsync(filter, selector, partitionKey, token), + Times.Once); + } + + private void SetupReader(int value) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetMinValueAsync( + It.IsAny>>(), + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .ReturnsAsync(value); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMinValueTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMinValueTests.cs new file mode 100644 index 0000000..5b861a6 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetMinValueTests.cs @@ -0,0 +1,107 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetMinValueTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + private readonly Expression> selector = document => document.SomeValue; + + [Fact] + public void WithFilterAndSelector_GetsMinValue() + { + // Arrange + var value = Fixture.Create(); + + SetupReader(value); + + // Act + var result = Sut.GetMinValue(filter, selector); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMinValue(filter, selector, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndCancellationToken_GetsMinValue() + { + // Arrange + var value = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(value); + + // Act + var result = Sut.GetMinValue(filter, selector, token); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMinValue(filter, selector, null, token), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndPartitionKey_GetsMinValue() + { + // Arrange + var value = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(value); + + // Act + var result = Sut.GetMinValue(filter, selector, partitionKey); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMinValue(filter, selector, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsMinValue() + { + // Arrange + var value = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(value); + + // Act + var result = Sut.GetMinValue(filter, selector, partitionKey, token); + + // Assert + result.Should().Be(value); + Reader.Verify( + x => x.GetMinValue(filter, selector, partitionKey, token), + Times.Once); + } + + private void SetupReader(int value) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetMinValue( + It.IsAny>>(), + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .Returns(value); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetOneAsyncTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetOneAsyncTests.cs new file mode 100644 index 0000000..d817465 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetOneAsyncTests.cs @@ -0,0 +1,110 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetOneAsyncTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + + [Fact] + public async Task WithId_GetsOne() + { + // Arrange + var document = Fixture.Create(); + + SetupReader(document); + + // Act + var result = await Sut.GetOneAsync(filter); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetOneAsync(filter, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithIdAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = await Sut.GetOneAsync(filter, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetOneAsync(filter, null, token), + Times.Once); + } + + [Fact] + public async Task WithIdAndPartitionKey_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(document); + + // Act + var result = await Sut.GetOneAsync(filter, partitionKey); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetOneAsync(filter, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public async Task WithIdAndPartitionKeyAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = await Sut.GetOneAsync(filter, partitionKey, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetOneAsync(filter, partitionKey, token), + Times.Once); + } + + private void SetupReader(TestDocument document) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetOneAsync( + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .ReturnsAsync(document); + } +} diff --git a/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetOneTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetOneTests.cs new file mode 100644 index 0000000..289f1d0 --- /dev/null +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetOneTests.cs @@ -0,0 +1,110 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDbGenericRepository.DataAccess.Read; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; + +public class GetOneTests : TestKeyedReadOnlyMongoRepositoryContext +{ + private readonly Expression> filter = document => document.SomeContent == "SomeContent"; + + [Fact] + public void WithId_GetsOne() + { + // Arrange + var document = Fixture.Create(); + + SetupReader(document); + + // Act + var result = Sut.GetOne(filter); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetOne(filter, null, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithIdAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = Sut.GetOne(filter, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetOne(filter, null, token), + Times.Once); + } + + [Fact] + public void WithIdAndPartitionKey_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + + SetupReader(document); + + // Act + var result = Sut.GetOne(filter, partitionKey); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetOne(filter, partitionKey, CancellationToken.None), + Times.Once); + } + + [Fact] + public void WithIdAndPartitionKeyAndCancellationToken_GetsOne() + { + // Arrange + var document = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + SetupReader(document); + + // Act + var result = Sut.GetOne(filter, partitionKey, token); + + // Assert + result.Should().NotBeNull(); + result.Should().BeEquivalentTo(document); + Reader.Verify( + x => x.GetOne(filter, partitionKey, token), + Times.Once); + } + + private void SetupReader(TestDocument document) + { + Reader = new Mock(); + Reader + .Setup( + x => x.GetOne( + It.IsAny>>(), + It.IsAny(), + It.IsAny())) + .Returns(document); + } +} diff --git a/CoreUnitTests/ReadOnlyMongoRepositoryTests/GetSortedPaginatedAsyncTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetSortedPaginatedAsyncTests.cs similarity index 99% rename from CoreUnitTests/ReadOnlyMongoRepositoryTests/GetSortedPaginatedAsyncTests.cs rename to CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetSortedPaginatedAsyncTests.cs index 3fe29a1..1b199c8 100644 --- a/CoreUnitTests/ReadOnlyMongoRepositoryTests/GetSortedPaginatedAsyncTests.cs +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GetSortedPaginatedAsyncTests.cs @@ -13,7 +13,7 @@ using MongoDbGenericRepository.DataAccess.Read; using Moq; using Xunit; -namespace CoreUnitTests.ReadOnlyMongoRepositoryTests; +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; public class GetSortedPaginatedAsyncTests : TestKeyedReadOnlyMongoRepositoryContext { diff --git a/CoreUnitTests/ReadOnlyMongoRepositoryTests/GroupByTests.cs b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GroupByTests.cs similarity index 99% rename from CoreUnitTests/ReadOnlyMongoRepositoryTests/GroupByTests.cs rename to CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GroupByTests.cs index abbdca7..018c4bc 100644 --- a/CoreUnitTests/ReadOnlyMongoRepositoryTests/GroupByTests.cs +++ b/CoreUnitTests/KeyedReadOnlyMongoRepositoryTests/GroupByTests.cs @@ -10,7 +10,7 @@ using MongoDbGenericRepository.DataAccess.Read; using Moq; using Xunit; -namespace CoreUnitTests.ReadOnlyMongoRepositoryTests; +namespace CoreUnitTests.KeyedReadOnlyMongoRepositoryTests; public class GroupByTests : TestKeyedReadOnlyMongoRepositoryContext { diff --git a/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.ReadOnly.cs b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.ReadOnly.cs index 8cbe59a..4e5c741 100644 --- a/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.ReadOnly.cs +++ b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.ReadOnly.cs @@ -594,7 +594,7 @@ namespace MongoDbGenericRepository CancellationToken cancellationToken) where TDocument : IDocument { - return MongoDbReader.GetByMax(filter, maxValueSelector, partitionKey); + return MongoDbReader.GetByMax(filter, maxValueSelector, partitionKey, cancellationToken); } ///