From 06991307338a2768a3e29b349a8d3d06e7aed328 Mon Sep 17 00:00:00 2001 From: Sean Garrett Date: Sun, 25 Jun 2023 21:12:52 +0100 Subject: [PATCH] Reader GetAll, GetByMin and getByMax test --- .../MongoDbReaderTests/GetAllAsyncTests.cs | 283 ++++++++++++++++++ .../MongoDbReaderTests/GetAllTests.cs | 283 ++++++++++++++++++ .../MongoDbReaderTests/GetByMaxAsyncTests.cs | 115 +++++++ .../MongoDbReaderTests/GetByMaxTests.cs | 119 ++++++++ .../MongoDbReaderTests/GetByMinAsyncTests.cs | 119 ++++++++ .../MongoDbReaderTests/GetByMinTests.cs | 119 ++++++++ 6 files changed, 1038 insertions(+) create mode 100644 CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllAsyncTests.cs create mode 100644 CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllTests.cs create mode 100644 CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxAsyncTests.cs create mode 100644 CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxTests.cs create mode 100644 CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinAsyncTests.cs create mode 100644 CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinTests.cs diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllAsyncTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllAsyncTests.cs new file mode 100644 index 0000000..51818de --- /dev/null +++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllAsyncTests.cs @@ -0,0 +1,283 @@ +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.Model; +using FluentAssertions; +using MongoDB.Driver; +using MongoDbGenericRepository; +using Moq; +using Xunit; + +namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests; + +public class GetOneAsyncTests : BaseReaderTests +{ + [Fact] + public async Task WithFilter_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + Expression> filter = x => x.Id == documents[0].Id; + var (context, cursor) = SetupAsyncGet(documents, collection); + + + // Act + var result = await Sut.GetOneAsync(filter); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithFilterAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var token = new CancellationToken(true); + Expression> filter = x => x.Id == documents[0].Id; + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetOneAsync(filter, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithFilterAndPartitionKey_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + Expression> filter = x => x.Id == documents[0].Id; + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetOneAsync(filter, partitionKey); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithFilterAndPartitionKeyAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + Expression> filter = x => x.Id == documents[0].Id; + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetOneAsync(filter, partitionKey, token); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithCondition_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetOneAsync(condition); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithConditionAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var token = new CancellationToken(true); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetOneAsync(condition, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithConditionAndPartitionKey_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var partitionKey = Fixture.Create(); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetOneAsync(condition, partitionKey: partitionKey); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithConditionAndPartitionKeyAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetOneAsync(condition, partitionKey: partitionKey, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithConditionAndFindOptions_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var options = Fixture + .Build() + .Without(x => x.Comment) + .Without(x => x.Hint) + .Create(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetOneAsync(condition, options); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithConditionAndFindOptionsAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var options = Fixture + .Build() + .Without(x => x.Comment) + .Without(x => x.Hint) + .Create(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var token = new CancellationToken(true); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetOneAsync(condition, options, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithConditionAndFindOptionsAndPartitionKeyAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var options = Fixture + .Build() + .Without(x => x.Comment) + .Without(x => x.Hint) + .Create(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var token = new CancellationToken(true); + var partitionKey = Fixture.Create(); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetOneAsync(condition, options, partitionKey, token); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + private (Mock, Mock>) SetupAsyncGet( + List documents, + Mock> collection, + string partitionKey = null) + { + var asyncCursor = SetupAsyncCursor(documents); + + SetupFindAsync(collection, asyncCursor); + + var context = MockOf(); + + context + .Setup(x => x.GetCollection(partitionKey)) + .Returns(collection.Object); + + return (context, asyncCursor); + } +} diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllTests.cs new file mode 100644 index 0000000..db168c5 --- /dev/null +++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllTests.cs @@ -0,0 +1,283 @@ +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.Model; +using FluentAssertions; +using MongoDB.Driver; +using MongoDbGenericRepository; +using Moq; +using Xunit; + +namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests; + +public class GetAllAsyncTests : BaseReaderTests +{ + [Fact] + public async Task WithFilter_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + Expression> filter = x => x.Id == documents[0].Id; + var (context, cursor) = SetupAsyncGet(documents, collection); + + + // Act + var result = await Sut.GetAllAsync(filter); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Exactly(documents.Count)); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Exactly(documents.Count + 1)); + result.Should().NotBeNull(); + result.Should().OnlyContain(x => documents.Contains(x)); + } + + [Fact] + public async Task WithFilterAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var token = new CancellationToken(false); + Expression> filter = x => x.Id == documents[0].Id; + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetAllAsync(filter, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Exactly(documents.Count)); + cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1)); + result.Should().NotBeNull(); + result.Should().OnlyContain(x => documents.Contains(x)); + } + + [Fact] + public async Task WithFilterAndPartitionKey_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + Expression> filter = x => x.Id == documents[0].Id; + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetAllAsync(filter, partitionKey); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Exactly(documents.Count)); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Exactly(documents.Count + 1)); + result.Should().NotBeNull(); + result.Should().OnlyContain(x => documents.Contains(x)); + } + + [Fact] + public async Task WithFilterAndPartitionKeyAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(false); + Expression> filter = x => x.Id == documents[0].Id; + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetAllAsync(filter, partitionKey, token); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Exactly(documents.Count)); + cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1)); + result.Should().NotBeNull(); + result.Should().OnlyContain(x => documents.Contains(x)); + } + + [Fact] + public async Task WithCondition_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetAllAsync(condition); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Exactly(documents.Count)); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Exactly(documents.Count + 1)); + result.Should().NotBeNull(); + result.Should().OnlyContain(x => documents.Contains(x)); + } + + [Fact] + public async Task WithConditionAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var token = new CancellationToken(false); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetAllAsync(condition, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Exactly(documents.Count)); + cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1)); + result.Should().NotBeNull(); + result.Should().OnlyContain(x => documents.Contains(x)); + } + + [Fact] + public async Task WithConditionAndPartitionKey_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var partitionKey = Fixture.Create(); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetAllAsync(condition, partitionKey: partitionKey); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Exactly(documents.Count + 1)); + cursor.Verify(x => x.Current, Times.Exactly(documents.Count)); + result.Should().NotBeNull(); + result.Should().OnlyContain(x => documents.Contains(x)); + } + + [Fact] + public async Task WithConditionAndPartitionKeyAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(false); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetAllAsync(condition, partitionKey: partitionKey, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Exactly(documents.Count)); + cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1)); + result.Should().NotBeNull(); + result.Should().OnlyContain(x => documents.Contains(x)); + } + + [Fact] + public async Task WithConditionAndFindOptions_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var options = Fixture + .Build() + .Without(x => x.Comment) + .Without(x => x.Hint) + .Create(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetAllAsync(condition, options); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Exactly(documents.Count)); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Exactly(documents.Count + 1)); + result.Should().NotBeNull(); + result.Should().OnlyContain(x => documents.Contains(x)); + } + + [Fact] + public async Task WithConditionAndFindOptionsAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var options = Fixture + .Build() + .Without(x => x.Comment) + .Without(x => x.Hint) + .Create(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var token = new CancellationToken(false); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetAllAsync(condition, options, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Exactly(documents.Count)); + cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1)); + result.Should().NotBeNull(); + result.Should().OnlyContain(x => documents.Contains(x)); + } + + [Fact] + public async Task WithConditionAndFindOptionsAndPartitionKeyAndCancellationToken_GetsMatchingDocuments() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var options = Fixture + .Build() + .Without(x => x.Comment) + .Without(x => x.Hint) + .Create(); + var condition = Builders.Filter.Eq("Id", documents[0].Id); + var token = new CancellationToken(false); + var partitionKey = Fixture.Create(); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetAllAsync(condition, options, partitionKey, token); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Exactly(documents.Count)); + cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1)); + result.Should().NotBeNull(); + result.Should().OnlyContain(x => documents.Contains(x)); + } + + private (Mock, Mock>) SetupAsyncGet( + List documents, + Mock> collection, + string partitionKey = null) + { + var asyncCursor = SetupAsyncCursor(documents); + + SetupFindAsync(collection, asyncCursor); + + var context = MockOf(); + + context + .Setup(x => x.GetCollection(partitionKey)) + .Returns(collection.Object); + + return (context, asyncCursor); + } +} diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxAsyncTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxAsyncTests.cs new file mode 100644 index 0000000..d9af227 --- /dev/null +++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxAsyncTests.cs @@ -0,0 +1,115 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure.Model; +using FluentAssertions; +using MongoDB.Driver; +using MongoDbGenericRepository; +using Moq; +using Xunit; + +namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests; + +public class GetByIdAsyncTests : BaseReaderTests +{ + [Fact] + public async Task WithId_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetByIdAsync(documents[0].Id); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithIdAndCancellationToken_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var token = new CancellationToken(true); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetByIdAsync(documents[0].Id, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithIdAndPartitionKey_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetByIdAsync(documents[0].Id, partitionKey); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithIdAndPartitionKeyAndCancellationToken_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetByIdAsync(documents[0].Id, partitionKey, token); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + private (Mock, Mock>) SetupAsyncGet( + List documents, + Mock> collection, + string partitionKey = null) + { + var asyncCursor = SetupAsyncCursor(documents); + + SetupFindAsync(collection, asyncCursor); + + var context = MockOf(); + + context + .Setup(x => x.GetCollection(partitionKey)) + .Returns(collection.Object); + + return (context, asyncCursor); + } +} diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxTests.cs new file mode 100644 index 0000000..000ea7b --- /dev/null +++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxTests.cs @@ -0,0 +1,119 @@ +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.Model; +using FluentAssertions; +using MongoDB.Driver; +using MongoDbGenericRepository; +using Moq; +using Xunit; + +namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests; + +public class GetByMaxAsyncTests : BaseReaderTests +{ + private readonly Expression> filter = x => x.SomeContent == "SomeContent"; + private readonly Expression> selector = x => x.SomeValue; + + [Fact] + public async Task WithFilterAndSelector_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithFilterAndSelectorAndCancellationToken_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var token = new CancellationToken(true); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKey_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector, partitionKey); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector, partitionKey, token); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + private (Mock, Mock>) SetupAsyncGet( + List documents, + Mock> collection, + string partitionKey = null) + { + var asyncCursor = SetupAsyncCursor(documents); + + SetupFindAsync(collection, asyncCursor); + + var context = MockOf(); + + context + .Setup(x => x.GetCollection(partitionKey)) + .Returns(collection.Object); + + return (context, asyncCursor); + } +} diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinAsyncTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinAsyncTests.cs new file mode 100644 index 0000000..000ea7b --- /dev/null +++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinAsyncTests.cs @@ -0,0 +1,119 @@ +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.Model; +using FluentAssertions; +using MongoDB.Driver; +using MongoDbGenericRepository; +using Moq; +using Xunit; + +namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests; + +public class GetByMaxAsyncTests : BaseReaderTests +{ + private readonly Expression> filter = x => x.SomeContent == "SomeContent"; + private readonly Expression> selector = x => x.SomeValue; + + [Fact] + public async Task WithFilterAndSelector_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithFilterAndSelectorAndCancellationToken_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var token = new CancellationToken(true); + var (context, cursor) = SetupAsyncGet(documents, collection); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKey_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector, partitionKey); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public async Task WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey); + + // Act + var result = await Sut.GetByMaxAsync(filter, selector, partitionKey, token); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNextAsync(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + private (Mock, Mock>) SetupAsyncGet( + List documents, + Mock> collection, + string partitionKey = null) + { + var asyncCursor = SetupAsyncCursor(documents); + + SetupFindAsync(collection, asyncCursor); + + var context = MockOf(); + + context + .Setup(x => x.GetCollection(partitionKey)) + .Returns(collection.Object); + + return (context, asyncCursor); + } +} diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinTests.cs new file mode 100644 index 0000000..500afc2 --- /dev/null +++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinTests.cs @@ -0,0 +1,119 @@ +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.Model; +using FluentAssertions; +using MongoDB.Driver; +using MongoDbGenericRepository; +using Moq; +using Xunit; + +namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests; + +public class GetByMaxTests : BaseReaderTests +{ + private readonly Expression> filter = x => x.SomeContent == "SomeContent"; + private readonly Expression> selector = x => x.SomeValue; + + [Fact] + public void WithFilterAndSelector_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var (context, cursor) = SetupSyncGet(documents, collection); + + // Act + var result = Sut.GetByMax(filter, selector); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNext(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public void WithFilterAndSelectorAndCancellationToken_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var token = new CancellationToken(true); + var (context, cursor) = SetupSyncGet(documents, collection); + + // Act + var result = Sut.GetByMax(filter, selector, cancellationToken: token); + + // Assert + context.Verify(x => x.GetCollection(null), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNext(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public void WithFilterAndSelectorAndPartitionKey_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var (context, cursor) = SetupSyncGet(documents, collection, partitionKey); + + // Act + var result = Sut.GetByMax(filter, selector, partitionKey); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNext(CancellationToken.None), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + [Fact] + public void WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsMatchingDocument() + { + // Arrange + var collection = MockOf>(); + var documents = Fixture.CreateMany().ToList(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + var (context, cursor) = SetupSyncGet(documents, collection, partitionKey); + + // Act + var result = Sut.GetByMax(filter, selector, partitionKey, token); + + // Assert + context.Verify(x => x.GetCollection(partitionKey), Times.Once); + cursor.Verify(x => x.Current, Times.Once); + cursor.Verify(x => x.MoveNext(token), Times.Once); + result.Should().NotBeNull(); + result.Should().Be(documents[0]); + } + + private (Mock, Mock>) SetupSyncGet( + List documents, + Mock> collection, + string partitionKey = null) + { + var asyncCursor = SetupSyncCursor(documents); + + SetupFindSync(collection, asyncCursor); + + var context = MockOf(); + + context + .Setup(x => x.GetCollection(partitionKey)) + .Returns(collection.Object); + + return (context, asyncCursor); + } +}