diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllAsyncTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllAsyncTests.cs
index 51818de..db168c5 100644
--- a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllAsyncTests.cs
+++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllAsyncTests.cs
@@ -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>(
diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllTests.cs
index db168c5..2d679ab 100644
--- a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllTests.cs
+++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetAllTests.cs
@@ -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>();
 
diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxAsyncTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxAsyncTests.cs
index d9af227..000ea7b 100644
--- a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxAsyncTests.cs
+++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxAsyncTests.cs
@@ -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);
diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxTests.cs
index 000ea7b..500afc2 100644
--- a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxTests.cs
+++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMaxTests.cs
@@ -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>();
 
diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinAsyncTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinAsyncTests.cs
index 000ea7b..5521897 100644
--- a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinAsyncTests.cs
+++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinAsyncTests.cs
@@ -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);
diff --git a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinTests.cs b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinTests.cs
index 500afc2..0cd9d9c 100644
--- a/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinTests.cs
+++ b/CoreUnitTests/DataAccessTests/MongoDbReaderTests/GetByMinTests.cs
@@ -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);