UltimateCoder/mongodb-generic-repository
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Reader GetAll, GetByMin and getByMax test

Browse Source
This commit is contained in:
Sean Garrett
2023-06-25 21:13:17 +01:00
parent 0699130733
commit f7ba046f20
6 changed files with 142 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllAsyncTests.cs
+51 -51
View File
@@ -14,7 +14,7 @@ using Xunit;
namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests;
public class GetOneAsyncTests : BaseReaderTests
public class GetAllAsyncTests : BaseReaderTests
{
[Fact]
public async Task WithFilter_GetsMatchingDocuments()
@@ -27,14 +27,14 @@ public class GetOneAsyncTests : BaseReaderTests
// Act
var result = await Sut.GetOneAsync<TestDocument, Guid>(filter);
var result = await Sut.GetAllAsync<TestDocument, Guid>(filter);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), 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().Be(documents[0]);
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
@@ -43,19 +43,19 @@ public class GetOneAsyncTests : BaseReaderTests
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var token = new CancellationToken(true);
var token = new CancellationToken(false);
Expression<Func<TestDocument, bool>> filter = x => x.Id == documents[0].Id;
var (context, cursor) = SetupAsyncGet(documents, collection);
// Act
var result = await Sut.GetOneAsync<TestDocument, Guid>(filter, cancellationToken: token);
var result = await Sut.GetAllAsync<TestDocument, Guid>(filter, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(token), 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().Be(documents[0]);
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
@@ -69,14 +69,14 @@ public class GetOneAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetOneAsync<TestDocument, Guid>(filter, partitionKey);
var result = await Sut.GetAllAsync<TestDocument, Guid>(filter, partitionKey);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), 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().Be(documents[0]);
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
@@ -86,19 +86,19 @@ public class GetOneAsyncTests : BaseReaderTests
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var partitionKey = Fixture.Create<string>();
var token = new CancellationToken(true);
var token = new CancellationToken(false);
Expression<Func<TestDocument, bool>> filter = x => x.Id == documents[0].Id;
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetOneAsync<TestDocument, Guid>(filter, partitionKey, token);
var result = await Sut.GetAllAsync<TestDocument, Guid>(filter, partitionKey, token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(token), 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().Be(documents[0]);
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
@@ -111,14 +111,14 @@ public class GetOneAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection);
// Act
var result = await Sut.GetOneAsync<TestDocument, Guid>(condition);
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), 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().Be(documents[0]);
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
@@ -128,18 +128,18 @@ public class GetOneAsyncTests : BaseReaderTests
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var condition = Builders<TestDocument>.Filter.Eq("Id", documents[0].Id);
var token = new CancellationToken(true);
var token = new CancellationToken(false);
var (context, cursor) = SetupAsyncGet(documents, collection);
// Act
var result = await Sut.GetOneAsync<TestDocument, Guid>(condition, cancellationToken: token);
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(token), 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().Be(documents[0]);
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
@@ -153,14 +153,14 @@ public class GetOneAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetOneAsync<TestDocument, Guid>(condition, partitionKey: partitionKey);
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, partitionKey: partitionKey);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once);
cursor.Verify(x => x.Current, 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().Be(documents[0]);
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
@@ -171,18 +171,18 @@ public class GetOneAsyncTests : BaseReaderTests
var documents = Fixture.CreateMany<TestDocument>().ToList();
var condition = Builders<TestDocument>.Filter.Eq("Id", documents[0].Id);
var partitionKey = Fixture.Create<string>();
var token = new CancellationToken(true);
var token = new CancellationToken(false);
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetOneAsync<TestDocument, Guid>(condition, partitionKey: partitionKey, cancellationToken: token);
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, partitionKey: partitionKey, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(token), 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().Be(documents[0]);
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
@@ -200,14 +200,14 @@ public class GetOneAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection);
// Act
var result = await Sut.GetOneAsync<TestDocument, Guid>(condition, options);
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, options);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), 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().Be(documents[0]);
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
@@ -222,18 +222,18 @@ public class GetOneAsyncTests : BaseReaderTests
.Without(x => x.Hint)
.Create();
var condition = Builders<TestDocument>.Filter.Eq("Id", documents[0].Id);
var token = new CancellationToken(true);
var token = new CancellationToken(false);
var (context, cursor) = SetupAsyncGet(documents, collection);
// Act
var result = await Sut.GetOneAsync<TestDocument, Guid>(condition, options, cancellationToken: token);
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, options, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(token), 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().Be(documents[0]);
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
@@ -248,19 +248,19 @@ public class GetOneAsyncTests : BaseReaderTests
.Without(x => x.Hint)
.Create();
var condition = Builders<TestDocument>.Filter.Eq("Id", documents[0].Id);
var token = new CancellationToken(true);
var token = new CancellationToken(false);
var partitionKey = Fixture.Create<string>();
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetOneAsync<TestDocument, Guid>(condition, options, partitionKey, token);
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, options, partitionKey, token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(token), 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().Be(documents[0]);
result.Should().OnlyContain(x => documents.Contains(x));
}
private (Mock<IMongoDbContext>, Mock<IAsyncCursor<TDocument>>) SetupAsyncGet<TDocument>(
CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllTests.cs
+48 -49
View File
@@ -3,7 +3,6 @@ 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;
@@ -14,73 +13,73 @@ using Xunit;
namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests;
public class GetAllAsyncTests : BaseReaderTests
public class GetAllTests : BaseReaderTests
{
[Fact]
public async Task WithFilter_GetsMatchingDocuments()
public void WithFilter_GetsMatchingDocuments()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
Expression<Func<TestDocument, bool>> filter = x => x.Id == documents[0].Id;
var (context, cursor) = SetupAsyncGet(documents, collection);
var (context, cursor) = SetupGet(documents, collection);
// Act
var result = await Sut.GetAllAsync<TestDocument, Guid>(filter);
var result = Sut.GetAll<TestDocument, Guid>(filter);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Exactly(documents.Count));
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Exactly(documents.Count + 1));
cursor.Verify(x => x.MoveNext(CancellationToken.None), Times.Exactly(documents.Count + 1));
result.Should().NotBeNull();
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
public async Task WithFilterAndCancellationToken_GetsMatchingDocuments()
public void WithFilterAndCancellationToken_GetsMatchingDocuments()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var token = new CancellationToken(false);
Expression<Func<TestDocument, bool>> filter = x => x.Id == documents[0].Id;
var (context, cursor) = SetupAsyncGet(documents, collection);
var (context, cursor) = SetupGet(documents, collection);
// Act
var result = await Sut.GetAllAsync<TestDocument, Guid>(filter, cancellationToken: token);
var result = Sut.GetAll<TestDocument, Guid>(filter, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Exactly(documents.Count));
cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1));
cursor.Verify(x => x.MoveNext(token), Times.Exactly(documents.Count + 1));
result.Should().NotBeNull();
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
public async Task WithFilterAndPartitionKey_GetsMatchingDocuments()
public void WithFilterAndPartitionKey_GetsMatchingDocuments()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var partitionKey = Fixture.Create<string>();
Expression<Func<TestDocument, bool>> filter = x => x.Id == documents[0].Id;
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
var (context, cursor) = SetupGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetAllAsync<TestDocument, Guid>(filter, partitionKey);
var result = Sut.GetAll<TestDocument, Guid>(filter, partitionKey);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.Current, Times.Exactly(documents.Count));
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Exactly(documents.Count + 1));
cursor.Verify(x => x.MoveNext(CancellationToken.None), Times.Exactly(documents.Count + 1));
result.Should().NotBeNull();
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
public async Task WithFilterAndPartitionKeyAndCancellationToken_GetsMatchingDocuments()
public void WithFilterAndPartitionKeyAndCancellationToken_GetsMatchingDocuments()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
@@ -88,83 +87,83 @@ public class GetAllAsyncTests : BaseReaderTests
var partitionKey = Fixture.Create<string>();
var token = new CancellationToken(false);
Expression<Func<TestDocument, bool>> filter = x => x.Id == documents[0].Id;
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
var (context, cursor) = SetupGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetAllAsync<TestDocument, Guid>(filter, partitionKey, token);
var result = Sut.GetAll<TestDocument, Guid>(filter, partitionKey, token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.Current, Times.Exactly(documents.Count));
cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1));
cursor.Verify(x => x.MoveNext(token), Times.Exactly(documents.Count + 1));
result.Should().NotBeNull();
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
public async Task WithCondition_GetsMatchingDocuments()
public void WithCondition_GetsMatchingDocuments()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var condition = Builders<TestDocument>.Filter.Eq("Id", documents[0].Id);
var (context, cursor) = SetupAsyncGet(documents, collection);
var (context, cursor) = SetupGet(documents, collection);
// Act
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition);
var result = Sut.GetAll<TestDocument, Guid>(condition);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Exactly(documents.Count));
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Exactly(documents.Count + 1));
cursor.Verify(x => x.MoveNext(CancellationToken.None), Times.Exactly(documents.Count + 1));
result.Should().NotBeNull();
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
public async Task WithConditionAndCancellationToken_GetsMatchingDocuments()
public void WithConditionAndCancellationToken_GetsMatchingDocuments()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var condition = Builders<TestDocument>.Filter.Eq("Id", documents[0].Id);
var token = new CancellationToken(false);
var (context, cursor) = SetupAsyncGet(documents, collection);
var (context, cursor) = SetupGet(documents, collection);
// Act
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, cancellationToken: token);
var result = Sut.GetAll<TestDocument, Guid>(condition, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Exactly(documents.Count));
cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1));
cursor.Verify(x => x.MoveNext(token), Times.Exactly(documents.Count + 1));
result.Should().NotBeNull();
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
public async Task WithConditionAndPartitionKey_GetsMatchingDocuments()
public void WithConditionAndPartitionKey_GetsMatchingDocuments()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var condition = Builders<TestDocument>.Filter.Eq("Id", documents[0].Id);
var partitionKey = Fixture.Create<string>();
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
var (context, cursor) = SetupGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, partitionKey: partitionKey);
var result = Sut.GetAll<TestDocument, Guid>(condition, partitionKey: partitionKey);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Exactly(documents.Count + 1));
cursor.Verify(x => x.MoveNext(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()
public void WithConditionAndPartitionKeyAndCancellationToken_GetsMatchingDocuments()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
@@ -172,21 +171,21 @@ public class GetAllAsyncTests : BaseReaderTests
var condition = Builders<TestDocument>.Filter.Eq("Id", documents[0].Id);
var partitionKey = Fixture.Create<string>();
var token = new CancellationToken(false);
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
var (context, cursor) = SetupGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, partitionKey: partitionKey, cancellationToken: token);
var result = Sut.GetAll<TestDocument, Guid>(condition, partitionKey: partitionKey, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.Current, Times.Exactly(documents.Count));
cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1));
cursor.Verify(x => x.MoveNext(token), Times.Exactly(documents.Count + 1));
result.Should().NotBeNull();
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
public async Task WithConditionAndFindOptions_GetsMatchingDocuments()
public void WithConditionAndFindOptions_GetsMatchingDocuments()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
@@ -197,21 +196,21 @@ public class GetAllAsyncTests : BaseReaderTests
.Without(x => x.Hint)
.Create();
var condition = Builders<TestDocument>.Filter.Eq("Id", documents[0].Id);
var (context, cursor) = SetupAsyncGet(documents, collection);
var (context, cursor) = SetupGet(documents, collection);
// Act
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, options);
var result = Sut.GetAll<TestDocument, Guid>(condition, options);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Exactly(documents.Count));
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Exactly(documents.Count + 1));
cursor.Verify(x => x.MoveNext(CancellationToken.None), Times.Exactly(documents.Count + 1));
result.Should().NotBeNull();
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
public async Task WithConditionAndFindOptionsAndCancellationToken_GetsMatchingDocuments()
public void WithConditionAndFindOptionsAndCancellationToken_GetsMatchingDocuments()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
@@ -223,21 +222,21 @@ public class GetAllAsyncTests : BaseReaderTests
.Create();
var condition = Builders<TestDocument>.Filter.Eq("Id", documents[0].Id);
var token = new CancellationToken(false);
var (context, cursor) = SetupAsyncGet(documents, collection);
var (context, cursor) = SetupGet(documents, collection);
// Act
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, options, cancellationToken: token);
var result = Sut.GetAll<TestDocument, Guid>(condition, options, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Exactly(documents.Count));
cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1));
cursor.Verify(x => x.MoveNext(token), Times.Exactly(documents.Count + 1));
result.Should().NotBeNull();
result.Should().OnlyContain(x => documents.Contains(x));
}
[Fact]
public async Task WithConditionAndFindOptionsAndPartitionKeyAndCancellationToken_GetsMatchingDocuments()
public void WithConditionAndFindOptionsAndPartitionKeyAndCancellationToken_GetsMatchingDocuments()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
@@ -250,27 +249,27 @@ public class GetAllAsyncTests : BaseReaderTests
var condition = Builders<TestDocument>.Filter.Eq("Id", documents[0].Id);
var token = new CancellationToken(false);
var partitionKey = Fixture.Create<string>();
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
var (context, cursor) = SetupGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetAllAsync<TestDocument, Guid>(condition, options, partitionKey, token);
var result = Sut.GetAll<TestDocument, Guid>(condition, options, partitionKey, token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.Current, Times.Exactly(documents.Count));
cursor.Verify(x => x.MoveNextAsync(token), Times.Exactly(documents.Count + 1));
cursor.Verify(x => x.MoveNext(token), Times.Exactly(documents.Count + 1));
result.Should().NotBeNull();
result.Should().OnlyContain(x => documents.Contains(x));
}
private (Mock<IMongoDbContext>, Mock<IAsyncCursor<TDocument>>) SetupAsyncGet<TDocument>(
private (Mock<IMongoDbContext>, Mock<IAsyncCursor<TDocument>>) SetupGet<TDocument>(
List<TDocument> documents,
Mock<IMongoCollection<TDocument>> collection,
string partitionKey = null)
{
var asyncCursor = SetupAsyncCursor(documents);
var asyncCursor = SetupSyncCursor(documents);
SetupFindAsync(collection, asyncCursor);
SetupFindSync(collection, asyncCursor);
var context = MockOf<IMongoDbContext>();
CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxAsyncTests.cs
+13 -9
View File
@@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks;
using AutoFixture;
@@ -13,10 +14,13 @@ using Xunit;
namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests;
public class GetByIdAsyncTests : BaseReaderTests
public class GetByMaxAsyncTests : BaseReaderTests
{
private readonly Expression<Func<TestDocument, bool>> filter = x => x.SomeContent == "SomeContent";
private readonly Expression<Func<TestDocument, object>> selector = x => x.SomeValue;
[Fact]
public async Task WithId_GetsMatchingDocument()
public async Task WithFilterAndSelector_GetsMatchingDocument()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
@@ -24,7 +28,7 @@ public class GetByIdAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection);
// Act
var result = await Sut.GetByIdAsync<TestDocument, Guid>(documents[0].Id);
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
@@ -35,7 +39,7 @@ public class GetByIdAsyncTests : BaseReaderTests
}
[Fact]
public async Task WithIdAndCancellationToken_GetsMatchingDocument()
public async Task WithFilterAndSelectorAndCancellationToken_GetsMatchingDocument()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
@@ -44,7 +48,7 @@ public class GetByIdAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection);
// Act
var result = await Sut.GetByIdAsync<TestDocument, Guid>(documents[0].Id, cancellationToken: token);
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
@@ -55,7 +59,7 @@ public class GetByIdAsyncTests : BaseReaderTests
}
[Fact]
public async Task WithIdAndPartitionKey_GetsMatchingDocument()
public async Task WithFilterAndSelectorAndPartitionKey_GetsMatchingDocument()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
@@ -64,7 +68,7 @@ public class GetByIdAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetByIdAsync<TestDocument, Guid>(documents[0].Id, partitionKey);
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector, partitionKey);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
@@ -75,7 +79,7 @@ public class GetByIdAsyncTests : BaseReaderTests
}
[Fact]
public async Task WithIdAndPartitionKeyAndCancellationToken_GetsMatchingDocument()
public async Task WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsMatchingDocument()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
@@ -85,7 +89,7 @@ public class GetByIdAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetByIdAsync<TestDocument, Guid>(documents[0].Id, partitionKey, token);
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector, partitionKey, token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxTests.cs
+20 -20
View File
@@ -14,99 +14,99 @@ using Xunit;
namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests;
public class GetByMaxAsyncTests : BaseReaderTests
public class GetByMaxTests : BaseReaderTests
{
private readonly Expression<Func<TestDocument, bool>> filter = x => x.SomeContent == "SomeContent";
private readonly Expression<Func<TestDocument, object>> selector = x => x.SomeValue;
[Fact]
public async Task WithFilterAndSelector_GetsMatchingDocument()
public void WithFilterAndSelector_GetsMatchingDocument()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var (context, cursor) = SetupAsyncGet(documents, collection);
var (context, cursor) = SetupSyncGet(documents, collection);
// Act
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector);
var result = Sut.GetByMax<TestDocument, Guid>(filter, selector);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once);
cursor.Verify(x => x.MoveNext(CancellationToken.None), Times.Once);
result.Should().NotBeNull();
result.Should().Be(documents[0]);
}
[Fact]
public async Task WithFilterAndSelectorAndCancellationToken_GetsMatchingDocument()
public void WithFilterAndSelectorAndCancellationToken_GetsMatchingDocument()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var token = new CancellationToken(true);
var (context, cursor) = SetupAsyncGet(documents, collection);
var (context, cursor) = SetupSyncGet(documents, collection);
// Act
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector, cancellationToken: token);
var result = Sut.GetByMax<TestDocument, Guid>(filter, selector, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(token), Times.Once);
cursor.Verify(x => x.MoveNext(token), Times.Once);
result.Should().NotBeNull();
result.Should().Be(documents[0]);
}
[Fact]
public async Task WithFilterAndSelectorAndPartitionKey_GetsMatchingDocument()
public void WithFilterAndSelectorAndPartitionKey_GetsMatchingDocument()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var partitionKey = Fixture.Create<string>();
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
var (context, cursor) = SetupSyncGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector, partitionKey);
var result = Sut.GetByMax<TestDocument, Guid>(filter, selector, partitionKey);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(CancellationToken.None), Times.Once);
cursor.Verify(x => x.MoveNext(CancellationToken.None), Times.Once);
result.Should().NotBeNull();
result.Should().Be(documents[0]);
}
[Fact]
public async Task WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsMatchingDocument()
public void WithFilterAndSelectorAndPartitionKeyAndCancellationToken_GetsMatchingDocument()
{
// Arrange
var collection = MockOf<IMongoCollection<TestDocument>>();
var documents = Fixture.CreateMany<TestDocument>().ToList();
var partitionKey = Fixture.Create<string>();
var token = new CancellationToken(true);
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
var (context, cursor) = SetupSyncGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector, partitionKey, token);
var result = Sut.GetByMax<TestDocument, Guid>(filter, selector, partitionKey, token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
cursor.Verify(x => x.Current, Times.Once);
cursor.Verify(x => x.MoveNextAsync(token), Times.Once);
cursor.Verify(x => x.MoveNext(token), Times.Once);
result.Should().NotBeNull();
result.Should().Be(documents[0]);
}
private (Mock<IMongoDbContext>, Mock<IAsyncCursor<TDocument>>) SetupAsyncGet<TDocument>(
private (Mock<IMongoDbContext>, Mock<IAsyncCursor<TDocument>>) SetupSyncGet<TDocument>(
List<TDocument> documents,
Mock<IMongoCollection<TDocument>> collection,
string partitionKey = null)
{
var asyncCursor = SetupAsyncCursor(documents);
var asyncCursor = SetupSyncCursor(documents);
SetupFindAsync(collection, asyncCursor);
SetupFindSync(collection, asyncCursor);
var context = MockOf<IMongoDbContext>();
CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinAsyncTests.cs
+5 -5
View File
@@ -14,7 +14,7 @@ using Xunit;
namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests;
public class GetByMaxAsyncTests : BaseReaderTests
public class GetByMinAsyncTests : BaseReaderTests
{
private readonly Expression<Func<TestDocument, bool>> filter = x => x.SomeContent == "SomeContent";
private readonly Expression<Func<TestDocument, object>> selector = x => x.SomeValue;
@@ -28,7 +28,7 @@ public class GetByMaxAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection);
// Act
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector);
var result = await Sut.GetByMinAsync<TestDocument, Guid>(filter, selector);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
@@ -48,7 +48,7 @@ public class GetByMaxAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection);
// Act
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector, cancellationToken: token);
var result = await Sut.GetByMinAsync<TestDocument, Guid>(filter, selector, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
@@ -68,7 +68,7 @@ public class GetByMaxAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector, partitionKey);
var result = await Sut.GetByMinAsync<TestDocument, Guid>(filter, selector, partitionKey);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
@@ -89,7 +89,7 @@ public class GetByMaxAsyncTests : BaseReaderTests
var (context, cursor) = SetupAsyncGet(documents, collection, partitionKey);
// Act
var result = await Sut.GetByMaxAsync<TestDocument, Guid>(filter, selector, partitionKey, token);
var result = await Sut.GetByMinAsync<TestDocument, Guid>(filter, selector, partitionKey, token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinTests.cs
+5 -5
View File
@@ -14,7 +14,7 @@ using Xunit;
namespace CoreUnitTests.DataAccessTests.MongoDbReaderTests;
public class GetByMaxTests : BaseReaderTests
public class GetByMinTests : BaseReaderTests
{
private readonly Expression<Func<TestDocument, bool>> filter = x => x.SomeContent == "SomeContent";
private readonly Expression<Func<TestDocument, object>> selector = x => x.SomeValue;
@@ -28,7 +28,7 @@ public class GetByMaxTests : BaseReaderTests
var (context, cursor) = SetupSyncGet(documents, collection);
// Act
var result = Sut.GetByMax<TestDocument, Guid>(filter, selector);
var result = Sut.GetByMin<TestDocument, Guid>(filter, selector);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
@@ -48,7 +48,7 @@ public class GetByMaxTests : BaseReaderTests
var (context, cursor) = SetupSyncGet(documents, collection);
// Act
var result = Sut.GetByMax<TestDocument, Guid>(filter, selector, cancellationToken: token);
var result = Sut.GetByMin<TestDocument, Guid>(filter, selector, cancellationToken: token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(null), Times.Once);
@@ -68,7 +68,7 @@ public class GetByMaxTests : BaseReaderTests
var (context, cursor) = SetupSyncGet(documents, collection, partitionKey);
// Act
var result = Sut.GetByMax<TestDocument, Guid>(filter, selector, partitionKey);
var result = Sut.GetByMin<TestDocument, Guid>(filter, selector, partitionKey);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);
@@ -89,7 +89,7 @@ public class GetByMaxTests : BaseReaderTests
var (context, cursor) = SetupSyncGet(documents, collection, partitionKey);
// Act
var result = Sut.GetByMax<TestDocument, Guid>(filter, selector, partitionKey, token);
var result = Sut.GetByMin<TestDocument, Guid>(filter, selector, partitionKey, token);
// Assert
context.Verify(x => x.GetCollection<TestDocument>(partitionKey), Times.Once);