From 251ffdacfa2647f4246f48ea6ee9b29d7bfe88b6 Mon Sep 17 00:00:00 2001 From: Sean Garrett Date: Sat, 24 Jun 2023 14:48:35 +0100 Subject: [PATCH] unit tests for Create and Get Indexes --- .../IndexTests/CreateTextIndexTests.cs | 263 ++++++++++++------ .../IndexTests/GetIndexNamesTests.cs | 154 +++++----- .../IndexTests/CreateTextIndexAsyncTests.cs | 154 ++++++++++ .../IndexTests/GetIndexNamesAsyncTests.cs | 90 ++++++ 4 files changed, 506 insertions(+), 155 deletions(-) create mode 100644 CoreUnitTests/KeyTypedRepositoryTests/IndexTests/CreateTextIndexAsyncTests.cs diff --git a/CoreUnitTests/BaseMongoRepositoryTests/IndexTests/CreateTextIndexTests.cs b/CoreUnitTests/BaseMongoRepositoryTests/IndexTests/CreateTextIndexTests.cs index c3584ec..485fa54 100644 --- a/CoreUnitTests/BaseMongoRepositoryTests/IndexTests/CreateTextIndexTests.cs +++ b/CoreUnitTests/BaseMongoRepositoryTests/IndexTests/CreateTextIndexTests.cs @@ -1,21 +1,23 @@ using System; using System.Linq.Expressions; -using System.Threading; using System.Threading.Tasks; +using AutoFixture; using CoreUnitTests.Infrastructure.Model; using MongoDbGenericRepository.DataAccess.Index; using MongoDbGenericRepository.Models; using Moq; using Xunit; +using CancellationToken = System.Threading.CancellationToken; namespace CoreUnitTests.BaseMongoRepositoryTests.IndexTests; public class CreateTextIndexTests : BaseIndexTests { private readonly Expression> fieldExpression = t => t.SomeContent2; + private readonly Expression, object>> keyedFieldExpression = t => t.SomeContent2; [Fact] - public async Task WhenFieldExpression_CreatesIndex() + public async Task WithFieldExpression_CreatesIndex() { // Arrange IndexHandler = new Mock(); @@ -29,11 +31,27 @@ public class CreateTextIndexTests : BaseIndexTests } [Fact] - public async Task Ensure_Passes_Options() + public async Task WithFieldExpressionAndCancellationToken_CreatesIndex() { // Arrange + var token = new CancellationToken(true); + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync(fieldExpression, token); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync(fieldExpression, null, null, token)); + } + + [Fact] + public async Task WithFieldExpressionAndOptions_CreatesIndex() + { + // Arrange + var indexName = Fixture.Create(); + var options = new IndexCreationOptions { Name = indexName }; IndexHandler = new Mock(); - var options = new IndexCreationOptions { Name = "theIndexName" }; // Act await Sut.CreateTextIndexAsync(fieldExpression, options); @@ -45,15 +63,32 @@ public class CreateTextIndexTests : BaseIndexTests } [Fact] - public async Task Ensure_Passes_PartitionKey() + public async Task WithFieldExpressionAndOptionsAndCancellationToken_CreatesIndex() { // Arrange - const string partitionKey = "thePartitionKey"; - + var indexName = Fixture.Create(); + var options = new IndexCreationOptions { Name = indexName }; + var token = new CancellationToken(true); IndexHandler = new Mock(); // Act - await Sut.CreateTextIndexAsync(fieldExpression, partitionKey: partitionKey); + await Sut.CreateTextIndexAsync(fieldExpression, options, token); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync( + fieldExpression, options, null, token)); + } + + [Fact] + public async Task WithFieldExpressionAndPartitionKey_CreatesIndex() + { + // Arrange + var partitionKey = Fixture.Create(); + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync(fieldExpression, partitionKey); // Assert IndexHandler.Verify( @@ -61,135 +96,199 @@ public class CreateTextIndexTests : BaseIndexTests fieldExpression, null, partitionKey, CancellationToken.None)); } - /*[Fact] - public async Task Ensure_Creates_Index_With_CancellationToken() - { - // Arrange - IndexHandler = new Mock(); - var token = new CancellationToken(true); - - // Act - await Sut.CreateTextIndexAsync(fieldExpression, token); - - // Assert - IndexHandler.Verify( - x => x.CreateTextIndexAsync(_fieldExpression, null, null, token)); - }*/ - - /* [Fact] - public async Task Ensure_Passes_Options_With_CancellationToken() + public async Task WithFieldExpressionAndPartitionKeyAndCancellationToken_CreatesIndex() { // Arrange - IndexHandler = new Mock(); + var partitionKey = Fixture.Create(); var token = new CancellationToken(true); - var options = new IndexCreationOptions { Name = "theIndexName" }; + IndexHandler = new Mock(); // Act - await Sut.CreateTextIndexAsync(_fieldExpression, token, options); + await Sut.CreateTextIndexAsync(fieldExpression, partitionKey, token); // Assert IndexHandler.Verify( x => x.CreateTextIndexAsync( - _fieldExpression, options, null, token)); + fieldExpression, null, partitionKey, token)); } [Fact] - public async Task Ensure_Passes_PartitionKey_With_CancellationToken() + public async Task WithFieldExpressionAndOptionsAndPartitionKey_CreatesIndex() { // Arrange - const string partitionKey = "thePartitionKey"; - var token = new CancellationToken(true); + var partitionKey = Fixture.Create(); + var indexName = Fixture.Create(); + var options = new IndexCreationOptions { Name = indexName }; + IndexHandler = new Mock(); // Act - await Sut.CreateTextIndexAsync(_fieldExpression, token, partitionKey: partitionKey); + await Sut.CreateTextIndexAsync(fieldExpression, options, partitionKey); // Assert IndexHandler.Verify( x => x.CreateTextIndexAsync( - _fieldExpression, null, partitionKey, token)); + fieldExpression, options, partitionKey, CancellationToken.None)); } [Fact] - public async Task Ensure_Creates_Index_Custom_Key() + public async Task WithFieldExpressionAndOptionsAndPartitionKeyAndCancellationToken_CreatesIndex() { // Arrange - IndexHandler = new Mock(); - Expression> fieldExpression = t => t.SomeContent2; - - // Act - await Sut.CreateTextIndexAsync(fieldExpression); - - // Assert - IndexHandler.Verify(x => x.CreateTextIndexAsync(fieldExpression, null, null, default)); - } - - [Fact] - public async Task Ensure_Passes_CancellationToken_Custom_Key() - { - // Arrange - IndexHandler = new Mock(); + var partitionKey = Fixture.Create(); var token = new CancellationToken(true); + var indexName = Fixture.Create(); + var options = new IndexCreationOptions { Name = indexName }; + + IndexHandler = new Mock(); // Act - await Sut.CreateTextIndexAsync(t => t.SomeContent2, token); + await Sut.CreateTextIndexAsync(fieldExpression, options, partitionKey, token); // Assert IndexHandler.Verify( - x => x.CreateTextIndexAsync( - t => t.SomeContent2, null, null, token)); + x => x.CreateTextIndexAsync( + fieldExpression, options, partitionKey, token)); } + #region Keyed + [Fact] - public async Task Ensure_Passes_Options_Custom_Key() + public async Task Keyed_WithKeyedFieldExpression_CreatesIndex() { // Arrange IndexHandler = new Mock(); - var options = new IndexCreationOptions { Name = "theIndexName" }; // Act - await Sut.CreateTextIndexAsync(t => t.SomeContent2, options); - - // Assert - IndexHandler.Verify(x => x.CreateTextIndexAsync(t => t.SomeContent2, options, null, default)); - } - - [Fact] - public async Task Ensure_Passes_PartitionKey_Custom_Key() - { - // Arrange - const string partitionKey = "thePartitionKey"; - - IndexHandler = new Mock(); - var options = new IndexCreationOptions { Name = "theIndexName" }; - - // Act - await Sut.CreateTextIndexAsync(t => t.SomeContent2, options, partitionKey); + await Sut.CreateTextIndexAsync, int>(keyedFieldExpression); // Assert IndexHandler.Verify( - x => x.CreateTextIndexAsync( - t => t.SomeContent2, options, partitionKey, default)); + x => x.CreateTextIndexAsync, int>(keyedFieldExpression, null, null, CancellationToken.None)); } [Fact] - public async Task Ensure_Passes_PartitionKey_And_CancellationToken_Custom_Key() + public async Task Keyed_WithKeyedFieldExpressionAndCancellationToken_CreatesIndex() { // Arrange - const string partitionKey = "thePartitionKey"; - const string indexName = "theIndexName"; var token = new CancellationToken(true); + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync, int>(keyedFieldExpression, token); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>(keyedFieldExpression, null, null, token)); + } + + [Fact] + public async Task Keyed_WithKeyedFieldExpressionAndOptions_CreatesIndex() + { + // Arrange + var indexName = Fixture.Create(); var options = new IndexCreationOptions { Name = indexName }; IndexHandler = new Mock(); // Act - await Sut.CreateTextIndexAsync(t => t.SomeContent2, token, options, partitionKey); + await Sut.CreateTextIndexAsync, int>(keyedFieldExpression, options); // Assert - IndexHandler - .Verify(x => x.CreateTextIndexAsync( - t => t.SomeContent2, options, partitionKey, token)); + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, options, null, CancellationToken.None)); } - */ + + [Fact] + public async Task Keyed_WithKeyedFieldExpressionAndOptionsAndCancellationToken_CreatesIndex() + { + // Arrange + var indexName = Fixture.Create(); + var options = new IndexCreationOptions { Name = indexName }; + var token = new CancellationToken(true); + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync, int>(keyedFieldExpression, options, token); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, options, null, token)); + } + + [Fact] + public async Task Keyed_WithKeyedFieldExpressionAndPartitionKey_CreatesIndex() + { + // Arrange + var partitionKey = Fixture.Create(); + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync, int>(keyedFieldExpression, partitionKey); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, null, partitionKey, CancellationToken.None)); + } + + [Fact] + public async Task Keyed_WithKeyedFieldExpressionAndPartitionKeyAndCancellationToken_CreatesIndex() + { + // Arrange + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync, int>(keyedFieldExpression, partitionKey, token); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, null, partitionKey, token)); + } + + [Fact] + public async Task Keyed_WithKeyedFieldExpressionAndOptionsAndPartitionKey_CreatesIndex() + { + // Arrange + var partitionKey = Fixture.Create(); + var indexName = Fixture.Create(); + var options = new IndexCreationOptions { Name = indexName }; + + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync, int>(keyedFieldExpression, options, partitionKey); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, options, partitionKey, CancellationToken.None)); + } + + [Fact] + public async Task Keyed_WithKeyedFieldExpressionAndOptionsAndPartitionKeyAndCancellationToken_CreatesIndex() + { + // Arrange + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + var indexName = Fixture.Create(); + var options = new IndexCreationOptions { Name = indexName }; + + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync, int>(keyedFieldExpression, options, partitionKey, token); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, options, partitionKey, token)); + } + + #endregion } diff --git a/CoreUnitTests/BaseMongoRepositoryTests/IndexTests/GetIndexNamesTests.cs b/CoreUnitTests/BaseMongoRepositoryTests/IndexTests/GetIndexNamesTests.cs index c73e7ae..78b2b77 100644 --- a/CoreUnitTests/BaseMongoRepositoryTests/IndexTests/GetIndexNamesTests.cs +++ b/CoreUnitTests/BaseMongoRepositoryTests/IndexTests/GetIndexNamesTests.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; +using AutoFixture; using CoreUnitTests.Infrastructure.Model; using MongoDbGenericRepository.DataAccess.Index; using Moq; @@ -12,11 +13,11 @@ namespace CoreUnitTests.BaseMongoRepositoryTests.IndexTests; public class GetIndexNamesTests : BaseIndexTests { [Fact] - public async Task Ensure_Returns_IndexNames() + public async Task WithNoParameters_ReturnsIndexNames() { // Arrange IndexHandler = new Mock(); - const string indexName = "theIndexName"; + var indexName = Fixture.Create(); IndexHandler .Setup(x => x.GetIndexesNamesAsync(It.IsAny(), It.IsAny())) @@ -31,16 +32,16 @@ public class GetIndexNamesTests : BaseIndexTests IndexHandler.Verify(x => x.GetIndexesNamesAsync(null, CancellationToken.None), Times.Once()); } - /* [Fact] - public async Task Ensure_Passes_Provided_CancellationToken() + public async Task WithCancellationToken_ReturnsIndexNames() { // Arrange - const string indexName = "theIndexName"; - var token = new CancellationToken(true); IndexHandler = new Mock(); + var indexName = Fixture.Create(); + var token = new CancellationToken(true); + IndexHandler - .Setup(x => x.GetIndexesNamesAsync(null, token)) + .Setup(x => x.GetIndexesNamesAsync(It.IsAny(), It.IsAny())) .ReturnsAsync(new List { indexName }); // Act @@ -49,17 +50,17 @@ public class GetIndexNamesTests : BaseIndexTests // Assert Assert.NotNull(result); Assert.Contains(result, x => x == indexName); + IndexHandler.Verify(x => x.GetIndexesNamesAsync(null, token), Times.Once()); } - */ [Fact] - public async Task Ensure_Handles_PartitionKey() + public async Task WithPartitionKey_ReturnsIndexNames() { // Arrange - const string partitionKey = "thePartitionKey"; - const string indexName = "theIndexName"; - IndexHandler = new Mock(); + var indexName = Fixture.Create(); + var partitionKey = Fixture.Create(); + IndexHandler .Setup(x => x.GetIndexesNamesAsync(It.IsAny(), It.IsAny())) .ReturnsAsync(new List { indexName }); @@ -70,105 +71,112 @@ public class GetIndexNamesTests : BaseIndexTests // Assert Assert.NotNull(result); Assert.Contains(result, x => x == indexName); + IndexHandler.Verify(x => x.GetIndexesNamesAsync(partitionKey, CancellationToken.None), Times.Once()); } - /*[Fact] - public async Task Ensure_Passes_Provided_CancellationToken_And_Handles_Partition_Key() + [Fact] + public async Task WithPartitionKeyAndCancellationToken_ReturnsIndexNames() { // Arrange - const string partitionKey = "thePartitionKey"; - const string indexName = "theIndexName"; + IndexHandler = new Mock(); + var indexName = Fixture.Create(); + var partitionKey = Fixture.Create(); var token = new CancellationToken(true); - IndexHandler = new Mock(); IndexHandler - .Setup(x => x.GetIndexesNamesAsync(partitionKey, token)) + .Setup(x => x.GetIndexesNamesAsync(It.IsAny(), It.IsAny())) .ReturnsAsync(new List { indexName }); // Act - var result = await Sut.GetIndexesNamesAsync(token, partitionKey); + var result = await Sut.GetIndexesNamesAsync(partitionKey, token); // Assert Assert.NotNull(result); Assert.Contains(result, x => x == indexName); - }*/ + IndexHandler.Verify(x => x.GetIndexesNamesAsync(partitionKey, token), Times.Once()); + } - /*[Fact] - public async Task Ensure_Returns_IndexNames_Custom_Primary_Key() + [Fact] + public async Task Keyed_WithNoParameters_ReturnsIndexNames() { // Arrange - const string indexName = "theIndexName"; - IndexHandler = new Mock(); + var indexName = Fixture.Create(); + IndexHandler - .Setup(x => x.GetIndexesNamesAsync(null)) + .Setup(x => x.GetIndexesNamesAsync, int>(It.IsAny(), It.IsAny())) .ReturnsAsync(new List { indexName }); // Act - var result = await Sut.GetIndexesNamesAsync(); + var result = await Sut.GetIndexesNamesAsync, int>(); // Assert Assert.NotNull(result); Assert.Contains(result, x => x == indexName); - }*/ + IndexHandler.Verify(x => x.GetIndexesNamesAsync, int>(null, CancellationToken.None), Times.Once()); + } - /*[Fact] - public async Task Ensure_Passes_Provided_CancellationToken_Custom_Primary_Key() + [Fact] + public async Task Keyed_WithCancellationToken_ReturnsIndexNames() { // Arrange - const string indexName = "theIndexName"; - var token = new CancellationToken(true); IndexHandler = new Mock(); - IndexHandler - .Setup(x => x.GetIndexesNamesAsync(null, token)) - .ReturnsAsync(new List { indexName }); - - // Act - var result = await Sut.GetIndexesNamesAsync(token); - - // Assert - Assert.NotNull(result); - Assert.Contains(result, x => x == indexName); - }*/ - - /*[Fact] - public async Task Ensure_Handles_PartitionKey_Custom_Primary_Key() - { - // Arrange - const string indexName = "theIndexName"; - const string partitionKey = "thePartitionKey"; - - IndexHandler = new Mock(); - IndexHandler - .Setup(x => x.GetIndexesNamesAsync(partitionKey)) - .ReturnsAsync(new List { indexName }); - - // Act - var result = await Sut.GetIndexesNamesAsync(partitionKey); - - // Assert - Assert.NotNull(result); - Assert.Contains(result, x => x == indexName); - }*/ - - /*[Fact] - public async Task Ensure_Passes_Provided_CancellationToken_And_Handles_Partition_Key_Custom_Primary_Key() - { - // Arrange - const string indexName = "theIndexName"; - const string partitionKey = "thePartitionKey"; + var indexName = Fixture.Create(); var token = new CancellationToken(true); - IndexHandler = new Mock(); IndexHandler - .Setup(x => x.GetIndexesNamesAsync(partitionKey, token)) + .Setup(x => x.GetIndexesNamesAsync, int>(It.IsAny(), It.IsAny())) .ReturnsAsync(new List { indexName }); // Act - var result = await Sut.GetIndexesNamesAsync(token, partitionKey); + var result = await Sut.GetIndexesNamesAsync, int>(token); // Assert Assert.NotNull(result); Assert.Contains(result, x => x == indexName); - }*/ + IndexHandler.Verify(x => x.GetIndexesNamesAsync, int>(null, token), Times.Once()); + } + + [Fact] + public async Task Keyed_WithPartitionKey_ReturnsIndexNames() + { + // Arrange + IndexHandler = new Mock(); + var indexName = Fixture.Create(); + var partitionKey = Fixture.Create(); + + IndexHandler + .Setup(x => x.GetIndexesNamesAsync, int>(It.IsAny(), It.IsAny())) + .ReturnsAsync(new List { indexName }); + + // Act + var result = await Sut.GetIndexesNamesAsync, int>(partitionKey); + + // Assert + Assert.NotNull(result); + Assert.Contains(result, x => x == indexName); + IndexHandler.Verify(x => x.GetIndexesNamesAsync, int>(partitionKey, CancellationToken.None), Times.Once()); + } + + [Fact] + public async Task Keyed_WithPartitionKeyAndCancellationToken_ReturnsIndexNames() + { + // Arrange + IndexHandler = new Mock(); + var indexName = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + IndexHandler + .Setup(x => x.GetIndexesNamesAsync, int>(It.IsAny(), It.IsAny())) + .ReturnsAsync(new List { indexName }); + + // Act + var result = await Sut.GetIndexesNamesAsync, int>(partitionKey, token); + + // Assert + Assert.NotNull(result); + Assert.Contains(result, x => x == indexName); + IndexHandler.Verify(x => x.GetIndexesNamesAsync, int>(partitionKey, token), Times.Once()); + } } diff --git a/CoreUnitTests/KeyTypedRepositoryTests/IndexTests/CreateTextIndexAsyncTests.cs b/CoreUnitTests/KeyTypedRepositoryTests/IndexTests/CreateTextIndexAsyncTests.cs new file mode 100644 index 0000000..81f2790 --- /dev/null +++ b/CoreUnitTests/KeyTypedRepositoryTests/IndexTests/CreateTextIndexAsyncTests.cs @@ -0,0 +1,154 @@ +using System; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; +using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using MongoDbGenericRepository.DataAccess.Index; +using MongoDbGenericRepository.Models; +using Moq; +using Xunit; + +namespace CoreUnitTests.KeyTypedRepositoryTests.IndexTests; + +public class CreateTextIndexAsyncTests : TestKeyedMongoRepositoryContext +{ + private readonly Expression, object>> keyedFieldExpression = t => t.SomeContent2; + + [Fact] + public async Task WithFieldExpression_CreatesIndex() + { + // Arrange + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync(keyedFieldExpression); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>(keyedFieldExpression, null, null, CancellationToken.None)); + } + + [Fact] + public async Task WithFieldExpressionAndCancellationToken_CreatesIndex() + { + // Arrange + var token = new CancellationToken(true); + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync(keyedFieldExpression, token); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>(keyedFieldExpression, null, null, token)); + } + + [Fact] + public async Task WithFieldExpressionAndOptions_CreatesIndex() + { + // Arrange + var indexName = Fixture.Create(); + var options = new IndexCreationOptions { Name = indexName }; + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync(keyedFieldExpression, options); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, options, null, CancellationToken.None)); + } + + [Fact] + public async Task WithFieldExpressionAndOptionsAndCancellationToken_CreatesIndex() + { + // Arrange + var indexName = Fixture.Create(); + var options = new IndexCreationOptions { Name = indexName }; + var token = new CancellationToken(true); + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync(keyedFieldExpression, options, token); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, options, null, token)); + } + + [Fact] + public async Task WithFieldExpressionAndPartitionKey_CreatesIndex() + { + // Arrange + var partitionKey = Fixture.Create(); + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync(keyedFieldExpression, partitionKey); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, null, partitionKey, CancellationToken.None)); + } + + [Fact] + public async Task WithFieldExpressionAndPartitionKeyAndCancellationToken_CreatesIndex() + { + // Arrange + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync(keyedFieldExpression, partitionKey, token); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, null, partitionKey, token)); + } + + [Fact] + public async Task WithFieldExpressionAndOptionsAndPartitionKey_CreatesIndex() + { + // Arrange + var partitionKey = Fixture.Create(); + var indexName = Fixture.Create(); + var options = new IndexCreationOptions { Name = indexName }; + + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync(keyedFieldExpression, options, partitionKey); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, options, partitionKey, CancellationToken.None)); + } + + [Fact] + public async Task WithFieldExpressionAndOptionsAndPartitionKeyAndCancellationToken_CreatesIndex() + { + // Arrange + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + var indexName = Fixture.Create(); + var options = new IndexCreationOptions { Name = indexName }; + + IndexHandler = new Mock(); + + // Act + await Sut.CreateTextIndexAsync(keyedFieldExpression, options, partitionKey, token); + + // Assert + IndexHandler.Verify( + x => x.CreateTextIndexAsync, int>( + keyedFieldExpression, options, partitionKey, token)); + } +} diff --git a/CoreUnitTests/KeyTypedRepositoryTests/IndexTests/GetIndexNamesAsyncTests.cs b/CoreUnitTests/KeyTypedRepositoryTests/IndexTests/GetIndexNamesAsyncTests.cs index 087cfc6..2d385bf 100644 --- a/CoreUnitTests/KeyTypedRepositoryTests/IndexTests/GetIndexNamesAsyncTests.cs +++ b/CoreUnitTests/KeyTypedRepositoryTests/IndexTests/GetIndexNamesAsyncTests.cs @@ -1,8 +1,98 @@ +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; +using AutoFixture; using CoreUnitTests.Infrastructure; +using CoreUnitTests.Infrastructure.Model; +using MongoDbGenericRepository.DataAccess.Index; +using Moq; +using Xunit; namespace CoreUnitTests.KeyTypedRepositoryTests.IndexTests; public class GetIndexNamesAsyncTests : TestKeyedMongoRepositoryContext { + [Fact] + public async Task WithNoParameters_ReturnsIndexNames() + { + // Arrange + IndexHandler = new Mock(); + var indexName = Fixture.Create(); + IndexHandler + .Setup(x => x.GetIndexesNamesAsync, int>(It.IsAny(), It.IsAny())) + .ReturnsAsync(new List { indexName }); + + // Act + var result = await Sut.GetIndexesNamesAsync>(); + + // Assert + Assert.NotNull(result); + Assert.Contains(result, x => x == indexName); + IndexHandler.Verify(x => x.GetIndexesNamesAsync, int>(null, CancellationToken.None), Times.Once()); + } + + [Fact] + public async Task WithCancellationToken_ReturnsIndexNames() + { + // Arrange + IndexHandler = new Mock(); + var indexName = Fixture.Create(); + var token = new CancellationToken(true); + + IndexHandler + .Setup(x => x.GetIndexesNamesAsync, int>(It.IsAny(), It.IsAny())) + .ReturnsAsync(new List { indexName }); + + // Act + var result = await Sut.GetIndexesNamesAsync>(token); + + // Assert + Assert.NotNull(result); + Assert.Contains(result, x => x == indexName); + IndexHandler.Verify(x => x.GetIndexesNamesAsync, int>(null, token), Times.Once()); + } + + [Fact] + public async Task WithPartitionKey_ReturnsIndexNames() + { + // Arrange + IndexHandler = new Mock(); + var indexName = Fixture.Create(); + var partitionKey = Fixture.Create(); + + IndexHandler + .Setup(x => x.GetIndexesNamesAsync, int>(It.IsAny(), It.IsAny())) + .ReturnsAsync(new List { indexName }); + + // Act + var result = await Sut.GetIndexesNamesAsync>(partitionKey); + + // Assert + Assert.NotNull(result); + Assert.Contains(result, x => x == indexName); + IndexHandler.Verify(x => x.GetIndexesNamesAsync, int>(partitionKey, CancellationToken.None), Times.Once()); + } + + [Fact] + public async Task WithPartitionKeyAndCancellationToken_ReturnsIndexNames() + { + // Arrange + IndexHandler = new Mock(); + var indexName = Fixture.Create(); + var partitionKey = Fixture.Create(); + var token = new CancellationToken(true); + + IndexHandler + .Setup(x => x.GetIndexesNamesAsync, int>(It.IsAny(), It.IsAny())) + .ReturnsAsync(new List { indexName }); + + // Act + var result = await Sut.GetIndexesNamesAsync>(partitionKey, token); + + // Assert + Assert.NotNull(result); + Assert.Contains(result, x => x == indexName); + IndexHandler.Verify(x => x.GetIndexesNamesAsync, int>(partitionKey, token), Times.Once()); + } }