From ca0d44601a038dfd0895b375067f68d1dc911a19 Mon Sep 17 00:00:00 2001 From: PascalSenn Date: Sun, 17 Apr 2022 20:44:25 +0200 Subject: [PATCH] Migrated MongoDb to file scoped namespaces (#4972) --- format.sh | 1 + src/HotChocolate/MongoDb/format.sh | 13 + .../src/Data/Driver/AndFilterDefinition.cs | 141 +- .../Data/Driver/FilterDefinitionExtensions.cs | 43 +- .../MongoDbCombinedProjectionDefinition.cs | 63 +- .../Driver/MongoDbCombinedSortDefinition.cs | 57 +- .../Driver/MongoDbDirectionalSortOperation.cs | 75 +- .../Data/Driver/MongoDbFilterDefinition.cs | 69 +- .../src/Data/Driver/MongoDbFilterOperation.cs | 127 +- .../MongoDbIncludeProjectionOperation.cs | 39 +- .../Driver/MongoDbProjectionDefinition.cs | 71 +- .../src/Data/Driver/MongoDbSortDefinition.cs | 69 +- .../Data/Driver/NotMongoDbFilterDefinition.cs | 191 +- .../Data/Driver/OrMongoDbFilterDefinition.cs | 73 +- .../Data/Driver/SortDefinitionExtensions.cs | 41 +- .../Driver/StringFieldDefinitionHelper.cs | 171 +- .../MongoDb/src/Data/ErrorHelper.cs | 81 +- .../src/Data/Execution/IMongoDbExecutable.cs | 45 +- .../MongoDbAggregateFluentExecutable.cs | 105 +- .../Execution/MongoDbCollectionExecutable.cs | 173 +- .../src/Data/Execution/MongoDbExecutable.cs | 95 +- .../Execution/MongoDbExecutableExtensions.cs | 81 +- .../Execution/MongoDbFindFluentExecutable.cs | 119 +- .../Data/Extensions/BsonDocumentExtensions.cs | 33 +- .../MongoDbDataRequestBuilderExtensions.cs | 189 +- .../MongoDbFilterScopeExtensions.cs | 31 +- .../MongoDbObjectFieldExtensions.cs | 21 +- .../Extensions/MongoDbSortFieldExtensions.cs | 21 +- .../MongoFilterOperationFieldExtensions.cs | 21 +- .../MongoFilterVisitorContextExtensions.cs | 45 +- .../MongoSortVisitorContextExtensions.cs | 31 +- .../Extensions/SchemaBuilderExtensions.cs | 95 +- ...erConventionDescriptorMongoDbExtensions.cs | 101 +- .../MongoDbComparableGreaterThanHandler.cs | 55 +- ...oDbComparableGreaterThanOrEqualsHandler.cs | 53 +- .../MongoDbComparableLowerThanHandler.cs | 55 +- ...ngoDbComparableLowerThanOrEqualsHandler.cs | 55 +- .../MongoDbComparableNotGreaterThanHandler.cs | 57 +- ...ComparableNotGreaterThanOrEqualsHandler.cs | 57 +- .../MongoDbComparableNotLowerThanHandler.cs | 57 +- ...DbComparableNotLowerThanOrEqualsHandler.cs | 57 +- .../MongoDbComparableOperationHandler.cs | 73 +- .../List/MongoDbListAllOperationHandler.cs | 69 +- .../List/MongoDbListAnyOperationHandler.cs | 105 +- .../List/MongoDbListNoneOperationHandler.cs | 55 +- .../List/MongoDbListOperationHandlerBase.cs | 195 +- .../List/MongoDbListSomeOperationHandler.cs | 39 +- .../Handlers/MongoDbDefaultFieldHandler.cs | 101 +- .../Handlers/MongoDbEqualsOperationHandler.cs | 57 +- .../Handlers/MongoDbInOperationHandler.cs | 59 +- .../MongoDbNotEqualsOperationHandler.cs | 59 +- .../Handlers/MongoDbNotInOperationHandler.cs | 59 +- .../Handlers/MongoDbOperationHandlerBase.cs | 125 +- .../String/MongoDbStringContainsHandler.cs | 47 +- .../String/MongoDbStringEndsWithHandler.cs | 47 +- .../String/MongoDbStringNotContainsHandler.cs | 49 +- .../String/MongoDbStringNotEndsWithHandler.cs | 49 +- .../MongoDbStringNotStartsWithHandler.cs | 49 +- .../String/MongoDbStringOperationHandler.cs | 33 +- .../String/MongoDbStringStartsWithHandler.cs | 47 +- .../Data/Filters/MongoDbFilterCombinator.cs | 75 +- .../src/Data/Filters/MongoDbFilterProvider.cs | 114 +- .../src/Data/Filters/MongoDbFilterScope.cs | 19 +- .../Filters/MongoDbFilterVisitorContext.cs | 35 +- .../Paging/AggregateFluentPagingContainer.cs | 93 +- .../Data/Paging/FindFluentPagingContainer.cs | 95 +- .../src/Data/Paging/IMongoPagingContainer.cs | 21 +- .../Data/Paging/MongoCursorPagingHandler.cs | 43 +- .../Data/Paging/MongoDbCursorPagingHandler.cs | 63 +- .../Paging/MongoDbCursorPagingProvider.cs | 55 +- .../Data/Paging/MongoDbOffsetPagingHandler.cs | 63 +- .../Paging/MongoDbOffsetPagingProvider.cs | 63 +- .../src/Data/Paging/MongoOffsetPagination.cs | 45 +- ...bProjectionProviderDescriptorExtensions.cs | 61 +- ...rojectionConventionDescriptorExtensions.cs | 23 +- ...MongoProjectionVisitorContextExtensions.cs | 31 +- .../Handlers/MongoDbProjectionFieldHandler.cs | 55 +- .../Handlers/MongoDbProjectionHandlerBase.cs | 49 +- .../MongoDbProjectionScalarHandler.cs | 41 +- .../Convention/MongoDbProjectionProvider.cs | 93 +- .../Convention/MongoDbProjectionScope.cs | 11 +- .../MongoDbProjectionVisitorContext.cs | 37 +- ...goSortingConventionDescriptorExtensions.cs | 95 +- ...SortConventionDescriptorMongoExtensions.cs | 47 +- .../MongoDbAscendingSortOperationHandler.cs | 11 +- .../MongoDbDefaultSortFieldHandler.cs | 73 +- .../MongoDbDescendingSortOperationHandler.cs | 11 +- .../MongoDbSortOperationHandlerBase.cs | 87 +- .../Sorting/Handlers/MongoDbSortProvider.cs | 112 +- .../Handlers/MongoDbSortVisitorContext.cs | 21 +- .../MongoDb/src/Data/ThrowHelper.cs | 53 +- .../MongoDb/src/Types/BsonType.cs | 52 +- .../MongoDb/src/Types/MongoDbScalarNames.cs | 29 +- .../MongoDb/src/Types/ObjectIdType.cs | 73 +- .../Extensions/TestExtensions.cs | 27 +- .../FilterVisitorTestBase.cs | 121 +- .../MongoDbAggregateFluentTests.cs | 279 ++- .../MongoDbCollectionTests.cs | 275 ++- .../MongoDbFilterVisitorBooleanTests.cs | 293 ++- .../MongoDbFilterVisitorComparableTests.cs | 1625 ++++++++--------- .../MongoDbFilterVisitorDateOnlyTests.cs | 289 ++- .../MongoDbFilterVisitorEnumTests.cs | 565 +++--- .../MongoDbFilterVisitorListTests.cs | 539 +++--- .../MongoDbFilterVisitorObjectIdTests.cs | 1351 +++++++------- .../MongoDbFilterVisitorObjectTests.cs | 1133 ++++++------ .../MongoDbFilterVisitorStringTests.cs | 1023 ++++++----- .../MongoDbFilterVisitorTimeOnlyTests.cs | 287 ++- .../MongoDbFindFluentTests.cs | 343 ++-- .../Data.MongoDb.Filters.Tests/SchemaCache.cs | 47 +- .../Extensions/TestExtensions.cs | 27 +- ...MongoDbCursorPagingAggregateFluentTests.cs | 259 ++- .../MongoDbCursorPagingFindFluentTests.cs | 263 ++- .../MongoDbCursorPagingProviderTests.cs | 87 +- .../MongoDbOffsetPagingAggregateTests.cs | 273 ++- .../MongoDbOffsetPagingFindFluentTests.cs | 243 ++- .../MongoDbOffsetPagingProviderTests.cs | 87 +- .../MongoDbRelayTests.cs | 105 +- .../Data.MongoDb.Paging.Tests/SchemaCache.cs | 47 +- .../VisitorTestBase.cs | 127 +- .../Extensions/TestExtensions.cs | 23 +- .../MongoDbProjectionObjectsTests.cs | 247 ++- ...ongoDbProjectionVisitorIsProjectedTests.cs | 203 +- .../MongoDbProjectionVisitorPagingTests.cs | 749 ++++---- .../MongoDbProjectionVisitorScalarTests.cs | 145 +- .../ProjectionVisitorTestBase.cs | 187 +- .../SchemaCache.cs | 61 +- .../Extensions/TestExtensions.cs | 25 +- .../MongoDbAggregateFluentTests.cs | 271 ++- .../MongoDbCollectionTests.cs | 271 ++- .../MongoDbFindFluentTests.cs | 365 ++-- .../MongoDbSortVisitorBooleanTests.cs | 165 +- .../MongoDbSortVisitorComparableTests.cs | 183 +- .../MongoDbSortVisitorEnumTests.cs | 183 +- .../MongoDbSortVisitorObjectTests.cs | 591 +++--- .../MongoDbSortVisitorStringTests.cs | 161 +- .../Data.MongoDb.Sorting.Tests/SchemaCache.cs | 47 +- .../SortVisitorTestBase.cs | 117 +- .../test/Types.MongoDb/BsonTypeTests.cs | 5 +- .../test/Types.MongoDb/ObjectIdTypeTests.cs | 101 +- 139 files changed, 9920 insertions(+), 10038 deletions(-) create mode 100755 src/HotChocolate/MongoDb/format.sh diff --git a/format.sh b/format.sh index 8bed454c1bd..f2c97400b0d 100755 --- a/format.sh +++ b/format.sh @@ -5,6 +5,7 @@ rootDir=$(dirname "$0") $rootDir/src/HotChocolate/AspNetCore/format.sh $rootDir/src/HotChocolate/ApolloFederation/format.sh $rootDir/src/HotChocolate/Data/format.sh +$rootDir/src/HotChocolate/MongoDb/format.sh $rootDir/src/HotChocolate/Language/format.sh $rootDir/src/HotChocolate/Stitching/format.sh $rootDir/src/HotChocolate/Spatial/format.sh diff --git a/src/HotChocolate/MongoDb/format.sh b/src/HotChocolate/MongoDb/format.sh new file mode 100755 index 00000000000..c1d3e203294 --- /dev/null +++ b/src/HotChocolate/MongoDb/format.sh @@ -0,0 +1,13 @@ +#!/usr/bin/env bash + +BASEDIR=$(dirname "$0") +src=$BASEDIR/src +test=$BASEDIR/test + +dotnet format $src/Data +dotnet format $src/Types +dotnet format $test/Data.MongoDb.Filters.Tests +dotnet format $test/Data.MongoDb.Projections.Tests +dotnet format $test/Data.MongoDb.Paging.Tests +dotnet format $test/Data.MongoDb.Sorting.Tests +dotnet format $test/Types.MongoDb diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/AndFilterDefinition.cs b/src/HotChocolate/MongoDb/src/Data/Driver/AndFilterDefinition.cs index ac817ad40d6..19bc44148b8 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/AndFilterDefinition.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/AndFilterDefinition.cs @@ -4,114 +4,113 @@ using MongoDB.Bson.Serialization; using MongoDB.Driver.Linq; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// This class was ported over from the official mongo db driver +/// +public sealed class AndFilterDefinition : MongoDbFilterDefinition { - /// - /// This class was ported over from the official mongo db driver - /// - public sealed class AndFilterDefinition : MongoDbFilterDefinition + private static readonly string[] __operatorsThatCannotBeCombined = new[] { - private static readonly string[] __operatorsThatCannotBeCombined = new[] - { "$geoWithin", "$near", "$geoIntersects", "$nearSphere" }; - private readonly MongoDbFilterDefinition[] _filters; + private readonly MongoDbFilterDefinition[] _filters; - public AndFilterDefinition(params MongoDbFilterDefinition[] filters) - { - _filters = filters; - } + public AndFilterDefinition(params MongoDbFilterDefinition[] filters) + { + _filters = filters; + } + + public AndFilterDefinition(IEnumerable filters) + { + _filters = filters.ToArray(); + } - public AndFilterDefinition(IEnumerable filters) + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + if (_filters.Length == 0) { - _filters = filters.ToArray(); + return new BsonDocument("$and", new BsonArray(0)); } - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) + var document = new BsonDocument(); + + foreach (var filter in _filters) { - if (_filters.Length == 0) + BsonDocument renderedFilter = filter.Render(documentSerializer, serializerRegistry); + foreach (BsonElement clause in renderedFilter) { - return new BsonDocument("$and", new BsonArray(0)); + AddClause(document, clause); } + } - var document = new BsonDocument(); + return document; + } - foreach (var filter in _filters) + private static void AddClause(BsonDocument document, BsonElement clause) + { + if (clause.Name == "$and") + { + // flatten out nested $and + foreach (var item in (BsonArray)clause.Value) { - BsonDocument renderedFilter = filter.Render(documentSerializer, serializerRegistry); - foreach (BsonElement clause in renderedFilter) + foreach (BsonElement element in (BsonDocument)item) { - AddClause(document, clause); + AddClause(document, element); } } - - return document; } - - private static void AddClause(BsonDocument document, BsonElement clause) + else if (document.ElementCount == 1 && document.GetElement(0).Name == "$and") { - if (clause.Name == "$and") - { - // flatten out nested $and - foreach (var item in (BsonArray)clause.Value) - { - foreach (BsonElement element in (BsonDocument)item) - { - AddClause(document, element); - } - } - } - else if (document.ElementCount == 1 && document.GetElement(0).Name == "$and") - { - ((BsonArray)document[0]).Add(new BsonDocument(clause)); - } - else if (document.Contains(clause.Name)) + ((BsonArray)document[0]).Add(new BsonDocument(clause)); + } + else if (document.Contains(clause.Name)) + { + BsonElement existingClause = document.GetElement(clause.Name); + if (existingClause.Value is BsonDocument existingClauseValue && + clause.Value is BsonDocument clauseValue) { - BsonElement existingClause = document.GetElement(clause.Name); - if (existingClause.Value is BsonDocument existingClauseValue && - clause.Value is BsonDocument clauseValue) + var clauseOperator = clauseValue.ElementCount > 0 + ? clauseValue.GetElement(0).Name + : null; + if (clauseValue.Names.Any(op => existingClauseValue.Contains(op)) || + __operatorsThatCannotBeCombined.Contains(clauseOperator)) { - var clauseOperator = clauseValue.ElementCount > 0 - ? clauseValue.GetElement(0).Name - : null; - if (clauseValue.Names.Any(op => existingClauseValue.Contains(op)) || - __operatorsThatCannotBeCombined.Contains(clauseOperator)) - { - PromoteFilterToDollarForm(document, clause); - } - else - { - existingClauseValue.AddRange(clauseValue); - } + PromoteFilterToDollarForm(document, clause); } else { - PromoteFilterToDollarForm(document, clause); + existingClauseValue.AddRange(clauseValue); } } else { - document.Add(clause); + PromoteFilterToDollarForm(document, clause); } } - - private static void PromoteFilterToDollarForm(BsonDocument document, BsonElement clause) + else { - var clauses = new BsonArray(); - foreach (BsonElement queryElement in document) - { - clauses.Add(new BsonDocument(queryElement)); - } + document.Add(clause); + } + } - clauses.Add(new BsonDocument(clause)); - document.Clear(); - document.Add("$and", clauses); + private static void PromoteFilterToDollarForm(BsonDocument document, BsonElement clause) + { + var clauses = new BsonArray(); + foreach (BsonElement queryElement in document) + { + clauses.Add(new BsonDocument(queryElement)); } + + clauses.Add(new BsonDocument(clause)); + document.Clear(); + document.Add("$and", clauses); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/FilterDefinitionExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Driver/FilterDefinitionExtensions.cs index eb8eaed5d08..3f9bf278609 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/FilterDefinitionExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/FilterDefinitionExtensions.cs @@ -2,36 +2,35 @@ using MongoDB.Bson.Serialization; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +public static class FilterDefinitionExtensions { - public static class FilterDefinitionExtensions + public static MongoDbFilterDefinition Wrap( + this FilterDefinition filterDefinition) => + new FilterDefinitionWrapper(filterDefinition); + + private sealed class FilterDefinitionWrapper : MongoDbFilterDefinition { - public static MongoDbFilterDefinition Wrap( - this FilterDefinition filterDefinition) => - new FilterDefinitionWrapper(filterDefinition); + private readonly FilterDefinition _filter; - private sealed class FilterDefinitionWrapper : MongoDbFilterDefinition + public FilterDefinitionWrapper(FilterDefinition filter) { - private readonly FilterDefinition _filter; + _filter = filter; + } - public FilterDefinitionWrapper(FilterDefinition filter) + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + if (documentSerializer is IBsonSerializer typedSerializer) { - _filter = filter; + return _filter.Render(typedSerializer, serializerRegistry); } - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) - { - if (documentSerializer is IBsonSerializer typedSerializer) - { - return _filter.Render(typedSerializer, serializerRegistry); - } - - return _filter.Render( - serializerRegistry.GetSerializer(), - serializerRegistry); - } + return _filter.Render( + serializerRegistry.GetSerializer(), + serializerRegistry); } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbCombinedProjectionDefinition.cs b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbCombinedProjectionDefinition.cs index b7901eb4956..559d2361102 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbCombinedProjectionDefinition.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbCombinedProjectionDefinition.cs @@ -4,47 +4,46 @@ using MongoDB.Bson.Serialization; using MongoDB.Driver.Core.Misc; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// This class was ported over from the official mongo db driver +/// +public sealed class MongoDbCombinedProjectionDefinition : MongoDbProjectionDefinition { - /// - /// This class was ported over from the official mongo db driver - /// - public sealed class MongoDbCombinedProjectionDefinition : MongoDbProjectionDefinition + private readonly MongoDbProjectionDefinition[] _projections; + + public MongoDbCombinedProjectionDefinition( + params MongoDbProjectionDefinition[] projections) { - private readonly MongoDbProjectionDefinition[] _projections; + _projections = projections; + } - public MongoDbCombinedProjectionDefinition( - params MongoDbProjectionDefinition[] projections) - { - _projections = projections; - } + public MongoDbCombinedProjectionDefinition( + IEnumerable projections) + { + _projections = Ensure.IsNotNull(projections, nameof(projections)).ToArray(); + } - public MongoDbCombinedProjectionDefinition( - IEnumerable projections) - { - _projections = Ensure.IsNotNull(projections, nameof(projections)).ToArray(); - } + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + var document = new BsonDocument(); - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) + foreach (var sort in _projections) { - var document = new BsonDocument(); + BsonDocument renderedProjection = sort.Render( + documentSerializer, + serializerRegistry); - foreach (var sort in _projections) + foreach (BsonElement element in renderedProjection.Elements) { - BsonDocument renderedProjection = sort.Render( - documentSerializer, - serializerRegistry); - - foreach (BsonElement element in renderedProjection.Elements) - { - document.Remove(element.Name); - document.Add(element); - } + document.Remove(element.Name); + document.Add(element); } - - return document; } + + return document; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbCombinedSortDefinition.cs b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbCombinedSortDefinition.cs index 4c3ff77a43d..4bc48311657 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbCombinedSortDefinition.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbCombinedSortDefinition.cs @@ -4,44 +4,43 @@ using MongoDB.Bson.Serialization; using MongoDB.Driver.Core.Misc; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// This class was ported over from the official mongo db driver +/// +public sealed class MongoDbCombinedSortDefinition : MongoDbSortDefinition { - /// - /// This class was ported over from the official mongo db driver - /// - public sealed class MongoDbCombinedSortDefinition : MongoDbSortDefinition + private readonly MongoDbSortDefinition[] _sorts; + + public MongoDbCombinedSortDefinition(params MongoDbSortDefinition[] sorts) { - private readonly MongoDbSortDefinition[] _sorts; + _sorts = sorts; + } - public MongoDbCombinedSortDefinition(params MongoDbSortDefinition[] sorts) - { - _sorts = sorts; - } + public MongoDbCombinedSortDefinition(IEnumerable sorts) + { + _sorts = Ensure.IsNotNull(sorts, nameof(sorts)).ToArray(); + } - public MongoDbCombinedSortDefinition(IEnumerable sorts) - { - _sorts = Ensure.IsNotNull(sorts, nameof(sorts)).ToArray(); - } + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + var document = new BsonDocument(); - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) + foreach (var sort in _sorts) { - var document = new BsonDocument(); + BsonDocument renderedSort = sort.Render(documentSerializer, serializerRegistry); - foreach (var sort in _sorts) + foreach (BsonElement element in renderedSort.Elements) { - BsonDocument renderedSort = sort.Render(documentSerializer, serializerRegistry); - - foreach (BsonElement element in renderedSort.Elements) - { - // the last sort always wins, and we need to make sure that order is preserved. - document.Remove(element.Name); - document.Add(element); - } + // the last sort always wins, and we need to make sure that order is preserved. + document.Remove(element.Name); + document.Add(element); } - - return document; } + + return document; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbDirectionalSortOperation.cs b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbDirectionalSortOperation.cs index faa9d0e7b83..4c7a4529eef 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbDirectionalSortOperation.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbDirectionalSortOperation.cs @@ -4,49 +4,48 @@ using MongoDB.Driver; using MongoDB.Driver.Core.Misc; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// This class was ported over from the official mongo db driver +/// +public sealed class MongoDbDirectionalSortOperation : MongoDbSortDefinition { - /// - /// This class was ported over from the official mongo db driver - /// - public sealed class MongoDbDirectionalSortOperation : MongoDbSortDefinition + private readonly string _path; + private readonly SortDirection _direction; + + public MongoDbDirectionalSortOperation( + string field, + SortDirection direction) { - private readonly string _path; - private readonly SortDirection _direction; + _path = Ensure.IsNotNull(field, nameof(field)); + _direction = direction; + } - public MongoDbDirectionalSortOperation( - string field, - SortDirection direction) - { - _path = Ensure.IsNotNull(field, nameof(field)); - _direction = direction; - } + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + StringFieldDefinitionHelper.Resolve( + _path, + documentSerializer, + out string? resolvedFieldName, + out IBsonSerializer? _); - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) + BsonValue value; + switch (_direction) { - StringFieldDefinitionHelper.Resolve( - _path, - documentSerializer, - out string? resolvedFieldName, - out IBsonSerializer? _); - - BsonValue value; - switch (_direction) - { - case SortDirection.Ascending: - value = 1; - break; - case SortDirection.Descending: - value = -1; - break; - default: - throw new InvalidOperationException( - "Unknown value for " + typeof(SortDirection) + "."); - } - - return new BsonDocument(resolvedFieldName ?? _path, value); + case SortDirection.Ascending: + value = 1; + break; + case SortDirection.Descending: + value = -1; + break; + default: + throw new InvalidOperationException( + "Unknown value for " + typeof(SortDirection) + "."); } + + return new BsonDocument(resolvedFieldName ?? _path, value); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbFilterDefinition.cs b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbFilterDefinition.cs index 94fc6b6da86..e72f05d91ab 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbFilterDefinition.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbFilterDefinition.cs @@ -3,54 +3,53 @@ using MongoDB.Driver; using MongoDB.Driver.Linq; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +public abstract class MongoDbFilterDefinition : FilterDefinition { - public abstract class MongoDbFilterDefinition : FilterDefinition + public abstract BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry); + + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + return Render(documentSerializer, serializerRegistry); + } + + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry, + LinqProvider provider) + { + return Render(documentSerializer, serializerRegistry); + } + + public FilterDefinition ToFilterDefinition() => new FilterDefinitionWrapper(this); + + private sealed class FilterDefinitionWrapper : FilterDefinition { - public abstract BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry); + private readonly MongoDbFilterDefinition _filter; + + public FilterDefinitionWrapper(MongoDbFilterDefinition filter) + { + _filter = filter; + } public override BsonDocument Render( - IBsonSerializer documentSerializer, + IBsonSerializer documentSerializer, IBsonSerializerRegistry serializerRegistry) { - return Render(documentSerializer, serializerRegistry); + return _filter.Render(documentSerializer, serializerRegistry); } public override BsonDocument Render( - IBsonSerializer documentSerializer, + IBsonSerializer documentSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider provider) { return Render(documentSerializer, serializerRegistry); } - - public FilterDefinition ToFilterDefinition() => new FilterDefinitionWrapper(this); - - private sealed class FilterDefinitionWrapper : FilterDefinition - { - private readonly MongoDbFilterDefinition _filter; - - public FilterDefinitionWrapper(MongoDbFilterDefinition filter) - { - _filter = filter; - } - - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) - { - return _filter.Render(documentSerializer, serializerRegistry); - } - - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry, - LinqProvider provider) - { - return Render(documentSerializer, serializerRegistry); - } - } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbFilterOperation.cs b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbFilterOperation.cs index 56aa3b9e844..69733195b9e 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbFilterOperation.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbFilterOperation.cs @@ -5,95 +5,94 @@ using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Serializers; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +public class MongoDbFilterOperation : MongoDbFilterDefinition { - public class MongoDbFilterOperation : MongoDbFilterDefinition + private readonly string _path; + private readonly object? _value; + + public MongoDbFilterOperation(string path, object? value) + { + _path = path; + _value = value; + } + + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) { - private readonly string _path; - private readonly object? _value; + StringFieldDefinitionHelper.Resolve( + _path, + documentSerializer, + out string? resolvedFieldName, + out IBsonSerializer? resolvedFieldSerializer); + + resolvedFieldSerializer ??= documentSerializer; - public MongoDbFilterOperation(string path, object? value) + if (_value is BsonDocument bsonDocument) { - _path = path; - _value = value; + return new BsonDocument(resolvedFieldName, bsonDocument); } - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) + if (_value is BsonValue bsonValue) { - StringFieldDefinitionHelper.Resolve( - _path, - documentSerializer, - out string? resolvedFieldName, - out IBsonSerializer? resolvedFieldSerializer); - - resolvedFieldSerializer ??= documentSerializer; + return new BsonDocument(resolvedFieldName, bsonValue); + } - if (_value is BsonDocument bsonDocument) + if (_value is MongoDbFilterDefinition mongoDbOperation) + { + if (_path is "") { - return new BsonDocument(resolvedFieldName, bsonDocument); + return mongoDbOperation.Render(resolvedFieldSerializer, serializerRegistry); } - if (_value is BsonValue bsonValue) - { - return new BsonDocument(resolvedFieldName, bsonValue); - } + return new BsonDocument( + resolvedFieldName, + mongoDbOperation.Render(resolvedFieldSerializer, serializerRegistry)); + } - if (_value is MongoDbFilterDefinition mongoDbOperation) + var document = new BsonDocument(); + using var bsonWriter = new BsonDocumentWriter(document); + var context = BsonSerializationContext.CreateRoot(bsonWriter); + bsonWriter.WriteStartDocument(); + bsonWriter.WriteName(resolvedFieldName); + if (_value is IList values) + { + bsonWriter.WriteStartArray(); + foreach (var value in values) { - if (_path is "") - { - return mongoDbOperation.Render(resolvedFieldSerializer, serializerRegistry); - } - - return new BsonDocument( - resolvedFieldName, - mongoDbOperation.Render(resolvedFieldSerializer, serializerRegistry)); + resolvedFieldSerializer.Serialize(context, value); } - var document = new BsonDocument(); - using var bsonWriter = new BsonDocumentWriter(document); - var context = BsonSerializationContext.CreateRoot(bsonWriter); - bsonWriter.WriteStartDocument(); - bsonWriter.WriteName(resolvedFieldName); - if (_value is IList values) + bsonWriter.WriteEndArray(); + } + else + { + if (_value is null) { - bsonWriter.WriteStartArray(); - foreach (var value in values) - { - resolvedFieldSerializer.Serialize(context, value); - } - - bsonWriter.WriteEndArray(); + bsonWriter.WriteNull(); } - else + else if (_value is DateTimeOffset dateTimeOffset && + resolvedFieldSerializer is DateTimeSerializer or NullableSerializer) { - if (_value is null) + if (dateTimeOffset.Offset == TimeSpan.Zero) { - bsonWriter.WriteNull(); - } - else if (_value is DateTimeOffset dateTimeOffset && - resolvedFieldSerializer is DateTimeSerializer or NullableSerializer) - { - if (dateTimeOffset.Offset == TimeSpan.Zero) - { - resolvedFieldSerializer.Serialize(context, dateTimeOffset.UtcDateTime); - } - else - { - resolvedFieldSerializer.Serialize(context, dateTimeOffset.DateTime); - } + resolvedFieldSerializer.Serialize(context, dateTimeOffset.UtcDateTime); } else { - resolvedFieldSerializer.Serialize(context, _value); + resolvedFieldSerializer.Serialize(context, dateTimeOffset.DateTime); } } + else + { + resolvedFieldSerializer.Serialize(context, _value); + } + } - bsonWriter.WriteEndDocument(); + bsonWriter.WriteEndDocument(); - return document; - } + return document; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbIncludeProjectionOperation.cs b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbIncludeProjectionOperation.cs index 9fc2cf9543d..be3d5fc2d92 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbIncludeProjectionOperation.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbIncludeProjectionOperation.cs @@ -3,29 +3,28 @@ using MongoDB.Driver; using MongoDB.Driver.Core.Misc; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +public sealed class MongoDbIncludeProjectionOperation : MongoDbProjectionDefinition { - public sealed class MongoDbIncludeProjectionOperation : MongoDbProjectionDefinition - { - private readonly string _path; + private readonly string _path; - public MongoDbIncludeProjectionOperation ( - string field) - { - _path = Ensure.IsNotNull(field, nameof(field)); - } + public MongoDbIncludeProjectionOperation( + string field) + { + _path = Ensure.IsNotNull(field, nameof(field)); + } - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) - { - StringFieldDefinitionHelper.Resolve( - _path, - documentSerializer, - out string? resolvedFieldName, - out IBsonSerializer? _); + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + StringFieldDefinitionHelper.Resolve( + _path, + documentSerializer, + out string? resolvedFieldName, + out IBsonSerializer? _); - return new BsonDocument(resolvedFieldName ?? _path, 1); - } + return new BsonDocument(resolvedFieldName ?? _path, 1); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbProjectionDefinition.cs b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbProjectionDefinition.cs index 9aacf16b54e..04327f19469 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbProjectionDefinition.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbProjectionDefinition.cs @@ -3,55 +3,54 @@ using MongoDB.Driver; using MongoDB.Driver.Linq; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +public abstract class MongoDbProjectionDefinition : ProjectionDefinition { - public abstract class MongoDbProjectionDefinition : ProjectionDefinition + public abstract BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry); + + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + return Render(documentSerializer, serializerRegistry); + } + + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry, + LinqProvider provider) + { + return Render(documentSerializer, serializerRegistry); + } + + public ProjectionDefinition ToProjectionDefinition() => + new ProjectionDefinitionWrapper(this); + + private sealed class ProjectionDefinitionWrapper : ProjectionDefinition { - public abstract BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry); + private readonly MongoDbProjectionDefinition _filter; + + public ProjectionDefinitionWrapper(MongoDbProjectionDefinition filter) + { + _filter = filter; + } public override BsonDocument Render( - IBsonSerializer documentSerializer, + IBsonSerializer documentSerializer, IBsonSerializerRegistry serializerRegistry) { - return Render(documentSerializer, serializerRegistry); + return _filter.Render(documentSerializer, serializerRegistry); } public override BsonDocument Render( - IBsonSerializer documentSerializer, + IBsonSerializer documentSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider provider) { return Render(documentSerializer, serializerRegistry); } - - public ProjectionDefinition ToProjectionDefinition() => - new ProjectionDefinitionWrapper(this); - - private sealed class ProjectionDefinitionWrapper : ProjectionDefinition - { - private readonly MongoDbProjectionDefinition _filter; - - public ProjectionDefinitionWrapper(MongoDbProjectionDefinition filter) - { - _filter = filter; - } - - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) - { - return _filter.Render(documentSerializer, serializerRegistry); - } - - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry, - LinqProvider provider) - { - return Render(documentSerializer, serializerRegistry); - } - } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbSortDefinition.cs b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbSortDefinition.cs index 97c3c1f9d58..f62fd986ad4 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbSortDefinition.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/MongoDbSortDefinition.cs @@ -3,54 +3,53 @@ using MongoDB.Driver; using MongoDB.Driver.Linq; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +public abstract class MongoDbSortDefinition : SortDefinition { - public abstract class MongoDbSortDefinition : SortDefinition + public abstract BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry); + + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + return Render(documentSerializer, serializerRegistry); + } + + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry, + LinqProvider provider) + { + return Render(documentSerializer, serializerRegistry); + } + + public SortDefinition ToSortDefinition() => new SortDefinitionWrapper(this); + + private sealed class SortDefinitionWrapper : SortDefinition { - public abstract BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry); + private readonly MongoDbSortDefinition _sort; + + public SortDefinitionWrapper(MongoDbSortDefinition sort) + { + _sort = sort; + } public override BsonDocument Render( - IBsonSerializer documentSerializer, + IBsonSerializer documentSerializer, IBsonSerializerRegistry serializerRegistry) { - return Render(documentSerializer, serializerRegistry); + return _sort.Render(documentSerializer, serializerRegistry); } public override BsonDocument Render( - IBsonSerializer documentSerializer, + IBsonSerializer documentSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider provider) { return Render(documentSerializer, serializerRegistry); } - - public SortDefinition ToSortDefinition() => new SortDefinitionWrapper(this); - - private sealed class SortDefinitionWrapper : SortDefinition - { - private readonly MongoDbSortDefinition _sort; - - public SortDefinitionWrapper(MongoDbSortDefinition sort) - { - _sort = sort; - } - - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) - { - return _sort.Render(documentSerializer, serializerRegistry); - } - - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry, - LinqProvider provider) - { - return Render(documentSerializer, serializerRegistry); - } - } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/NotMongoDbFilterDefinition.cs b/src/HotChocolate/MongoDb/src/Data/Driver/NotMongoDbFilterDefinition.cs index 69cdaf59ded..548dac2e261 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/NotMongoDbFilterDefinition.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/NotMongoDbFilterDefinition.cs @@ -2,128 +2,127 @@ using MongoDB.Bson; using MongoDB.Bson.Serialization; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// This class was ported over from the official mongo db driver +/// +public sealed class NotMongoDbFilterDefinition : MongoDbFilterDefinition { - /// - /// This class was ported over from the official mongo db driver - /// - public sealed class NotMongoDbFilterDefinition : MongoDbFilterDefinition + private readonly MongoDbFilterDefinition _filter; + + public NotMongoDbFilterDefinition(MongoDbFilterDefinition filter) { - private readonly MongoDbFilterDefinition _filter; + _filter = filter; + } - public NotMongoDbFilterDefinition(MongoDbFilterDefinition filter) - { - _filter = filter; - } + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + var renderedFilter = _filter.Render(documentSerializer, serializerRegistry); - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) + if (renderedFilter.ElementCount == 1) { - var renderedFilter = _filter.Render(documentSerializer, serializerRegistry); + return NegateSingleElementFilter(renderedFilter, renderedFilter.GetElement(0)); + } - if (renderedFilter.ElementCount == 1) - { - return NegateSingleElementFilter(renderedFilter, renderedFilter.GetElement(0)); - } + return NegateArbitraryFilter(renderedFilter); + } - return NegateArbitraryFilter(renderedFilter); + private static BsonDocument NegateArbitraryFilter(BsonDocument filter) + { + if (filter.ElementCount == 1 && + filter.GetElement(0).Name.StartsWith("$", StringComparison.Ordinal)) + { + return new BsonDocument("$not", filter); } - - private static BsonDocument NegateArbitraryFilter(BsonDocument filter) + else { - if (filter.ElementCount == 1 && - filter.GetElement(0).Name.StartsWith("$", StringComparison.Ordinal)) - { - return new BsonDocument("$not", filter); - } - else - { - // $not only works as a meta operator on a single operator so simulate Not using $nor - return new BsonDocument("$nor", new BsonArray { filter }); - } + // $not only works as a meta operator on a single operator so simulate Not using $nor + return new BsonDocument("$nor", new BsonArray { filter }); } + } - private static BsonDocument NegateSingleElementFilter( - BsonDocument filter, - BsonElement element) + private static BsonDocument NegateSingleElementFilter( + BsonDocument filter, + BsonElement element) + { + if (element.Name[0] == '$') { - if (element.Name[0] == '$') - { - return NegateSingleElementTopLevelOperatorFilter(filter, element); - } + return NegateSingleElementTopLevelOperatorFilter(filter, element); + } - if (element.Value is BsonDocument) + if (element.Value is BsonDocument) + { + var selector = (BsonDocument)element.Value; + if (selector.ElementCount >= 1) { - var selector = (BsonDocument)element.Value; - if (selector.ElementCount >= 1) + var operatorName = selector.GetElement(0).Name; + if (operatorName[0] == '$' && operatorName != "$ref") { - var operatorName = selector.GetElement(0).Name; - if (operatorName[0] == '$' && operatorName != "$ref") + if (selector.ElementCount == 1) { - if (selector.ElementCount == 1) - { - return NegateSingleFieldOperatorFilter( - element.Name, - selector.GetElement(0)); - } - - return NegateArbitraryFilter(filter); + return NegateSingleFieldOperatorFilter( + element.Name, + selector.GetElement(0)); } - } - } - if (element.Value is BsonRegularExpression) - { - return new BsonDocument(element.Name, new BsonDocument("$not", element.Value)); + return NegateArbitraryFilter(filter); + } } + } - return new BsonDocument(element.Name, new BsonDocument("$ne", element.Value)); + if (element.Value is BsonRegularExpression) + { + return new BsonDocument(element.Name, new BsonDocument("$not", element.Value)); } - private static BsonDocument NegateSingleFieldOperatorFilter( - string field, - BsonElement element) + return new BsonDocument(element.Name, new BsonDocument("$ne", element.Value)); + } + + private static BsonDocument NegateSingleFieldOperatorFilter( + string field, + BsonElement element) + { + switch (element.Name) { - switch (element.Name) - { - case "$exists": - return new BsonDocument( - field, - new BsonDocument("$exists", !element.Value.ToBoolean())); - case "$in": - return new BsonDocument( - field, - new BsonDocument("$nin", (BsonArray)element.Value)); - case "$ne": - case "$not": - return new BsonDocument(field, element.Value); - case "$nin": - return new BsonDocument( - field, - new BsonDocument("$in", (BsonArray)element.Value)); - default: - return new BsonDocument( - field, - new BsonDocument("$not", new BsonDocument(element))); - } + case "$exists": + return new BsonDocument( + field, + new BsonDocument("$exists", !element.Value.ToBoolean())); + case "$in": + return new BsonDocument( + field, + new BsonDocument("$nin", (BsonArray)element.Value)); + case "$ne": + case "$not": + return new BsonDocument(field, element.Value); + case "$nin": + return new BsonDocument( + field, + new BsonDocument("$in", (BsonArray)element.Value)); + default: + return new BsonDocument( + field, + new BsonDocument("$not", new BsonDocument(element))); } + } - private static BsonDocument NegateSingleElementTopLevelOperatorFilter( - BsonDocument filter, - BsonElement element) + private static BsonDocument NegateSingleElementTopLevelOperatorFilter( + BsonDocument filter, + BsonElement element) + { + switch (element.Name) { - switch (element.Name) - { - case "$and": - return new BsonDocument("$nor", new BsonArray { filter }); - case "$or": - return new BsonDocument("$nor", element.Value); - case "$nor": - return new BsonDocument("$or", element.Value); - default: - return NegateArbitraryFilter(filter); - } + case "$and": + return new BsonDocument("$nor", new BsonArray { filter }); + case "$or": + return new BsonDocument("$nor", element.Value); + case "$nor": + return new BsonDocument("$or", element.Value); + default: + return NegateArbitraryFilter(filter); } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/OrMongoDbFilterDefinition.cs b/src/HotChocolate/MongoDb/src/Data/Driver/OrMongoDbFilterDefinition.cs index 973c7c0b843..191d49d376f 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/OrMongoDbFilterDefinition.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/OrMongoDbFilterDefinition.cs @@ -3,53 +3,52 @@ using MongoDB.Bson; using MongoDB.Bson.Serialization; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// This class was ported over from the official mongo db driver +/// +public sealed class OrMongoDbFilterDefinition : MongoDbFilterDefinition { - /// - /// This class was ported over from the official mongo db driver - /// - public sealed class OrMongoDbFilterDefinition : MongoDbFilterDefinition + private readonly List _filters; + + public OrMongoDbFilterDefinition(params MongoDbFilterDefinition[] filters) + : this(filters.AsEnumerable()) { - private readonly List _filters; + } - public OrMongoDbFilterDefinition(params MongoDbFilterDefinition[] filters) - : this(filters.AsEnumerable()) - { - } + public OrMongoDbFilterDefinition(IEnumerable filters) + { + _filters = filters.ToList(); + } - public OrMongoDbFilterDefinition(IEnumerable filters) - { - _filters = filters.ToList(); - } + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + var clauses = new BsonArray(); - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) + foreach (var filter in _filters) { - var clauses = new BsonArray(); + BsonDocument renderedFilter = filter.Render(documentSerializer, serializerRegistry); + AddClause(clauses, renderedFilter); + } - foreach (var filter in _filters) - { - BsonDocument renderedFilter = filter.Render(documentSerializer, serializerRegistry); - AddClause(clauses, renderedFilter); - } + return new BsonDocument("$or", clauses); + } - return new BsonDocument("$or", clauses); + private static void AddClause(BsonArray clauses, BsonDocument filter) + { + if (filter.ElementCount == 1 && filter.GetElement(0).Name == "$or") + { + // flatten nested $or + clauses.AddRange((BsonArray)filter[0]); } - - private static void AddClause(BsonArray clauses, BsonDocument filter) + else { - if (filter.ElementCount == 1 && filter.GetElement(0).Name == "$or") - { - // flatten nested $or - clauses.AddRange((BsonArray)filter[0]); - } - else - { - // we could shortcut the user's query if there are no elements in the filter, but - // I'd rather be literal and let them discover the problem on their own. - clauses.Add(filter); - } + // we could shortcut the user's query if there are no elements in the filter, but + // I'd rather be literal and let them discover the problem on their own. + clauses.Add(filter); } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/SortDefinitionExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Driver/SortDefinitionExtensions.cs index 41705be6fd6..a27b0eae18e 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/SortDefinitionExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/SortDefinitionExtensions.cs @@ -2,35 +2,34 @@ using MongoDB.Bson.Serialization; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +public static class SortDefinitionExtensions { - public static class SortDefinitionExtensions + public static MongoDbSortDefinition Wrap(this SortDefinition sortDefinition) => + new SortDefinitionWrapper(sortDefinition); + + private sealed class SortDefinitionWrapper : MongoDbSortDefinition { - public static MongoDbSortDefinition Wrap(this SortDefinition sortDefinition) => - new SortDefinitionWrapper(sortDefinition); + private readonly SortDefinition _sort; - private sealed class SortDefinitionWrapper : MongoDbSortDefinition + public SortDefinitionWrapper(SortDefinition sort) { - private readonly SortDefinition _sort; + _sort = sort; + } - public SortDefinitionWrapper(SortDefinition sort) + public override BsonDocument Render( + IBsonSerializer documentSerializer, + IBsonSerializerRegistry serializerRegistry) + { + if (documentSerializer is IBsonSerializer typedSerializer) { - _sort = sort; + return _sort.Render(typedSerializer, serializerRegistry); } - public override BsonDocument Render( - IBsonSerializer documentSerializer, - IBsonSerializerRegistry serializerRegistry) - { - if (documentSerializer is IBsonSerializer typedSerializer) - { - return _sort.Render(typedSerializer, serializerRegistry); - } - - return _sort.Render( - serializerRegistry.GetSerializer(), - serializerRegistry); - } + return _sort.Render( + serializerRegistry.GetSerializer(), + serializerRegistry); } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Driver/StringFieldDefinitionHelper.cs b/src/HotChocolate/MongoDb/src/Data/Driver/StringFieldDefinitionHelper.cs index fca1207db72..1cf39bf5f7d 100644 --- a/src/HotChocolate/MongoDb/src/Data/Driver/StringFieldDefinitionHelper.cs +++ b/src/HotChocolate/MongoDb/src/Data/Driver/StringFieldDefinitionHelper.cs @@ -2,113 +2,112 @@ using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Serializers; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// This class was ported over from the official mongo db driver +/// +public static class StringFieldDefinitionHelper { - /// - /// This class was ported over from the official mongo db driver - /// - public static class StringFieldDefinitionHelper + public static void Resolve( + string fieldName, + IBsonSerializer serializer, + out string? resolvedFieldName, + out IBsonSerializer? resolvedFieldSerializer) { - public static void Resolve( - string fieldName, - IBsonSerializer serializer, - out string? resolvedFieldName, - out IBsonSerializer? resolvedFieldSerializer) - { - BsonSerializationInfo serializationInfo; + BsonSerializationInfo serializationInfo; - resolvedFieldName = fieldName; - resolvedFieldSerializer = null; + resolvedFieldName = fieldName; + resolvedFieldSerializer = null; - var documentSerializer = serializer as IBsonDocumentSerializer; - if (serializer is IBsonArraySerializer bsonArraySerializer && - bsonArraySerializer.TryGetItemSerializationInfo(out serializationInfo)) - { - resolvedFieldSerializer = serializationInfo.Serializer; - documentSerializer = serializationInfo.Serializer as IBsonDocumentSerializer; - } + var documentSerializer = serializer as IBsonDocumentSerializer; + if (serializer is IBsonArraySerializer bsonArraySerializer && + bsonArraySerializer.TryGetItemSerializationInfo(out serializationInfo)) + { + resolvedFieldSerializer = serializationInfo.Serializer; + documentSerializer = serializationInfo.Serializer as IBsonDocumentSerializer; + } - if (documentSerializer == null) - { - return; - } + if (documentSerializer == null) + { + return; + } - // shortcut BsonDocumentSerializer since it is so common - if (serializer.GetType() == typeof(BsonDocumentSerializer)) - { - return; - } + // shortcut BsonDocumentSerializer since it is so common + if (serializer.GetType() == typeof(BsonDocumentSerializer)) + { + return; + } - // first, lets try the quick and easy one, which will be a majority of cases - if (documentSerializer.TryGetMemberSerializationInfo(fieldName, out serializationInfo)) - { - resolvedFieldName = serializationInfo.ElementName; - resolvedFieldSerializer = serializationInfo.Serializer; - return; - } + // first, lets try the quick and easy one, which will be a majority of cases + if (documentSerializer.TryGetMemberSerializationInfo(fieldName, out serializationInfo)) + { + resolvedFieldName = serializationInfo.ElementName; + resolvedFieldSerializer = serializationInfo.Serializer; + return; + } - // now lets go and do the more difficult variant - string[] nameParts = fieldName.Split('.'); - if (nameParts.Length <= 1) - { - // if we only have 1, then it's no different than what we did above - // when we found nothing. - return; - } + // now lets go and do the more difficult variant + string[] nameParts = fieldName.Split('.'); + if (nameParts.Length <= 1) + { + // if we only have 1, then it's no different than what we did above + // when we found nothing. + return; + } - IBsonArraySerializer? arraySerializer; - resolvedFieldSerializer = documentSerializer; - for (int i = 0; i < nameParts.Length; i++) + IBsonArraySerializer? arraySerializer; + resolvedFieldSerializer = documentSerializer; + for (int i = 0; i < nameParts.Length; i++) + { + if (nameParts[i] == "$" || nameParts[i].All(char.IsDigit)) { - if (nameParts[i] == "$" || nameParts[i].All(char.IsDigit)) + arraySerializer = resolvedFieldSerializer as IBsonArraySerializer; + if (resolvedFieldSerializer is IBsonArraySerializer && + arraySerializer is { } && + arraySerializer.TryGetItemSerializationInfo(out serializationInfo)) { - arraySerializer = resolvedFieldSerializer as IBsonArraySerializer; - if (resolvedFieldSerializer is IBsonArraySerializer && - arraySerializer is {} && - arraySerializer.TryGetItemSerializationInfo(out serializationInfo)) - { - resolvedFieldSerializer = serializationInfo.Serializer; - continue; - } - - resolvedFieldSerializer = null; - break; + resolvedFieldSerializer = serializationInfo.Serializer; + continue; } - documentSerializer = resolvedFieldSerializer as IBsonDocumentSerializer; - if (documentSerializer == null || - !documentSerializer.TryGetMemberSerializationInfo( - nameParts[i], - out serializationInfo)) + resolvedFieldSerializer = null; + break; + } + + documentSerializer = resolvedFieldSerializer as IBsonDocumentSerializer; + if (documentSerializer == null || + !documentSerializer.TryGetMemberSerializationInfo( + nameParts[i], + out serializationInfo)) + { + // need to check if this is an any element array match + arraySerializer = resolvedFieldSerializer as IBsonArraySerializer; + if (arraySerializer != null && + arraySerializer.TryGetItemSerializationInfo(out serializationInfo)) { - // need to check if this is an any element array match - arraySerializer = resolvedFieldSerializer as IBsonArraySerializer; - if (arraySerializer != null && - arraySerializer.TryGetItemSerializationInfo(out serializationInfo)) - { - documentSerializer = - serializationInfo.Serializer as IBsonDocumentSerializer; - if (documentSerializer == null || - !documentSerializer.TryGetMemberSerializationInfo( - nameParts[i], - out serializationInfo)) - { - resolvedFieldSerializer = null; - break; - } - } - else + documentSerializer = + serializationInfo.Serializer as IBsonDocumentSerializer; + if (documentSerializer == null || + !documentSerializer.TryGetMemberSerializationInfo( + nameParts[i], + out serializationInfo)) { resolvedFieldSerializer = null; break; } } - - nameParts[i] = serializationInfo.ElementName; - resolvedFieldSerializer = serializationInfo.Serializer; + else + { + resolvedFieldSerializer = null; + break; + } } - resolvedFieldName = string.Join(".", nameParts); + nameParts[i] = serializationInfo.ElementName; + resolvedFieldSerializer = serializationInfo.Serializer; } + + resolvedFieldName = string.Join(".", nameParts); } } diff --git a/src/HotChocolate/MongoDb/src/Data/ErrorHelper.cs b/src/HotChocolate/MongoDb/src/Data/ErrorHelper.cs index 141939d8ea0..7ed79b47955 100644 --- a/src/HotChocolate/MongoDb/src/Data/ErrorHelper.cs +++ b/src/HotChocolate/MongoDb/src/Data/ErrorHelper.cs @@ -4,52 +4,51 @@ using HotChocolate.Language; using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +internal static class ErrorHelper { - internal static class ErrorHelper + public static IError CreateNonNullError( + IFilterField field, + IValueNode value, + IFilterVisitorContext context, + bool isMemberInvalid = false) { - public static IError CreateNonNullError( - IFilterField field, - IValueNode value, - IFilterVisitorContext context, - bool isMemberInvalid = false) - { - IFilterInputType filterType = context.Types.OfType().First(); + IFilterInputType filterType = context.Types.OfType().First(); - INullabilityNode nullability = - isMemberInvalid && field.Type.IsListType() - ? new ListNullabilityNode(null, new RequiredModifierNode(null, null)) - : new RequiredModifierNode(null, null); + INullabilityNode nullability = + isMemberInvalid && field.Type.IsListType() + ? new ListNullabilityNode(null, new RequiredModifierNode(null, null)) + : new RequiredModifierNode(null, null); - return ErrorBuilder.New() - .SetMessage( - MongoDbResources.ErrorHelper_Filtering_CreateNonNullError, - context.Operations.Peek().Name, - filterType.Print()) - .AddLocation(value) - .SetCode(ErrorCodes.Data.NonNullError) - .SetExtension("expectedType", field.Type.RewriteNullability(nullability).Print()) - .SetExtension("filterType", filterType.Print()) - .Build(); - } + return ErrorBuilder.New() + .SetMessage( + MongoDbResources.ErrorHelper_Filtering_CreateNonNullError, + context.Operations.Peek().Name, + filterType.Print()) + .AddLocation(value) + .SetCode(ErrorCodes.Data.NonNullError) + .SetExtension("expectedType", field.Type.RewriteNullability(nullability).Print()) + .SetExtension("filterType", filterType.Print()) + .Build(); + } - public static IError CreateNonNullError( - ISortField field, - IValueNode value, - ISortVisitorContext context) - { - ISortInputType sortType = context.Types.OfType().First(); + public static IError CreateNonNullError( + ISortField field, + IValueNode value, + ISortVisitorContext context) + { + ISortInputType sortType = context.Types.OfType().First(); - return ErrorBuilder.New() - .SetMessage( - MongoDbResources.ErrorHelper_Filtering_CreateNonNullError, - context.Fields.Peek().Name, - sortType.Print()) - .AddLocation(value) - .SetCode(ErrorCodes.Data.NonNullError) - .SetExtension("expectedType", new NonNullType(field.Type).Print()) - .SetExtension("sortType", sortType.Print()) - .Build(); - } + return ErrorBuilder.New() + .SetMessage( + MongoDbResources.ErrorHelper_Filtering_CreateNonNullError, + context.Fields.Peek().Name, + sortType.Print()) + .AddLocation(value) + .SetCode(ErrorCodes.Data.NonNullError) + .SetExtension("expectedType", new NonNullType(field.Type).Print()) + .SetExtension("sortType", sortType.Print()) + .Build(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Execution/IMongoDbExecutable.cs b/src/HotChocolate/MongoDb/src/Data/Execution/IMongoDbExecutable.cs index f4ef7f8923f..bf5eef1fe16 100644 --- a/src/HotChocolate/MongoDb/src/Data/Execution/IMongoDbExecutable.cs +++ b/src/HotChocolate/MongoDb/src/Data/Execution/IMongoDbExecutable.cs @@ -1,29 +1,28 @@ -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// Represents a executable for the MongoDb. +/// +public interface IMongoDbExecutable : IExecutable { /// - /// Represents a executable for the MongoDb. + /// Applies the filter definition to the executable /// - public interface IMongoDbExecutable : IExecutable - { - /// - /// Applies the filter definition to the executable - /// - /// The filter definition - /// A executable that contains the filter definition - IMongoDbExecutable WithFiltering(MongoDbFilterDefinition filters); + /// The filter definition + /// A executable that contains the filter definition + IMongoDbExecutable WithFiltering(MongoDbFilterDefinition filters); - /// - /// Applies the sorting definition to the executable - /// - /// The sorting definition - /// A executable that contains the sorting definition - IMongoDbExecutable WithSorting(MongoDbSortDefinition sorting); + /// + /// Applies the sorting definition to the executable + /// + /// The sorting definition + /// A executable that contains the sorting definition + IMongoDbExecutable WithSorting(MongoDbSortDefinition sorting); - /// - /// Applies the projection definition to the executable - /// - /// The projection definition - /// A executable that contains the projection definition - IMongoDbExecutable WithProjection(MongoDbProjectionDefinition projection); - } + /// + /// Applies the projection definition to the executable + /// + /// The projection definition + /// A executable that contains the projection definition + IMongoDbExecutable WithProjection(MongoDbProjectionDefinition projection); } diff --git a/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbAggregateFluentExecutable.cs b/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbAggregateFluentExecutable.cs index 4920966b88a..9c87015fc8a 100644 --- a/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbAggregateFluentExecutable.cs +++ b/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbAggregateFluentExecutable.cs @@ -3,70 +3,69 @@ using System.Threading.Tasks; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// A executable that is based on +/// +/// The entity type +public class MongoDbAggregateFluentExecutable : MongoDbExecutable { - /// - /// A executable that is based on - /// - /// The entity type - public class MongoDbAggregateFluentExecutable : MongoDbExecutable - { - private readonly IAggregateFluent _aggregate; + private readonly IAggregateFluent _aggregate; - public MongoDbAggregateFluentExecutable(IAggregateFluent aggregate) - { - _aggregate = aggregate; - } + public MongoDbAggregateFluentExecutable(IAggregateFluent aggregate) + { + _aggregate = aggregate; + } - /// - public override object Source => _aggregate; + /// + public override object Source => _aggregate; - /// - public override async ValueTask ToListAsync(CancellationToken cancellationToken) => - await BuildPipeline() - .ToListAsync(cancellationToken) - .ConfigureAwait(false); + /// + public override async ValueTask ToListAsync(CancellationToken cancellationToken) => + await BuildPipeline() + .ToListAsync(cancellationToken) + .ConfigureAwait(false); - /// - public override async ValueTask FirstOrDefaultAsync( - CancellationToken cancellationToken) => - await BuildPipeline() - .FirstOrDefaultAsync(cancellationToken) - .ConfigureAwait(false); + /// + public override async ValueTask FirstOrDefaultAsync( + CancellationToken cancellationToken) => + await BuildPipeline() + .FirstOrDefaultAsync(cancellationToken) + .ConfigureAwait(false); - /// - public override async ValueTask SingleOrDefaultAsync( - CancellationToken cancellationToken) => - await BuildPipeline() - .SingleOrDefaultAsync(cancellationToken) - .ConfigureAwait(false); + /// + public override async ValueTask SingleOrDefaultAsync( + CancellationToken cancellationToken) => + await BuildPipeline() + .SingleOrDefaultAsync(cancellationToken) + .ConfigureAwait(false); - /// - public override string Print() => BuildPipeline().ToString() ?? ""; + /// + public override string Print() => BuildPipeline().ToString() ?? ""; - /// - /// Applies filtering sorting and projections on the - /// - /// A aggregate fluent including the configuration of this executable - public IAggregateFluent BuildPipeline() + /// + /// Applies filtering sorting and projections on the + /// + /// A aggregate fluent including the configuration of this executable + public IAggregateFluent BuildPipeline() + { + IAggregateFluent pipeline = _aggregate; + if (Sorting is not null) { - IAggregateFluent pipeline = _aggregate; - if (Sorting is not null) - { - pipeline = pipeline.Sort(Sorting.ToSortDefinition()); - } - - if (Filters is not null) - { - pipeline = pipeline.Match(Filters.ToFilterDefinition()); - } + pipeline = pipeline.Sort(Sorting.ToSortDefinition()); + } - if (Projection is not null) - { - pipeline = pipeline.Project(Projection.ToProjectionDefinition()); - } + if (Filters is not null) + { + pipeline = pipeline.Match(Filters.ToFilterDefinition()); + } - return pipeline; + if (Projection is not null) + { + pipeline = pipeline.Project(Projection.ToProjectionDefinition()); } + + return pipeline; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbCollectionExecutable.cs b/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbCollectionExecutable.cs index 0f702c9f97f..52f2c7f51ef 100644 --- a/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbCollectionExecutable.cs +++ b/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbCollectionExecutable.cs @@ -5,116 +5,115 @@ using MongoDB.Bson.Serialization; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// A executable that is based on +/// +/// The entity type +public class MongoDbCollectionExecutable : MongoDbExecutable { + private readonly IMongoCollection _collection; + + /// + public MongoDbCollectionExecutable(IMongoCollection collection) + { + _collection = collection; + } + + /// + public override object Source => _collection; + + /// + /// The options that were set by + /// + protected FindOptionsBase? Options { get; private set; } + /// - /// A executable that is based on + /// Applies the options to the executable /// - /// The entity type - public class MongoDbCollectionExecutable : MongoDbExecutable + /// The options + /// A executable that contains the options + public IMongoDbExecutable WithOptions(FindOptionsBase options) { - private readonly IMongoCollection _collection; + Options = options; + return this; + } - /// - public MongoDbCollectionExecutable(IMongoCollection collection) - { - _collection = collection; - } + /// + public override async ValueTask ToListAsync(CancellationToken cancellationToken) + { + IBsonSerializerRegistry serializers = _collection.Settings.SerializerRegistry; + IBsonSerializer bsonSerializer = _collection.DocumentSerializer; - /// - public override object Source => _collection; + FindOptions options = Options as FindOptions ?? new FindOptions(); + BsonDocument filters = new BsonDocument(); - /// - /// The options that were set by - /// - protected FindOptionsBase? Options { get; private set; } + if (Sorting is not null) + { + options.Sort = Sorting.Render(bsonSerializer, serializers); + } - /// - /// Applies the options to the executable - /// - /// The options - /// A executable that contains the options - public IMongoDbExecutable WithOptions(FindOptionsBase options) + if (Projection is not null) { - Options = options; - return this; + options.Projection = Projection.Render(bsonSerializer, serializers); } - /// - public override async ValueTask ToListAsync(CancellationToken cancellationToken) + if (Filters is not null) { - IBsonSerializerRegistry serializers = _collection.Settings.SerializerRegistry; - IBsonSerializer bsonSerializer = _collection.DocumentSerializer; + filters = Filters.Render(bsonSerializer, serializers); + } - FindOptions options = Options as FindOptions ?? new FindOptions(); - BsonDocument filters = new BsonDocument(); + IAsyncCursor cursor = await _collection + .FindAsync(filters, options, cancellationToken) + .ConfigureAwait(false); - if (Sorting is not null) - { - options.Sort = Sorting.Render(bsonSerializer, serializers); - } + return await cursor.ToListAsync(cancellationToken).ConfigureAwait(false); + } - if (Projection is not null) - { - options.Projection = Projection.Render(bsonSerializer, serializers); - } + /// + public override async ValueTask FirstOrDefaultAsync( + CancellationToken cancellationToken) => + await BuildPipeline() + .FirstOrDefaultAsync(cancellationToken) + .ConfigureAwait(false); - if (Filters is not null) - { - filters = Filters.Render(bsonSerializer, serializers); - } + /// + public override async ValueTask SingleOrDefaultAsync( + CancellationToken cancellationToken) => + await BuildPipeline() + .SingleOrDefaultAsync(cancellationToken) + .ConfigureAwait(false); - IAsyncCursor cursor = await _collection - .FindAsync(filters, options, cancellationToken) - .ConfigureAwait(false); + /// + public override string Print() => BuildPipeline().ToString() ?? ""; - return await cursor.ToListAsync(cancellationToken).ConfigureAwait(false); - } + /// + /// Applies filtering sorting and projections on the + /// + /// A find fluent including the configuration of this executable + public IFindFluent BuildPipeline() + { + FindOptions options = Options as FindOptions ?? new FindOptions(); + FilterDefinition filters = FilterDefinition.Empty; - /// - public override async ValueTask FirstOrDefaultAsync( - CancellationToken cancellationToken) => - await BuildPipeline() - .FirstOrDefaultAsync(cancellationToken) - .ConfigureAwait(false); - - /// - public override async ValueTask SingleOrDefaultAsync( - CancellationToken cancellationToken) => - await BuildPipeline() - .SingleOrDefaultAsync(cancellationToken) - .ConfigureAwait(false); - - /// - public override string Print() => BuildPipeline().ToString() ?? ""; - - /// - /// Applies filtering sorting and projections on the - /// - /// A find fluent including the configuration of this executable - public IFindFluent BuildPipeline() + if (Filters is not null) { - FindOptions options = Options as FindOptions ?? new FindOptions(); - FilterDefinition filters = FilterDefinition.Empty; - - if (Filters is not null) - { - filters = Filters.ToFilterDefinition(); - } - - IFindFluent pipeline = _collection.Find(filters, options); + filters = Filters.ToFilterDefinition(); + } - if (Sorting is not null) - { - pipeline = pipeline.Sort(Sorting.ToSortDefinition()); - } + IFindFluent pipeline = _collection.Find(filters, options); - if (Projection is not null) - { - pipeline = pipeline.Project(Projection.ToProjectionDefinition()); - } + if (Sorting is not null) + { + pipeline = pipeline.Sort(Sorting.ToSortDefinition()); + } - return pipeline; + if (Projection is not null) + { + pipeline = pipeline.Project(Projection.ToProjectionDefinition()); } + + return pipeline; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbExecutable.cs b/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbExecutable.cs index 4e0d6a3820d..add8c5ad520 100644 --- a/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbExecutable.cs +++ b/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbExecutable.cs @@ -2,65 +2,64 @@ using System.Threading; using System.Threading.Tasks; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// Is the base class for a executable for the MongoDb. +/// +public abstract class MongoDbExecutable + : IExecutable + , IMongoDbExecutable { /// - /// Is the base class for a executable for the MongoDb. + /// The filter definition that was set by /// - public abstract class MongoDbExecutable - : IExecutable - , IMongoDbExecutable - { - /// - /// The filter definition that was set by - /// - protected MongoDbFilterDefinition? Filters { get; private set; } + protected MongoDbFilterDefinition? Filters { get; private set; } - /// - /// The sort definition that was set by - /// - protected MongoDbSortDefinition? Sorting { get; private set; } + /// + /// The sort definition that was set by + /// + protected MongoDbSortDefinition? Sorting { get; private set; } - /// - /// The projection definition that was set by - /// - protected MongoDbProjectionDefinition? Projection { get; private set; } + /// + /// The projection definition that was set by + /// + protected MongoDbProjectionDefinition? Projection { get; private set; } - /// - public IMongoDbExecutable WithFiltering(MongoDbFilterDefinition filters) - { - Filters = filters; - return this; - } + /// + public IMongoDbExecutable WithFiltering(MongoDbFilterDefinition filters) + { + Filters = filters; + return this; + } - /// - public IMongoDbExecutable WithSorting(MongoDbSortDefinition sorting) - { - Sorting = sorting; - return this; - } + /// + public IMongoDbExecutable WithSorting(MongoDbSortDefinition sorting) + { + Sorting = sorting; + return this; + } - /// - public IMongoDbExecutable WithProjection(MongoDbProjectionDefinition projection) - { - Projection = projection; - return this; - } + /// + public IMongoDbExecutable WithProjection(MongoDbProjectionDefinition projection) + { + Projection = projection; + return this; + } - /// - public abstract object Source { get; } + /// + public abstract object Source { get; } - /// - public abstract ValueTask ToListAsync(CancellationToken cancellationToken); + /// + public abstract ValueTask ToListAsync(CancellationToken cancellationToken); - /// - public abstract ValueTask FirstOrDefaultAsync(CancellationToken cancellationToken); + /// + public abstract ValueTask FirstOrDefaultAsync(CancellationToken cancellationToken); - /// - public abstract ValueTask SingleOrDefaultAsync( - CancellationToken cancellationToken); + /// + public abstract ValueTask SingleOrDefaultAsync( + CancellationToken cancellationToken); - /// - public abstract string Print(); - } + /// + public abstract string Print(); } diff --git a/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbExecutableExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbExecutableExtensions.cs index a8c3c44cca0..14c442d3569 100644 --- a/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbExecutableExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbExecutableExtensions.cs @@ -1,50 +1,49 @@ using HotChocolate.Data.MongoDb; using MongoDB.Driver; -namespace HotChocolate.Data +namespace HotChocolate.Data; + +public static class MongoDbExecutableExtensions { - public static class MongoDbExecutableExtensions + /// + /// Wraps a with + /// to help the execution engine to execute it + /// more efficiently + /// + /// The source of the + /// The type parameter + /// The wrapped object + public static MongoDbCollectionExecutable AsExecutable( + this IMongoCollection collection) { - /// - /// Wraps a with - /// to help the execution engine to execute it - /// more efficiently - /// - /// The source of the - /// The type parameter - /// The wrapped object - public static MongoDbCollectionExecutable AsExecutable( - this IMongoCollection collection) - { - return new MongoDbCollectionExecutable(collection); - } + return new MongoDbCollectionExecutable(collection); + } - /// - /// Wraps a with - /// to help the execution engine to execute it - /// more efficiently - /// - /// The source of the - /// The type parameter - /// The wrapped object - public static MongoDbAggregateFluentExecutable AsExecutable( - this IAggregateFluent aggregate) - { - return new MongoDbAggregateFluentExecutable(aggregate); - } + /// + /// Wraps a with + /// to help the execution engine to execute it + /// more efficiently + /// + /// The source of the + /// The type parameter + /// The wrapped object + public static MongoDbAggregateFluentExecutable AsExecutable( + this IAggregateFluent aggregate) + { + return new MongoDbAggregateFluentExecutable(aggregate); + } - /// - /// Wraps a with - /// to help the execution engine to execute it - /// more efficiently - /// - /// The source of the - /// The type parameter - /// The wrapped object - public static MongoDbFindFluentExecutable AsExecutable( - this IFindFluent collection) - { - return new MongoDbFindFluentExecutable(collection); - } + /// + /// Wraps a with + /// to help the execution engine to execute it + /// more efficiently + /// + /// The source of the + /// The type parameter + /// The wrapped object + public static MongoDbFindFluentExecutable AsExecutable( + this IFindFluent collection) + { + return new MongoDbFindFluentExecutable(collection); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbFindFluentExecutable.cs b/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbFindFluentExecutable.cs index 7f1e5edd9e2..12fa4a2ef05 100644 --- a/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbFindFluentExecutable.cs +++ b/src/HotChocolate/MongoDb/src/Data/Execution/MongoDbFindFluentExecutable.cs @@ -3,82 +3,81 @@ using System.Threading.Tasks; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// A executable that is based on +/// +/// The entity type +public class MongoDbFindFluentExecutable : MongoDbExecutable { - /// - /// A executable that is based on - /// - /// The entity type - public class MongoDbFindFluentExecutable : MongoDbExecutable + private readonly IFindFluent _findFluent; + + public MongoDbFindFluentExecutable(IFindFluent findFluent) { - private readonly IFindFluent _findFluent; + _findFluent = findFluent; + } - public MongoDbFindFluentExecutable(IFindFluent findFluent) - { - _findFluent = findFluent; - } + /// + public override object Source => _findFluent; - /// - public override object Source => _findFluent; + /// + public override async ValueTask ToListAsync(CancellationToken cancellationToken) => + await BuildPipeline() + .ToListAsync(cancellationToken) + .ConfigureAwait(false); - /// - public override async ValueTask ToListAsync(CancellationToken cancellationToken) => - await BuildPipeline() - .ToListAsync(cancellationToken) - .ConfigureAwait(false); + /// + public override async ValueTask FirstOrDefaultAsync( + CancellationToken cancellationToken) => + await BuildPipeline() + .FirstOrDefaultAsync(cancellationToken) + .ConfigureAwait(false); - /// - public override async ValueTask FirstOrDefaultAsync( - CancellationToken cancellationToken) => - await BuildPipeline() - .FirstOrDefaultAsync(cancellationToken) - .ConfigureAwait(false); + /// + public override async ValueTask SingleOrDefaultAsync( + CancellationToken cancellationToken) => + await BuildPipeline() + .SingleOrDefaultAsync(cancellationToken) + .ConfigureAwait(false); - /// - public override async ValueTask SingleOrDefaultAsync( - CancellationToken cancellationToken) => - await BuildPipeline() - .SingleOrDefaultAsync(cancellationToken) - .ConfigureAwait(false); + /// + public override string Print() => BuildPipeline().ToString() ?? ""; - /// - public override string Print() => BuildPipeline().ToString() ?? ""; + /// + /// Applies filtering sorting and projections on the + /// + /// A find fluent including the configuration of this executable + public IFindFluent BuildPipeline() + { + IFindFluent pipeline = _findFluent; - /// - /// Applies filtering sorting and projections on the - /// - /// A find fluent including the configuration of this executable - public IFindFluent BuildPipeline() + if (Filters is not null) { - IFindFluent pipeline = _findFluent; + pipeline.Filter = + new AndFilterDefinition(_findFluent.Filter.Wrap(), Filters) + .ToFilterDefinition(); + } - if (Filters is not null) + if (Sorting is not null) + { + if (pipeline.Options?.Sort is { } sortDefinition) { - pipeline.Filter = - new AndFilterDefinition(_findFluent.Filter.Wrap(), Filters) - .ToFilterDefinition(); + pipeline.Sort( + new MongoDbCombinedSortDefinition(sortDefinition.Wrap(), Sorting) + .ToSortDefinition()); } - - if (Sorting is not null) + else { - if (pipeline.Options?.Sort is {} sortDefinition) - { - pipeline.Sort( - new MongoDbCombinedSortDefinition(sortDefinition.Wrap(), Sorting) - .ToSortDefinition()); - } - else - { - pipeline = pipeline.Sort(Sorting.ToSortDefinition()); - } - } - - if (Projection is not null) - { - pipeline = pipeline.Project(Projection.ToProjectionDefinition()); + pipeline = pipeline.Sort(Sorting.ToSortDefinition()); } + } - return pipeline; + if (Projection is not null) + { + pipeline = pipeline.Project(Projection.ToProjectionDefinition()); } + + return pipeline; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Extensions/BsonDocumentExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Extensions/BsonDocumentExtensions.cs index 93e6ff10196..becf3ea32a3 100644 --- a/src/HotChocolate/MongoDb/src/Data/Extensions/BsonDocumentExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Extensions/BsonDocumentExtensions.cs @@ -2,26 +2,25 @@ using MongoDB.Bson.Serialization; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +public static class BsonDocumentExtensions { - public static class BsonDocumentExtensions - { - private static readonly IBsonSerializerRegistry SerializerRegistry = - BsonSerializer.SerializerRegistry; + private static readonly IBsonSerializerRegistry SerializerRegistry = + BsonSerializer.SerializerRegistry; - private static readonly IBsonSerializer DocumentSerializer = - SerializerRegistry.GetSerializer(); + private static readonly IBsonSerializer DocumentSerializer = + SerializerRegistry.GetSerializer(); - public static BsonDocument DefaultRender( - this FilterDefinition bsonQuery) - { - return bsonQuery.Render(DocumentSerializer, SerializerRegistry); - } + public static BsonDocument DefaultRender( + this FilterDefinition bsonQuery) + { + return bsonQuery.Render(DocumentSerializer, SerializerRegistry); + } - public static BsonDocument DefaultRender( - this SortDefinition bsonQuery) - { - return bsonQuery.Render(DocumentSerializer, SerializerRegistry); - } + public static BsonDocument DefaultRender( + this SortDefinition bsonQuery) + { + return bsonQuery.Render(DocumentSerializer, SerializerRegistry); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbDataRequestBuilderExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbDataRequestBuilderExtensions.cs index 4bffed22559..116ef13a925 100644 --- a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbDataRequestBuilderExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbDataRequestBuilderExtensions.cs @@ -1,116 +1,115 @@ using System; -using HotChocolate.Execution.Configuration; using HotChocolate.Data.MongoDb; using HotChocolate.Data.MongoDb.Paging; +using HotChocolate.Execution.Configuration; using HotChocolate.Types; using HotChocolate.Types.Pagination; using MongoDB.Bson; -namespace Microsoft.Extensions.DependencyInjection +namespace Microsoft.Extensions.DependencyInjection; + +/// +/// Provides data extensions for the . +/// +public static class MongoDbDataRequestBuilderExtensions { /// - /// Provides data extensions for the . + /// Adds filtering support. /// - public static class MongoDbDataRequestBuilderExtensions - { - /// - /// Adds filtering support. - /// - /// - /// The . - /// - /// - /// - /// Returns the . - /// - public static IRequestExecutorBuilder AddMongoDbFiltering( - this IRequestExecutorBuilder builder, - string? name = null, - bool compatabilityMode = false) => - builder.ConfigureSchema(s => s.AddMongoDbFiltering(name, compatabilityMode)); + /// + /// The . + /// + /// + /// + /// Returns the . + /// + public static IRequestExecutorBuilder AddMongoDbFiltering( + this IRequestExecutorBuilder builder, + string? name = null, + bool compatabilityMode = false) => + builder.ConfigureSchema(s => s.AddMongoDbFiltering(name, compatabilityMode)); - /// - /// Adds sorting support. - /// - /// - /// The . - /// - /// - /// - /// Returns the . - /// - public static IRequestExecutorBuilder AddMongoDbSorting( - this IRequestExecutorBuilder builder, - string? name = null) => - builder.ConfigureSchema(s => s.AddMongoDbSorting(name)); + /// + /// Adds sorting support. + /// + /// + /// The . + /// + /// + /// + /// Returns the . + /// + public static IRequestExecutorBuilder AddMongoDbSorting( + this IRequestExecutorBuilder builder, + string? name = null) => + builder.ConfigureSchema(s => s.AddMongoDbSorting(name)); - /// - /// Adds projections support. - /// - /// - /// The . - /// - /// - /// - /// Returns the . - /// - public static IRequestExecutorBuilder AddMongoDbProjections( - this IRequestExecutorBuilder builder, - string? name = null) => - builder.ConfigureSchema(s => s.AddMongoDbProjections(name)); + /// + /// Adds projections support. + /// + /// + /// The . + /// + /// + /// + /// Returns the . + /// + public static IRequestExecutorBuilder AddMongoDbProjections( + this IRequestExecutorBuilder builder, + string? name = null) => + builder.ConfigureSchema(s => s.AddMongoDbProjections(name)); - /// - /// Adds converter - /// - /// - /// The . - /// - /// - /// Returns the . - /// - public static IRequestExecutorBuilder AddObjectIdConverters( - this IRequestExecutorBuilder builder) => - builder - .BindRuntimeType() - #pragma warning disable CS8622 + /// + /// Adds converter + /// + /// + /// The . + /// + /// + /// Returns the . + /// + public static IRequestExecutorBuilder AddObjectIdConverters( + this IRequestExecutorBuilder builder) => + builder + .BindRuntimeType() +#pragma warning disable CS8622 .AddTypeConverter(x => x.ToString()) - .AddTypeConverter(x => new ObjectId(x)); - #pragma warning restore CS8622 + .AddTypeConverter(x => new ObjectId(x)); +#pragma warning restore CS8622 - /// - /// Adds the MongoDB cursor and offset paging providers. - /// - /// - /// The GraphQL configuration builder. - /// - /// - /// The name which shall be used to refer to this registration. - /// - /// - /// Defines if these providers shall be registered as default providers. - /// - /// - /// Returns the GraphQL configuration builder for further configuration chaining. - /// - public static IRequestExecutorBuilder AddMongoDbPagingProviders( - this IRequestExecutorBuilder builder, - string? providerName = null, - bool defaultProvider = false) + /// + /// Adds the MongoDB cursor and offset paging providers. + /// + /// + /// The GraphQL configuration builder. + /// + /// + /// The name which shall be used to refer to this registration. + /// + /// + /// Defines if these providers shall be registered as default providers. + /// + /// + /// Returns the GraphQL configuration builder for further configuration chaining. + /// + public static IRequestExecutorBuilder AddMongoDbPagingProviders( + this IRequestExecutorBuilder builder, + string? providerName = null, + bool defaultProvider = false) + { + if (builder is null) { - if (builder is null) - { - throw new ArgumentNullException(nameof(builder)); - } + throw new ArgumentNullException(nameof(builder)); + } - builder.AddCursorPagingProvider( - providerName, - defaultProvider); + builder.AddCursorPagingProvider( + providerName, + defaultProvider); - builder.AddOffsetPagingProvider( - providerName, - defaultProvider); + builder.AddOffsetPagingProvider( + providerName, + defaultProvider); - return builder; - } + return builder; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbFilterScopeExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbFilterScopeExtensions.cs index a45ba80f26c..c9f398bb9ca 100644 --- a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbFilterScopeExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbFilterScopeExtensions.cs @@ -3,27 +3,26 @@ using MongoDB.Bson; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public static class MongoDbFilterScopeExtensions { - public static class MongoDbFilterScopeExtensions + public static string GetPath(this MongoDbFilterScope scope) => + string.Join(".", scope.Path.Reverse()); + + public static bool TryCreateQuery( + this MongoDbFilterScope scope, + [NotNullWhen(true)] out MongoDbFilterDefinition? query) { - public static string GetPath(this MongoDbFilterScope scope) => - string.Join(".", scope.Path.Reverse()); + query = null; - public static bool TryCreateQuery( - this MongoDbFilterScope scope, - [NotNullWhen(true)] out MongoDbFilterDefinition? query) + if (scope.Level.Peek().Count == 0) { - query = null; - - if (scope.Level.Peek().Count == 0) - { - return false; - } + return false; + } - query = new AndFilterDefinition(scope.Level.Peek().ToArray()); + query = new AndFilterDefinition(scope.Level.Peek().ToArray()); - return true; - } + return true; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbObjectFieldExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbObjectFieldExtensions.cs index 655eadf7066..642682dd63d 100644 --- a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbObjectFieldExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbObjectFieldExtensions.cs @@ -1,19 +1,18 @@ using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +public static class MongoDbObjectFieldExtensions { - public static class MongoDbObjectFieldExtensions + public static string GetName( + this IObjectField field) { - public static string GetName( - this IObjectField field) + string fieldName = field.Name; + if (field.Member is { } p) { - string fieldName = field.Name; - if (field.Member is { } p) - { - fieldName = p.Name; - } - - return fieldName; + fieldName = p.Name; } + + return fieldName; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbSortFieldExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbSortFieldExtensions.cs index f62eb9a0e1a..010e962d773 100644 --- a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbSortFieldExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbSortFieldExtensions.cs @@ -1,19 +1,18 @@ using HotChocolate.Data.Sorting; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +public static class MongoDbSortFieldExtensions { - public static class MongoDbSortFieldExtensions + public static string GetName( + this ISortField field) { - public static string GetName( - this ISortField field) + string fieldName = field.Name; + if (field.Member is { } p) { - string fieldName = field.Name; - if (field.Member is { } p) - { - fieldName = p.Name; - } - - return fieldName; + fieldName = p.Name; } + + return fieldName; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoFilterOperationFieldExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoFilterOperationFieldExtensions.cs index 428cec1bd08..90e68484750 100644 --- a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoFilterOperationFieldExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoFilterOperationFieldExtensions.cs @@ -1,19 +1,18 @@ using HotChocolate.Data.Filters; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +public static class MongoFilterOperationFieldExtensions { - public static class MongoFilterOperationFieldExtensions + public static string GetName( + this IFilterField field) { - public static string GetName( - this IFilterField field) + string fieldName = field.Name; + if (field.Member is { } p) { - string fieldName = field.Name; - if (field.Member is { } p) - { - fieldName = p.Name; - } - - return fieldName; + fieldName = p.Name; } + + return fieldName; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoFilterVisitorContextExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoFilterVisitorContextExtensions.cs index 61486810d85..2519f02b1d2 100644 --- a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoFilterVisitorContextExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoFilterVisitorContextExtensions.cs @@ -1,30 +1,29 @@ using System.Diagnostics.CodeAnalysis; using HotChocolate.Data.Filters; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public static class MongoFilterVisitorContextExtensions { - public static class MongoFilterVisitorContextExtensions - { - /// - /// Reads the current scope from the context - /// - /// The context - /// The current scope - public static MongoDbFilterScope GetMongoFilterScope( - this MongoDbFilterVisitorContext context) => - (MongoDbFilterScope)context.GetScope(); + /// + /// Reads the current scope from the context + /// + /// The context + /// The current scope + public static MongoDbFilterScope GetMongoFilterScope( + this MongoDbFilterVisitorContext context) => + (MongoDbFilterScope)context.GetScope(); - /// - /// Tries to build the query based on the items that are stored on the scope - /// - /// the context - /// The query that was build - /// True in case the query has been build successfully, otherwise false - public static bool TryCreateQuery( - this MongoDbFilterVisitorContext context, - [NotNullWhen(true)] out MongoDbFilterDefinition? query) - { - return context.GetMongoFilterScope().TryCreateQuery(out query); - } + /// + /// Tries to build the query based on the items that are stored on the scope + /// + /// the context + /// The query that was build + /// True in case the query has been build successfully, otherwise false + public static bool TryCreateQuery( + this MongoDbFilterVisitorContext context, + [NotNullWhen(true)] out MongoDbFilterDefinition? query) + { + return context.GetMongoFilterScope().TryCreateQuery(out query); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoSortVisitorContextExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoSortVisitorContextExtensions.cs index 9e52e7ce68d..8608eccfdaf 100644 --- a/src/HotChocolate/MongoDb/src/Data/Extensions/MongoSortVisitorContextExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Extensions/MongoSortVisitorContextExtensions.cs @@ -1,26 +1,25 @@ using System.Diagnostics.CodeAnalysis; using System.Linq; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public static class MongoSortVisitorContextExtensions { - public static class MongoSortVisitorContextExtensions + public static string GetPath(this MongoDbSortVisitorContext ctx) => + string.Join(".", ctx.Path.Reverse()); + + public static bool TryCreateQuery( + this MongoDbSortVisitorContext context, + [NotNullWhen(true)] out MongoDbSortDefinition? query) { - public static string GetPath(this MongoDbSortVisitorContext ctx) => - string.Join(".", ctx.Path.Reverse()); + query = null; - public static bool TryCreateQuery( - this MongoDbSortVisitorContext context, - [NotNullWhen(true)] out MongoDbSortDefinition? query) + if (context.Operations.Count == 0) { - query = null; - - if (context.Operations.Count == 0) - { - return false; - } - - query = new MongoDbCombinedSortDefinition(context.Operations.ToArray()); - return true; + return false; } + + query = new MongoDbCombinedSortDefinition(context.Operations.ToArray()); + return true; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Extensions/SchemaBuilderExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Extensions/SchemaBuilderExtensions.cs index b560b7e7667..a4a4ba1e86a 100644 --- a/src/HotChocolate/MongoDb/src/Data/Extensions/SchemaBuilderExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Extensions/SchemaBuilderExtensions.cs @@ -1,57 +1,56 @@ using HotChocolate.Data.Filters; using HotChocolate.Data.MongoDb.Filters; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +/// Provides mongo extensions for the . +/// +public static class MongoDbSchemaBuilderExtensions { /// - /// Provides mongo extensions for the . + /// Adds filtering support. /// - public static class MongoDbSchemaBuilderExtensions - { - /// - /// Adds filtering support. - /// - /// - /// The . - /// - /// - /// - /// Returns the . - /// - public static ISchemaBuilder AddMongoDbFiltering( - this ISchemaBuilder builder, - string? name = null, - bool compatabilityMode = false) => - builder.AddFiltering(x => x.AddMongoDbDefaults(compatabilityMode), name); + /// + /// The . + /// + /// + /// + /// Returns the . + /// + public static ISchemaBuilder AddMongoDbFiltering( + this ISchemaBuilder builder, + string? name = null, + bool compatabilityMode = false) => + builder.AddFiltering(x => x.AddMongoDbDefaults(compatabilityMode), name); - /// - /// Adds sorting support. - /// - /// - /// The . - /// - /// - /// - /// Returns the . - /// - public static ISchemaBuilder AddMongoDbSorting( - this ISchemaBuilder builder, - string? name = null) => - builder.AddSorting(x => x.AddMongoDbDefaults(), name); + /// + /// Adds sorting support. + /// + /// + /// The . + /// + /// + /// + /// Returns the . + /// + public static ISchemaBuilder AddMongoDbSorting( + this ISchemaBuilder builder, + string? name = null) => + builder.AddSorting(x => x.AddMongoDbDefaults(), name); - /// - /// Adds projections support. - /// - /// - /// The . - /// - /// - /// - /// Returns the . - /// - public static ISchemaBuilder AddMongoDbProjections( - this ISchemaBuilder builder, - string? name = null) => - builder.AddProjections(x => x.AddMongoDbDefaults(), name); - } + /// + /// Adds projections support. + /// + /// + /// The . + /// + /// + /// + /// Returns the . + /// + public static ISchemaBuilder AddMongoDbProjections( + this ISchemaBuilder builder, + string? name = null) => + builder.AddProjections(x => x.AddMongoDbDefaults(), name); } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Convention/Extensions/FilterConventionDescriptorMongoDbExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Convention/Extensions/FilterConventionDescriptorMongoDbExtensions.cs index d764f734d50..2c5b6a71341 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Convention/Extensions/FilterConventionDescriptorMongoDbExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Convention/Extensions/FilterConventionDescriptorMongoDbExtensions.cs @@ -1,57 +1,56 @@ using HotChocolate.Data.Filters; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public static class FilterConventionDescriptorMongoDbExtensions { - public static class FilterConventionDescriptorMongoDbExtensions + /// + /// Adds a with default configuration + /// + /// The descriptor where the provider is registered + /// The descriptor that was passed in as a parameter + public static IFilterConventionDescriptor UseMongoDbProvider( + this IFilterConventionDescriptor descriptor) => + descriptor.Provider(new MongoDbFilterProvider(x => x.AddDefaultMongoDbFieldHandlers())); + + /// + /// Initializes the default configuration of the provider by registering handlers + /// + /// The descriptor where the handlers are registered + /// The that was passed in as a parameter + public static IFilterProviderDescriptor + AddDefaultMongoDbFieldHandlers( + this IFilterProviderDescriptor descriptor) { - /// - /// Adds a with default configuration - /// - /// The descriptor where the provider is registered - /// The descriptor that was passed in as a parameter - public static IFilterConventionDescriptor UseMongoDbProvider( - this IFilterConventionDescriptor descriptor) => - descriptor.Provider(new MongoDbFilterProvider(x => x.AddDefaultMongoDbFieldHandlers())); - - /// - /// Initializes the default configuration of the provider by registering handlers - /// - /// The descriptor where the handlers are registered - /// The that was passed in as a parameter - public static IFilterProviderDescriptor - AddDefaultMongoDbFieldHandlers( - this IFilterProviderDescriptor descriptor) - { - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - descriptor.AddFieldHandler(); - - descriptor.AddFieldHandler(); - - return descriptor; - } + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + descriptor.AddFieldHandler(); + + descriptor.AddFieldHandler(); + + return descriptor; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableGreaterThanHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableGreaterThanHandler.cs index 82bd3877eb7..3ab816bdb38 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableGreaterThanHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableGreaterThanHandler.cs @@ -1,41 +1,40 @@ using System; using HotChocolate.Data.Filters; using HotChocolate.Language; -using MongoDB.Driver; using HotChocolate.Types; +using MongoDB.Driver; + +namespace HotChocolate.Data.MongoDb.Filters; -namespace HotChocolate.Data.MongoDb.Filters +/// +/// This filter operation handler maps a GreaterThan operation field to a +/// +/// +public class MongoDbComparableGreaterThanHandler + : MongoDbComparableOperationHandler { - /// - /// This filter operation handler maps a GreaterThan operation field to a - /// - /// - public class MongoDbComparableGreaterThanHandler - : MongoDbComparableOperationHandler + public MongoDbComparableGreaterThanHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbComparableGreaterThanHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - /// - protected override int Operation => DefaultFilterOperations.GreaterThan; + /// + protected override int Operation => DefaultFilterOperations.GreaterThan; - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is { }) { - if (parsedValue is { }) - { - var doc = new MongoDbFilterOperation("$gt", parsedValue); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + var doc = new MongoDbFilterOperation("$gt", parsedValue); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableGreaterThanOrEqualsHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableGreaterThanOrEqualsHandler.cs index bfcf23c09d3..17ec2d7a5b3 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableGreaterThanOrEqualsHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableGreaterThanOrEqualsHandler.cs @@ -5,38 +5,37 @@ using MongoDB.Bson; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a GreaterThanOrEquals operation field to a +/// +/// +public class MongoDbComparableGreaterThanOrEqualsHandler + : MongoDbComparableOperationHandler { - /// - /// This filter operation handler maps a GreaterThanOrEquals operation field to a - /// - /// - public class MongoDbComparableGreaterThanOrEqualsHandler - : MongoDbComparableOperationHandler + public MongoDbComparableGreaterThanOrEqualsHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbComparableGreaterThanOrEqualsHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - /// - protected override int Operation => DefaultFilterOperations.GreaterThanOrEquals; + /// + protected override int Operation => DefaultFilterOperations.GreaterThanOrEquals; - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is { }) { - if (parsedValue is { }) - { - var doc = new MongoDbFilterOperation("$gte", parsedValue); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + var doc = new MongoDbFilterOperation("$gte", parsedValue); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableLowerThanHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableLowerThanHandler.cs index 5cb54f571dc..610d4c838c1 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableLowerThanHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableLowerThanHandler.cs @@ -1,43 +1,42 @@ using System; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Bson; using MongoDB.Driver; -using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a LowerThan operation field to a +/// +/// +public class MongoDbComparableLowerThanHandler + : MongoDbComparableOperationHandler { - /// - /// This filter operation handler maps a LowerThan operation field to a - /// - /// - public class MongoDbComparableLowerThanHandler - : MongoDbComparableOperationHandler + public MongoDbComparableLowerThanHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbComparableLowerThanHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - /// - protected override int Operation => DefaultFilterOperations.LowerThan; + /// + protected override int Operation => DefaultFilterOperations.LowerThan; - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is { }) { - if (parsedValue is { }) - { - var doc = new MongoDbFilterOperation("$lt", parsedValue); + var doc = new MongoDbFilterOperation("$lt", parsedValue); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableLowerThanOrEqualsHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableLowerThanOrEqualsHandler.cs index 787608785d8..842e07df250 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableLowerThanOrEqualsHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableLowerThanOrEqualsHandler.cs @@ -1,42 +1,41 @@ using System; using HotChocolate.Data.Filters; using HotChocolate.Language; -using MongoDB.Driver; using HotChocolate.Types; +using MongoDB.Driver; + +namespace HotChocolate.Data.MongoDb.Filters; -namespace HotChocolate.Data.MongoDb.Filters +/// +/// This filter operation handler maps a LowerThanOrEquals operation field to a +/// +/// +public class MongoDbComparableLowerThanOrEqualsHandler + : MongoDbComparableOperationHandler { - /// - /// This filter operation handler maps a LowerThanOrEquals operation field to a - /// - /// - public class MongoDbComparableLowerThanOrEqualsHandler - : MongoDbComparableOperationHandler + public MongoDbComparableLowerThanOrEqualsHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbComparableLowerThanOrEqualsHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - /// - protected override int Operation => DefaultFilterOperations.LowerThanOrEquals; + /// + protected override int Operation => DefaultFilterOperations.LowerThanOrEquals; - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is { }) { - if (parsedValue is { }) - { - var doc = new MongoDbFilterOperation("$lte", parsedValue); + var doc = new MongoDbFilterOperation("$lte", parsedValue); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotGreaterThanHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotGreaterThanHandler.cs index 305e07f9421..96eed3e25aa 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotGreaterThanHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotGreaterThanHandler.cs @@ -1,44 +1,43 @@ using System; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Bson; using MongoDB.Driver; -using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a NotGreaterThan operation field to a +/// +/// +public class MongoDbComparableNotGreaterThanHandler + : MongoDbComparableOperationHandler { - /// - /// This filter operation handler maps a NotGreaterThan operation field to a - /// - /// - public class MongoDbComparableNotGreaterThanHandler - : MongoDbComparableOperationHandler + public MongoDbComparableNotGreaterThanHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbComparableNotGreaterThanHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - /// - protected override int Operation => DefaultFilterOperations.NotGreaterThan; + /// + protected override int Operation => DefaultFilterOperations.NotGreaterThan; - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is { }) { - if (parsedValue is { }) - { - var doc = new NotMongoDbFilterDefinition( - new MongoDbFilterOperation("$gt", parsedValue)); + var doc = new NotMongoDbFilterDefinition( + new MongoDbFilterOperation("$gt", parsedValue)); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotGreaterThanOrEqualsHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotGreaterThanOrEqualsHandler.cs index f654b079755..db6fb887a1d 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotGreaterThanOrEqualsHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotGreaterThanOrEqualsHandler.cs @@ -1,43 +1,42 @@ using System; using HotChocolate.Data.Filters; using HotChocolate.Language; -using MongoDB.Driver; using HotChocolate.Types; +using MongoDB.Driver; + +namespace HotChocolate.Data.MongoDb.Filters; -namespace HotChocolate.Data.MongoDb.Filters +/// +/// This filter operation handler maps a NotGreaterThanOrEquals operation field to a +/// +/// +public class MongoDbComparableNotGreaterThanOrEqualsHandler + : MongoDbComparableOperationHandler { - /// - /// This filter operation handler maps a NotGreaterThanOrEquals operation field to a - /// - /// - public class MongoDbComparableNotGreaterThanOrEqualsHandler - : MongoDbComparableOperationHandler + public MongoDbComparableNotGreaterThanOrEqualsHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbComparableNotGreaterThanOrEqualsHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - /// - protected override int Operation => DefaultFilterOperations.NotGreaterThanOrEquals; + /// + protected override int Operation => DefaultFilterOperations.NotGreaterThanOrEquals; - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is { }) { - if (parsedValue is { }) - { - var doc = new NotMongoDbFilterDefinition( - new MongoDbFilterOperation("$gte", parsedValue)); + var doc = new NotMongoDbFilterDefinition( + new MongoDbFilterOperation("$gte", parsedValue)); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotLowerThanHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotLowerThanHandler.cs index 4e38ae295c7..6f4f1970a62 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotLowerThanHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotLowerThanHandler.cs @@ -1,44 +1,43 @@ using System; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Bson; using MongoDB.Driver; -using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a NotLowerThan operation field to a +/// +/// +public class MongoDbComparableNotLowerThanHandler + : MongoDbComparableOperationHandler { - /// - /// This filter operation handler maps a NotLowerThan operation field to a - /// - /// - public class MongoDbComparableNotLowerThanHandler - : MongoDbComparableOperationHandler + public MongoDbComparableNotLowerThanHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbComparableNotLowerThanHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - /// - protected override int Operation => DefaultFilterOperations.NotLowerThan; + /// + protected override int Operation => DefaultFilterOperations.NotLowerThan; - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is { }) { - if (parsedValue is { }) - { - var doc = new NotMongoDbFilterDefinition( - new MongoDbFilterOperation("$lt", parsedValue)); + var doc = new NotMongoDbFilterDefinition( + new MongoDbFilterOperation("$lt", parsedValue)); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotLowerThanOrEqualsHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotLowerThanOrEqualsHandler.cs index dcfd54a0d91..1c694d5f93b 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotLowerThanOrEqualsHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableNotLowerThanOrEqualsHandler.cs @@ -1,43 +1,42 @@ using System; using HotChocolate.Data.Filters; using HotChocolate.Language; -using MongoDB.Driver; using HotChocolate.Types; +using MongoDB.Driver; + +namespace HotChocolate.Data.MongoDb.Filters; -namespace HotChocolate.Data.MongoDb.Filters +/// +/// This filter operation handler maps a NotLowerThanOrEquals operation field to a +/// +/// +public class MongoDbComparableNotLowerThanOrEqualsHandler + : MongoDbComparableOperationHandler { - /// - /// This filter operation handler maps a NotLowerThanOrEquals operation field to a - /// - /// - public class MongoDbComparableNotLowerThanOrEqualsHandler - : MongoDbComparableOperationHandler + public MongoDbComparableNotLowerThanOrEqualsHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbComparableNotLowerThanOrEqualsHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - /// - protected override int Operation => DefaultFilterOperations.NotLowerThanOrEquals; + /// + protected override int Operation => DefaultFilterOperations.NotLowerThanOrEquals; - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is { }) { - if (parsedValue is { }) - { - var doc = new NotMongoDbFilterDefinition( - new MongoDbFilterOperation("$lte", parsedValue)); + var doc = new NotMongoDbFilterDefinition( + new MongoDbFilterOperation("$lte", parsedValue)); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableOperationHandler.cs index 7f16d895ccb..ea15d3dcc4b 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/Comparable/MongoDbComparableOperationHandler.cs @@ -1,46 +1,45 @@ using HotChocolate.Configuration; -using HotChocolate.Types; using HotChocolate.Data.Filters; +using HotChocolate.Types; + +namespace HotChocolate.Data.MongoDb.Filters; -namespace HotChocolate.Data.MongoDb.Filters +/// +/// The base of a mongodb operation handler specific for +/// +/// If the encounters a operation field that implements +/// and matches the operation identifier +/// defined in the handler is bound to +/// the field +/// +public abstract class MongoDbComparableOperationHandler + : MongoDbOperationHandlerBase { - /// - /// The base of a mongodb operation handler specific for - /// - /// If the encounters a operation field that implements - /// and matches the operation identifier - /// defined in the handler is bound to - /// the field - /// - public abstract class MongoDbComparableOperationHandler - : MongoDbOperationHandlerBase + public MongoDbComparableOperationHandler(InputParser inputParser) : base(inputParser) { - public MongoDbComparableOperationHandler(InputParser inputParser) : base(inputParser) - { - } + } - /// - /// Specifies the identifier of the operations that should be handled by this handler - /// - protected abstract int Operation { get; } + /// + /// Specifies the identifier of the operations that should be handled by this handler + /// + protected abstract int Operation { get; } - /// - /// Checks if the implements - /// and has the operation identifier - /// defined in - /// - /// The discovery context of the schema - /// The definition of the declaring type of the field - /// The definition of the field - /// Returns true if the field can be handled - public override bool CanHandle( - ITypeCompletionContext context, - IFilterInputTypeDefinition typeDefinition, - IFilterFieldDefinition fieldDefinition) - { - return context.Type is IComparableOperationFilterInputType && - fieldDefinition is FilterOperationFieldDefinition operationField && - operationField.Id == Operation; - } + /// + /// Checks if the implements + /// and has the operation identifier + /// defined in + /// + /// The discovery context of the schema + /// The definition of the declaring type of the field + /// The definition of the field + /// Returns true if the field can be handled + public override bool CanHandle( + ITypeCompletionContext context, + IFilterInputTypeDefinition typeDefinition, + IFilterFieldDefinition fieldDefinition) + { + return context.Type is IComparableOperationFilterInputType && + fieldDefinition is FilterOperationFieldDefinition operationField && + operationField.Id == Operation; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListAllOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListAllOperationHandler.cs index d07f8101403..b663802adf3 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListAllOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListAllOperationHandler.cs @@ -3,48 +3,47 @@ using MongoDB.Bson; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a All operation field to a +/// +/// +public class MongoDbListAllOperationHandler : MongoDbListOperationHandlerBase { - /// - /// This filter operation handler maps a All operation field to a - /// - /// - public class MongoDbListAllOperationHandler : MongoDbListOperationHandlerBase + /// + protected override int Operation => DefaultFilterOperations.All; + + /// + protected override MongoDbFilterDefinition HandleListOperation( + MongoDbFilterVisitorContext context, + IFilterField field, + MongoDbFilterScope scope, + string path) { - /// - protected override int Operation => DefaultFilterOperations.All; + var negatedChilds = new List(); + Queue level = scope.Level.Peek(); - /// - protected override MongoDbFilterDefinition HandleListOperation( - MongoDbFilterVisitorContext context, - IFilterField field, - MongoDbFilterScope scope, - string path) + while (level.Count > 0) { - var negatedChilds = new List(); - Queue level = scope.Level.Peek(); - - while (level.Count > 0) - { - negatedChilds.Add( - new MongoDbFilterOperation( - path, - new MongoDbFilterOperation( - "$elemMatch", - new NotMongoDbFilterDefinition(level.Dequeue())))); - } - - return new AndFilterDefinition( + negatedChilds.Add( new MongoDbFilterOperation( path, - new BsonDocument - { + new MongoDbFilterOperation( + "$elemMatch", + new NotMongoDbFilterDefinition(level.Dequeue())))); + } + + return new AndFilterDefinition( + new MongoDbFilterOperation( + path, + new BsonDocument + { { "$exists", true }, { "$nin", new BsonArray { new BsonArray(), BsonNull.Value } } - }), - new NotMongoDbFilterDefinition( - new OrMongoDbFilterDefinition(negatedChilds) - )); - } + }), + new NotMongoDbFilterDefinition( + new OrMongoDbFilterDefinition(negatedChilds) + )); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListAnyOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListAnyOperationHandler.cs index ff635d22533..10c3c8df938 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListAnyOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListAnyOperationHandler.cs @@ -6,70 +6,69 @@ using MongoDB.Bson; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a Any operation field to a +/// +/// +public class MongoDbListAnyOperationHandler + : MongoDbOperationHandlerBase { - /// - /// This filter operation handler maps a Any operation field to a - /// - /// - public class MongoDbListAnyOperationHandler - : MongoDbOperationHandlerBase + public MongoDbListAnyOperationHandler(InputParser inputParser) : base(inputParser) { - public MongoDbListAnyOperationHandler(InputParser inputParser) : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - /// - public override bool CanHandle( - ITypeCompletionContext context, - IFilterInputTypeDefinition typeDefinition, - IFilterFieldDefinition fieldDefinition) - { - return context.Type is IListFilterInputType && - fieldDefinition is FilterOperationFieldDefinition operationField && - operationField.Id is DefaultFilterOperations.Any; - } + /// + public override bool CanHandle( + ITypeCompletionContext context, + IFilterInputTypeDefinition typeDefinition, + IFilterFieldDefinition fieldDefinition) + { + return context.Type is IListFilterInputType && + fieldDefinition is FilterOperationFieldDefinition operationField && + operationField.Id is DefaultFilterOperations.Any; + } - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (context.RuntimeTypes.Count > 0 && + context.RuntimeTypes.Peek().TypeArguments is { Count: > 0 } && + parsedValue is bool parsedBool && + context.Scopes.Peek() is MongoDbFilterScope scope) { - if (context.RuntimeTypes.Count > 0 && - context.RuntimeTypes.Peek().TypeArguments is { Count: > 0 } && - parsedValue is bool parsedBool && - context.Scopes.Peek() is MongoDbFilterScope scope) - { - var path = scope.GetPath(); + var path = scope.GetPath(); - if (parsedBool) - { - return new MongoDbFilterOperation( - path, - new BsonDocument - { + if (parsedBool) + { + return new MongoDbFilterOperation( + path, + new BsonDocument + { { "$exists", true }, { "$nin", new BsonArray { new BsonArray(), BsonNull.Value } } - }); - } + }); + } - return new OrMongoDbFilterDefinition( - new MongoDbFilterOperation( - path, - new BsonDocument - { + return new OrMongoDbFilterDefinition( + new MongoDbFilterOperation( + path, + new BsonDocument + { { "$exists", true }, { "$in", new BsonArray { new BsonArray(), BsonNull.Value } } - }), - new MongoDbFilterOperation( - path, - new BsonDocument { { "$exists", false } })); - } - - throw new InvalidOperationException(); + }), + new MongoDbFilterOperation( + path, + new BsonDocument { { "$exists", false } })); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListNoneOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListNoneOperationHandler.cs index f567e1559ca..d10259f7c3b 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListNoneOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListNoneOperationHandler.cs @@ -2,37 +2,36 @@ using MongoDB.Bson; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a All operation field to a +/// +/// +public class MongoDbListNoneOperationHandler : MongoDbListOperationHandlerBase { - /// - /// This filter operation handler maps a All operation field to a - /// - /// - public class MongoDbListNoneOperationHandler : MongoDbListOperationHandlerBase - { - /// - protected override int Operation => DefaultFilterOperations.None; + /// + protected override int Operation => DefaultFilterOperations.None; - /// - protected override MongoDbFilterDefinition HandleListOperation( - MongoDbFilterVisitorContext context, - IFilterField field, - MongoDbFilterScope scope, - string path) - { - return new AndFilterDefinition( - new MongoDbFilterOperation( - path, - new BsonDocument - { + /// + protected override MongoDbFilterDefinition HandleListOperation( + MongoDbFilterVisitorContext context, + IFilterField field, + MongoDbFilterScope scope, + string path) + { + return new AndFilterDefinition( + new MongoDbFilterOperation( + path, + new BsonDocument + { { "$exists", true }, { "$nin", new BsonArray { new BsonArray(), BsonNull.Value } } - }), - new MongoDbFilterOperation( - path, - new NotMongoDbFilterDefinition( - new MongoDbFilterOperation("$elemMatch", CombineOperationsOfScope(scope))) - )); - } + }), + new MongoDbFilterOperation( + path, + new NotMongoDbFilterDefinition( + new MongoDbFilterOperation("$elemMatch", CombineOperationsOfScope(scope))) + )); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListOperationHandlerBase.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListOperationHandlerBase.cs index a4626d9a47c..d0c93eac6cf 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListOperationHandlerBase.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListOperationHandlerBase.cs @@ -6,123 +6,122 @@ using HotChocolate.Language; using HotChocolate.Language.Visitors; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// The base of a mongodb operation handler specific for +/// +/// If the encounters a operation field that implements +/// and matches the operation identifier +/// defined in the handler is bound to +/// the field +/// +public abstract class MongoDbListOperationHandlerBase + : FilterFieldHandler { /// - /// The base of a mongodb operation handler specific for - /// - /// If the encounters a operation field that implements - /// and matches the operation identifier - /// defined in the handler is bound to - /// the field + /// Specifies the identifier of the operations that should be handled by this handler /// - public abstract class MongoDbListOperationHandlerBase - : FilterFieldHandler + protected abstract int Operation { get; } + + /// + public override bool CanHandle( + ITypeCompletionContext context, + IFilterInputTypeDefinition typeDefinition, + IFilterFieldDefinition fieldDefinition) { - /// - /// Specifies the identifier of the operations that should be handled by this handler - /// - protected abstract int Operation { get; } + return context.Type is IListFilterInputType && + fieldDefinition is FilterOperationFieldDefinition operationField && + operationField.Id == Operation; + } - /// - public override bool CanHandle( - ITypeCompletionContext context, - IFilterInputTypeDefinition typeDefinition, - IFilterFieldDefinition fieldDefinition) + /// + public override bool TryHandleEnter( + MongoDbFilterVisitorContext context, + IFilterField field, + ObjectFieldNode node, + [NotNullWhen(true)] out ISyntaxVisitorAction? action) + { + if (node.Value.IsNull()) { - return context.Type is IListFilterInputType && - fieldDefinition is FilterOperationFieldDefinition operationField && - operationField.Id == Operation; + context.ReportError( + ErrorHelper.CreateNonNullError(field, node.Value, context)); + + action = SyntaxVisitor.Skip; + return true; } - /// - public override bool TryHandleEnter( - MongoDbFilterVisitorContext context, - IFilterField field, - ObjectFieldNode node, - [NotNullWhen(true)] out ISyntaxVisitorAction? action) + if (context.RuntimeTypes.Count > 0 && + context.RuntimeTypes.Peek().TypeArguments is { Count: > 0 } args) { - if (node.Value.IsNull()) - { - context.ReportError( - ErrorHelper.CreateNonNullError(field, node.Value, context)); - - action = SyntaxVisitor.Skip; - return true; - } + IExtendedType element = args[0]; + context.RuntimeTypes.Push(element); + context.AddScope(); - if (context.RuntimeTypes.Count > 0 && - context.RuntimeTypes.Peek().TypeArguments is { Count: > 0 } args) - { - IExtendedType element = args[0]; - context.RuntimeTypes.Push(element); - context.AddScope(); - - action = SyntaxVisitor.Continue; - return true; - } - - action = null; - return false; + action = SyntaxVisitor.Continue; + return true; } - /// - public override bool TryHandleLeave( - MongoDbFilterVisitorContext context, - IFilterField field, - ObjectFieldNode node, - [NotNullWhen(true)] out ISyntaxVisitorAction? action) - { - context.RuntimeTypes.Pop(); + action = null; + return false; + } - if (context.TryCreateQuery(out MongoDbFilterDefinition? query) && - context.Scopes.Pop() is MongoDbFilterScope scope) - { - var path = context.GetMongoFilterScope().GetPath(); - MongoDbFilterDefinition combinedOperations = HandleListOperation( - context, - field, - scope, - path); + /// + public override bool TryHandleLeave( + MongoDbFilterVisitorContext context, + IFilterField field, + ObjectFieldNode node, + [NotNullWhen(true)] out ISyntaxVisitorAction? action) + { + context.RuntimeTypes.Pop(); - context.GetLevel().Enqueue(combinedOperations); - } + if (context.TryCreateQuery(out MongoDbFilterDefinition? query) && + context.Scopes.Pop() is MongoDbFilterScope scope) + { + var path = context.GetMongoFilterScope().GetPath(); + MongoDbFilterDefinition combinedOperations = HandleListOperation( + context, + field, + scope, + path); - action = SyntaxVisitor.Continue; - return true; + context.GetLevel().Enqueue(combinedOperations); } - /// - /// Maps a operation field to a mongodb list filter definition. - /// This method is called when the enters a - /// field - /// - /// The context of the visitor - /// The currently visited filter field - /// The current scope of the visitor - /// The path that leads to this visitor - /// - protected abstract MongoDbFilterDefinition HandleListOperation( - MongoDbFilterVisitorContext context, - IFilterField field, - MongoDbFilterScope scope, - string path); + action = SyntaxVisitor.Continue; + return true; + } - /// - /// Combines all definitions of the with and - /// - /// The scope where the definitions should be combined - /// A with and combined filter definition of all definitions of the scope - protected static MongoDbFilterDefinition CombineOperationsOfScope( - MongoDbFilterScope scope) - { - Queue level = scope.Level.Peek(); - if (level.Count == 1) - { - return level.Peek(); - } + /// + /// Maps a operation field to a mongodb list filter definition. + /// This method is called when the enters a + /// field + /// + /// The context of the visitor + /// The currently visited filter field + /// The current scope of the visitor + /// The path that leads to this visitor + /// + protected abstract MongoDbFilterDefinition HandleListOperation( + MongoDbFilterVisitorContext context, + IFilterField field, + MongoDbFilterScope scope, + string path); - return new AndFilterDefinition(level.ToArray()); + /// + /// Combines all definitions of the with and + /// + /// The scope where the definitions should be combined + /// A with and combined filter definition of all definitions of the scope + protected static MongoDbFilterDefinition CombineOperationsOfScope( + MongoDbFilterScope scope) + { + Queue level = scope.Level.Peek(); + if (level.Count == 1) + { + return level.Peek(); } + + return new AndFilterDefinition(level.ToArray()); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListSomeOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListSomeOperationHandler.cs index 8427b02b95a..7c7a43439e5 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListSomeOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/List/MongoDbListSomeOperationHandler.cs @@ -1,26 +1,25 @@ using HotChocolate.Data.Filters; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a Some operation field to a +/// +/// +public class MongoDbListSomeOperationHandler : MongoDbListOperationHandlerBase { - /// - /// This filter operation handler maps a Some operation field to a - /// - /// - public class MongoDbListSomeOperationHandler : MongoDbListOperationHandlerBase - { - /// - protected override int Operation => DefaultFilterOperations.Some; + /// + protected override int Operation => DefaultFilterOperations.Some; - /// - protected override MongoDbFilterDefinition HandleListOperation( - MongoDbFilterVisitorContext context, - IFilterField field, - MongoDbFilterScope scope, - string path) - { - return new MongoDbFilterOperation( - path, - new MongoDbFilterOperation("$elemMatch", CombineOperationsOfScope(scope))); - } + /// + protected override MongoDbFilterDefinition HandleListOperation( + MongoDbFilterVisitorContext context, + IFilterField field, + MongoDbFilterScope scope, + string path) + { + return new MongoDbFilterOperation( + path, + new MongoDbFilterOperation("$elemMatch", CombineOperationsOfScope(scope))); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbDefaultFieldHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbDefaultFieldHandler.cs index e3d5ded770c..c32582115dd 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbDefaultFieldHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbDefaultFieldHandler.cs @@ -4,67 +4,66 @@ using HotChocolate.Language; using HotChocolate.Language.Visitors; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// The default handler for all for the +/// +/// +public class MongoDbDefaultFieldHandler + : FilterFieldHandler { /// - /// The default handler for all for the - /// + /// Checks if the field not a filter operations field /// - public class MongoDbDefaultFieldHandler - : FilterFieldHandler - { - /// - /// Checks if the field not a filter operations field - /// - /// The current context - /// The definition of the type that declares the field - /// The definition of the field - /// True in case the field can be handled - public override bool CanHandle( - ITypeCompletionContext context, - IFilterInputTypeDefinition typeDefinition, - IFilterFieldDefinition fieldDefinition) => - !(fieldDefinition is FilterOperationFieldDefinition); + /// The current context + /// The definition of the type that declares the field + /// The definition of the field + /// True in case the field can be handled + public override bool CanHandle( + ITypeCompletionContext context, + IFilterInputTypeDefinition typeDefinition, + IFilterFieldDefinition fieldDefinition) => + !(fieldDefinition is FilterOperationFieldDefinition); - /// - public override bool TryHandleEnter( - MongoDbFilterVisitorContext context, - IFilterField field, - ObjectFieldNode node, - [NotNullWhen(true)] out ISyntaxVisitorAction? action) + /// + public override bool TryHandleEnter( + MongoDbFilterVisitorContext context, + IFilterField field, + ObjectFieldNode node, + [NotNullWhen(true)] out ISyntaxVisitorAction? action) + { + if (node.Value.IsNull()) { - if (node.Value.IsNull()) - { - context.ReportError(ErrorHelper.CreateNonNullError(field, node.Value, context)); + context.ReportError(ErrorHelper.CreateNonNullError(field, node.Value, context)); - action = SyntaxVisitor.Skip; - return true; - } - - if (field.RuntimeType is null) - { - action = null; - return false; - } - - context.GetMongoFilterScope().Path.Push(field.GetName()); - context.RuntimeTypes.Push(field.RuntimeType); - action = SyntaxVisitor.Continue; + action = SyntaxVisitor.Skip; return true; } - /// - public override bool TryHandleLeave( - MongoDbFilterVisitorContext context, - IFilterField field, - ObjectFieldNode node, - [NotNullWhen(true)] out ISyntaxVisitorAction? action) + if (field.RuntimeType is null) { - context.RuntimeTypes.Pop(); - context.GetMongoFilterScope().Path.Pop(); - - action = SyntaxVisitor.Continue; - return true; + action = null; + return false; } + + context.GetMongoFilterScope().Path.Push(field.GetName()); + context.RuntimeTypes.Push(field.RuntimeType); + action = SyntaxVisitor.Continue; + return true; + } + + /// + public override bool TryHandleLeave( + MongoDbFilterVisitorContext context, + IFilterField field, + ObjectFieldNode node, + [NotNullWhen(true)] out ISyntaxVisitorAction? action) + { + context.RuntimeTypes.Pop(); + context.GetMongoFilterScope().Path.Pop(); + + action = SyntaxVisitor.Continue; + return true; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbEqualsOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbEqualsOperationHandler.cs index a72927deb5f..3e89e2162a0 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbEqualsOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbEqualsOperationHandler.cs @@ -5,39 +5,38 @@ using MongoDB.Bson; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a Equals operation field to a +/// +/// +public class MongoDbEqualsOperationHandler + : MongoDbOperationHandlerBase { - /// - /// This filter operation handler maps a Equals operation field to a - /// - /// - public class MongoDbEqualsOperationHandler - : MongoDbOperationHandlerBase + public MongoDbEqualsOperationHandler(InputParser inputParser) : base(inputParser) { - public MongoDbEqualsOperationHandler(InputParser inputParser) : base(inputParser) - { - } + } - /// - public override bool CanHandle( - ITypeCompletionContext context, - IFilterInputTypeDefinition typeDefinition, - IFilterFieldDefinition fieldDefinition) - { - return fieldDefinition is FilterOperationFieldDefinition operationField && - operationField.Id is DefaultFilterOperations.Equals; - } + /// + public override bool CanHandle( + ITypeCompletionContext context, + IFilterInputTypeDefinition typeDefinition, + IFilterFieldDefinition fieldDefinition) + { + return fieldDefinition is FilterOperationFieldDefinition operationField && + operationField.Id is DefaultFilterOperations.Equals; + } - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) - { - var doc = new MongoDbFilterOperation("$eq", parsedValue); + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + var doc = new MongoDbFilterOperation("$eq", parsedValue); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbInOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbInOperationHandler.cs index ad1a4929545..47f60afeb65 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbInOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbInOperationHandler.cs @@ -1,42 +1,41 @@ using HotChocolate.Configuration; -using HotChocolate.Types; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a In operation field to a +/// +/// +public class MongoDbInOperationHandler + : MongoDbOperationHandlerBase { - /// - /// This filter operation handler maps a In operation field to a - /// - /// - public class MongoDbInOperationHandler - : MongoDbOperationHandlerBase + public MongoDbInOperationHandler(InputParser inputParser) : base(inputParser) { - public MongoDbInOperationHandler(InputParser inputParser) : base(inputParser) - { - } + } - /// - public override bool CanHandle( - ITypeCompletionContext context, - IFilterInputTypeDefinition typeDefinition, - IFilterFieldDefinition fieldDefinition) - { - return fieldDefinition is FilterOperationFieldDefinition operationField && - operationField.Id is DefaultFilterOperations.In; - } + /// + public override bool CanHandle( + ITypeCompletionContext context, + IFilterInputTypeDefinition typeDefinition, + IFilterFieldDefinition fieldDefinition) + { + return fieldDefinition is FilterOperationFieldDefinition operationField && + operationField.Id is DefaultFilterOperations.In; + } - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) - { - var doc = new MongoDbFilterOperation("$in", parsedValue); + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + var doc = new MongoDbFilterOperation("$in", parsedValue); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbNotEqualsOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbNotEqualsOperationHandler.cs index 60063de7904..b25fc47353f 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbNotEqualsOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbNotEqualsOperationHandler.cs @@ -1,43 +1,42 @@ using HotChocolate.Configuration; -using HotChocolate.Types; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Bson; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a NotEquals operation field to a +/// +/// +public class MongoDbNotEqualsOperationHandler + : MongoDbOperationHandlerBase { - /// - /// This filter operation handler maps a NotEquals operation field to a - /// - /// - public class MongoDbNotEqualsOperationHandler - : MongoDbOperationHandlerBase + public MongoDbNotEqualsOperationHandler(InputParser inputParser) : base(inputParser) { - public MongoDbNotEqualsOperationHandler(InputParser inputParser) : base(inputParser) - { - } + } - /// - public override bool CanHandle( - ITypeCompletionContext context, - IFilterInputTypeDefinition typeDefinition, - IFilterFieldDefinition fieldDefinition) - { - return fieldDefinition is FilterOperationFieldDefinition operationField && - operationField.Id is DefaultFilterOperations.NotEquals; - } + /// + public override bool CanHandle( + ITypeCompletionContext context, + IFilterInputTypeDefinition typeDefinition, + IFilterFieldDefinition fieldDefinition) + { + return fieldDefinition is FilterOperationFieldDefinition operationField && + operationField.Id is DefaultFilterOperations.NotEquals; + } - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) - { - var doc = new MongoDbFilterOperation("$ne", parsedValue); + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + var doc = new MongoDbFilterOperation("$ne", parsedValue); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbNotInOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbNotInOperationHandler.cs index 28bad8f3c07..0aaa9b65473 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbNotInOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbNotInOperationHandler.cs @@ -1,42 +1,41 @@ using HotChocolate.Configuration; -using HotChocolate.Types; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// This filter operation handler maps a NotIn operation field to a +/// +/// +public class MongoDbNotInOperationHandler + : MongoDbOperationHandlerBase { - /// - /// This filter operation handler maps a NotIn operation field to a - /// - /// - public class MongoDbNotInOperationHandler - : MongoDbOperationHandlerBase + public MongoDbNotInOperationHandler(InputParser inputParser) : base(inputParser) { - public MongoDbNotInOperationHandler(InputParser inputParser) : base(inputParser) - { - } + } - /// - public override bool CanHandle( - ITypeCompletionContext context, - IFilterInputTypeDefinition typeDefinition, - IFilterFieldDefinition fieldDefinition) - { - return fieldDefinition is FilterOperationFieldDefinition operationField && - operationField.Id is DefaultFilterOperations.NotIn; - } + /// + public override bool CanHandle( + ITypeCompletionContext context, + IFilterInputTypeDefinition typeDefinition, + IFilterFieldDefinition fieldDefinition) + { + return fieldDefinition is FilterOperationFieldDefinition operationField && + operationField.Id is DefaultFilterOperations.NotIn; + } - /// - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) - { - var doc = new MongoDbFilterOperation("$nin", parsedValue); + /// + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + var doc = new MongoDbFilterOperation("$nin", parsedValue); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbOperationHandlerBase.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbOperationHandlerBase.cs index 9f6bc0bc846..4eb1622de21 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbOperationHandlerBase.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/MongoDbOperationHandlerBase.cs @@ -6,78 +6,77 @@ using HotChocolate.Language; using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// The base of a mongodb operation handler that can be bound to a +/// . The is executed during the visitation of a input object. +/// This base is optimized to handle filter operations for mongodb +/// +public abstract class MongoDbOperationHandlerBase + : FilterOperationHandler { - /// - /// The base of a mongodb operation handler that can be bound to a - /// . The is executed during the visitation of a input object. - /// This base is optimized to handle filter operations for mongodb - /// - public abstract class MongoDbOperationHandlerBase - : FilterOperationHandler + protected MongoDbOperationHandlerBase(InputParser inputParser) { - protected MongoDbOperationHandlerBase(InputParser inputParser) - { - InputParser = inputParser; - } - - protected InputParser InputParser { get; } - - /// - public override bool TryHandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - ObjectFieldNode node, - [NotNullWhen(true)] out MongoDbFilterDefinition result) - { - IValueNode value = node.Value; - IExtendedType runtimeType = context.RuntimeTypes.Peek(); + InputParser = inputParser; + } - Type type = field.Type.IsListType() - ? runtimeType.Source.MakeArrayType() - : runtimeType.Source; + protected InputParser InputParser { get; } - object? parsedValue = InputParser.ParseLiteral(value, field, type); + /// + public override bool TryHandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + ObjectFieldNode node, + [NotNullWhen(true)] out MongoDbFilterDefinition result) + { + IValueNode value = node.Value; + IExtendedType runtimeType = context.RuntimeTypes.Peek(); - if ((!runtimeType.IsNullable || !CanBeNull) && parsedValue is null) - { - IError error = ErrorHelper.CreateNonNullError(field, value, context); - context.ReportError(error); - result = null!; - return false; - } + Type type = field.Type.IsListType() + ? runtimeType.Source.MakeArrayType() + : runtimeType.Source; - if (!ValueNullabilityHelpers.IsListValueValid(field.Type, runtimeType, node.Value)) - { - IError error = ErrorHelper.CreateNonNullError(field, value, context, true); - context.ReportError(error); - result = null!; - return false; - } + object? parsedValue = InputParser.ParseLiteral(value, field, type); - result = HandleOperation(context, field, value, parsedValue); - return true; + if ((!runtimeType.IsNullable || !CanBeNull) && parsedValue is null) + { + IError error = ErrorHelper.CreateNonNullError(field, value, context); + context.ReportError(error); + result = null!; + return false; } - /// - /// if this value is true, null values are allowed as inputs - /// - protected bool CanBeNull { get; set; } = true; + if (!ValueNullabilityHelpers.IsListValueValid(field.Type, runtimeType, node.Value)) + { + IError error = ErrorHelper.CreateNonNullError(field, value, context, true); + context.ReportError(error); + result = null!; + return false; + } - /// - /// Maps a operation field to a provider specific result. - /// This method is called when the enters a - /// field - /// - /// The of the visitor - /// The field that is currently being visited - /// The value node of this field - /// The value of the value node - /// If true is returned the action is used for further processing - public abstract MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue); + result = HandleOperation(context, field, value, parsedValue); + return true; } + + /// + /// if this value is true, null values are allowed as inputs + /// + protected bool CanBeNull { get; set; } = true; + + /// + /// Maps a operation field to a provider specific result. + /// This method is called when the enters a + /// field + /// + /// The of the visitor + /// The field that is currently being visited + /// The value node of this field + /// The value of the value node + /// If true is returned the action is used for further processing + public abstract MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue); } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringContainsHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringContainsHandler.cs index e274adcdbb7..fb0869b368c 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringContainsHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringContainsHandler.cs @@ -2,39 +2,38 @@ using System.Text.RegularExpressions; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Bson; using MongoDB.Driver; -using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbStringContainsHandler + : MongoDbStringOperationHandler { - public class MongoDbStringContainsHandler - : MongoDbStringOperationHandler + public MongoDbStringContainsHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbStringContainsHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - protected override int Operation => DefaultFilterOperations.Contains; + protected override int Operation => DefaultFilterOperations.Contains; - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is string str) { - if (parsedValue is string str) - { - var doc = new MongoDbFilterOperation( - "$regex", - new BsonRegularExpression($"/{Regex.Escape(str)}/")); + var doc = new MongoDbFilterOperation( + "$regex", + new BsonRegularExpression($"/{Regex.Escape(str)}/")); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringEndsWithHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringEndsWithHandler.cs index 6b0946d16a5..fa3d0f60dda 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringEndsWithHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringEndsWithHandler.cs @@ -2,39 +2,38 @@ using System.Text.RegularExpressions; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Bson; using MongoDB.Driver; -using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbStringEndsWithHandler + : MongoDbStringOperationHandler { - public class MongoDbStringEndsWithHandler - : MongoDbStringOperationHandler + public MongoDbStringEndsWithHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbStringEndsWithHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - protected override int Operation => DefaultFilterOperations.EndsWith; + protected override int Operation => DefaultFilterOperations.EndsWith; - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is string str) { - if (parsedValue is string str) - { - var doc = new MongoDbFilterOperation( - "$regex", - new BsonRegularExpression($"/{Regex.Escape(str)}$/")); + var doc = new MongoDbFilterOperation( + "$regex", + new BsonRegularExpression($"/{Regex.Escape(str)}$/")); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotContainsHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotContainsHandler.cs index 04670ce1be8..0a14df07fa9 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotContainsHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotContainsHandler.cs @@ -2,40 +2,39 @@ using System.Text.RegularExpressions; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Bson; using MongoDB.Driver; -using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbStringNotContainsHandler + : MongoDbStringOperationHandler { - public class MongoDbStringNotContainsHandler - : MongoDbStringOperationHandler + public MongoDbStringNotContainsHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbStringNotContainsHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - protected override int Operation => DefaultFilterOperations.NotContains; + protected override int Operation => DefaultFilterOperations.NotContains; - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is string str) { - if (parsedValue is string str) - { - var doc = new NotMongoDbFilterDefinition( - new MongoDbFilterOperation( - "$regex", - new BsonRegularExpression($"/{Regex.Escape(str)}/"))); + var doc = new NotMongoDbFilterDefinition( + new MongoDbFilterOperation( + "$regex", + new BsonRegularExpression($"/{Regex.Escape(str)}/"))); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotEndsWithHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotEndsWithHandler.cs index e39f60dd921..07813cc33cc 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotEndsWithHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotEndsWithHandler.cs @@ -2,40 +2,39 @@ using System.Text.RegularExpressions; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Bson; using MongoDB.Driver; -using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbStringNotEndsWithHandler + : MongoDbStringOperationHandler { - public class MongoDbStringNotEndsWithHandler - : MongoDbStringOperationHandler + public MongoDbStringNotEndsWithHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbStringNotEndsWithHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - protected override int Operation => DefaultFilterOperations.NotEndsWith; + protected override int Operation => DefaultFilterOperations.NotEndsWith; - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is string str) { - if (parsedValue is string str) - { - var doc = new NotMongoDbFilterDefinition( - new MongoDbFilterOperation( - "$regex", - new BsonRegularExpression($"/{Regex.Escape(str)}$/"))); + var doc = new NotMongoDbFilterDefinition( + new MongoDbFilterOperation( + "$regex", + new BsonRegularExpression($"/{Regex.Escape(str)}$/"))); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotStartsWithHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotStartsWithHandler.cs index cf3345680bb..c0ba8112582 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotStartsWithHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringNotStartsWithHandler.cs @@ -2,40 +2,39 @@ using System.Text.RegularExpressions; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Bson; using MongoDB.Driver; -using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbStringNotStartsWithHandler + : MongoDbStringOperationHandler { - public class MongoDbStringNotStartsWithHandler - : MongoDbStringOperationHandler + public MongoDbStringNotStartsWithHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbStringNotStartsWithHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - protected override int Operation => DefaultFilterOperations.NotStartsWith; + protected override int Operation => DefaultFilterOperations.NotStartsWith; - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is string str) { - if (parsedValue is string str) - { - var doc = new NotMongoDbFilterDefinition( - new MongoDbFilterOperation( - "$regex", - new BsonRegularExpression($"/^{Regex.Escape(str)}/"))); + var doc = new NotMongoDbFilterDefinition( + new MongoDbFilterOperation( + "$regex", + new BsonRegularExpression($"/^{Regex.Escape(str)}/"))); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringOperationHandler.cs index 5773f60dc9f..1a5a8173464 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringOperationHandler.cs @@ -1,26 +1,25 @@ using HotChocolate.Configuration; -using HotChocolate.Types; using HotChocolate.Data.Filters; +using HotChocolate.Types; + +namespace HotChocolate.Data.MongoDb.Filters; -namespace HotChocolate.Data.MongoDb.Filters +public abstract class MongoDbStringOperationHandler + : MongoDbOperationHandlerBase { - public abstract class MongoDbStringOperationHandler - : MongoDbOperationHandlerBase + public MongoDbStringOperationHandler(InputParser inputParser) : base(inputParser) { - public MongoDbStringOperationHandler(InputParser inputParser) : base(inputParser) - { - } + } - protected abstract int Operation { get; } + protected abstract int Operation { get; } - public override bool CanHandle( - ITypeCompletionContext context, - IFilterInputTypeDefinition typeDefinition, - IFilterFieldDefinition fieldDefinition) - { - return context.Type is StringOperationFilterInputType && - fieldDefinition is FilterOperationFieldDefinition operationField && - operationField.Id == Operation; - } + public override bool CanHandle( + ITypeCompletionContext context, + IFilterInputTypeDefinition typeDefinition, + IFilterFieldDefinition fieldDefinition) + { + return context.Type is StringOperationFilterInputType && + fieldDefinition is FilterOperationFieldDefinition operationField && + operationField.Id == Operation; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringStartsWithHandler.cs b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringStartsWithHandler.cs index 0db74d8deb0..72604794f58 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringStartsWithHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/Handlers/String/MongoDbStringStartsWithHandler.cs @@ -2,39 +2,38 @@ using System.Text.RegularExpressions; using HotChocolate.Data.Filters; using HotChocolate.Language; +using HotChocolate.Types; using MongoDB.Bson; using MongoDB.Driver; -using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbStringStartsWithHandler + : MongoDbStringOperationHandler { - public class MongoDbStringStartsWithHandler - : MongoDbStringOperationHandler + public MongoDbStringStartsWithHandler(InputParser inputParser) + : base(inputParser) { - public MongoDbStringStartsWithHandler(InputParser inputParser) - : base(inputParser) - { - CanBeNull = false; - } + CanBeNull = false; + } - protected override int Operation => DefaultFilterOperations.StartsWith; + protected override int Operation => DefaultFilterOperations.StartsWith; - public override MongoDbFilterDefinition HandleOperation( - MongoDbFilterVisitorContext context, - IFilterOperationField field, - IValueNode value, - object? parsedValue) + public override MongoDbFilterDefinition HandleOperation( + MongoDbFilterVisitorContext context, + IFilterOperationField field, + IValueNode value, + object? parsedValue) + { + if (parsedValue is string str) { - if (parsedValue is string str) - { - var doc = new MongoDbFilterOperation( - "$regex", - new BsonRegularExpression($"/^{Regex.Escape(str)}/")); + var doc = new MongoDbFilterOperation( + "$regex", + new BsonRegularExpression($"/^{Regex.Escape(str)}/")); - return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); - } - - throw new InvalidOperationException(); + return new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc); } + + throw new InvalidOperationException(); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterCombinator.cs b/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterCombinator.cs index 05811a76724..fa4f187740f 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterCombinator.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterCombinator.cs @@ -5,55 +5,54 @@ using MongoDB.Bson; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +public class MongoDbFilterCombinator + : FilterOperationCombinator { /// - public class MongoDbFilterCombinator - : FilterOperationCombinator + public override bool TryCombineOperations( + MongoDbFilterVisitorContext context, + Queue operations, + FilterCombinator combinator, + [NotNullWhen(true)] out MongoDbFilterDefinition combined) { - /// - public override bool TryCombineOperations( - MongoDbFilterVisitorContext context, - Queue operations, - FilterCombinator combinator, - [NotNullWhen(true)] out MongoDbFilterDefinition combined) + if (operations.Count == 0) { - if (operations.Count == 0) - { - throw ThrowHelper.Filtering_MongoDbCombinator_QueueEmpty(this); - } - - combined = combinator switch - { - FilterCombinator.And => CombineWithAnd(operations), - FilterCombinator.Or => CombineWithOr(operations), - _ => throw ThrowHelper - .Filtering_MongoDbCombinator_InvalidCombinator(this, combinator) - }; - - return true; + throw ThrowHelper.Filtering_MongoDbCombinator_QueueEmpty(this); } - private static MongoDbFilterDefinition CombineWithAnd( - Queue operations) + combined = combinator switch { - if (operations.Count == 0) - { - throw new InvalidOperationException(); - } + FilterCombinator.And => CombineWithAnd(operations), + FilterCombinator.Or => CombineWithOr(operations), + _ => throw ThrowHelper + .Filtering_MongoDbCombinator_InvalidCombinator(this, combinator) + }; - return new AndFilterDefinition(operations.ToArray()); - } + return true; + } - private static MongoDbFilterDefinition CombineWithOr( - Queue operations) + private static MongoDbFilterDefinition CombineWithAnd( + Queue operations) + { + if (operations.Count == 0) { - if (operations.Count == 0) - { - throw new InvalidOperationException(); - } + throw new InvalidOperationException(); + } - return new OrMongoDbFilterDefinition(operations.ToArray()); + return new AndFilterDefinition(operations.ToArray()); + } + + private static MongoDbFilterDefinition CombineWithOr( + Queue operations) + { + if (operations.Count == 0) + { + throw new InvalidOperationException(); } + + return new OrMongoDbFilterDefinition(operations.ToArray()); } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterProvider.cs b/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterProvider.cs index 15d002191a2..7ae47019a87 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterProvider.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterProvider.cs @@ -6,81 +6,81 @@ using HotChocolate.Types; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +/// A translates a incoming query to a +/// +/// +public class MongoDbFilterProvider + : FilterProvider { - /// - /// A translates a incoming query to a - /// - /// - public class MongoDbFilterProvider - : FilterProvider + /// + public MongoDbFilterProvider() { - /// - public MongoDbFilterProvider() - { - } + } - /// - public MongoDbFilterProvider( - Action> configure) - : base(configure) - { - } + /// + public MongoDbFilterProvider( + Action> configure) + : base(configure) + { + } - /// - /// The visitor that is used to traverse the incoming selection set an execute handlers - /// - protected virtual FilterVisitor - Visitor { get; } = new(new MongoDbFilterCombinator()); + /// + /// The visitor that is used to traverse the incoming selection set an execute handlers + /// + protected virtual FilterVisitor + Visitor + { get; } = new(new MongoDbFilterCombinator()); + + /// + public override FieldMiddleware CreateExecutor(NameString argumentName) + { + return next => context => ExecuteAsync(next, context); - /// - public override FieldMiddleware CreateExecutor(NameString argumentName) + async ValueTask ExecuteAsync( + FieldDelegate next, + IMiddlewareContext context) { - return next => context => ExecuteAsync(next, context); + MongoDbFilterVisitorContext? visitorContext = null; + IInputField argument = context.Selection.Field.Arguments[argumentName]; + IValueNode filter = context.ArgumentLiteral(argumentName); - async ValueTask ExecuteAsync( - FieldDelegate next, - IMiddlewareContext context) + if (filter is not NullValueNode && argument.Type is IFilterInputType filterInput) { - MongoDbFilterVisitorContext? visitorContext = null; - IInputField argument = context.Selection.Field.Arguments[argumentName]; - IValueNode filter = context.ArgumentLiteral(argumentName); + visitorContext = new MongoDbFilterVisitorContext(filterInput); - if (filter is not NullValueNode && argument.Type is IFilterInputType filterInput) - { - visitorContext = new MongoDbFilterVisitorContext(filterInput); - - Visitor.Visit(filter, visitorContext); + Visitor.Visit(filter, visitorContext); - if (!visitorContext.TryCreateQuery(out MongoDbFilterDefinition? whereQuery) || - visitorContext.Errors.Count > 0) - { - context.Result = Array.Empty(); - foreach (IError error in visitorContext.Errors) - { - context.ReportError(error.WithPath(context.Path)); - } - } - else + if (!visitorContext.TryCreateQuery(out MongoDbFilterDefinition? whereQuery) || + visitorContext.Errors.Count > 0) + { + context.Result = Array.Empty(); + foreach (IError error in visitorContext.Errors) { - context.LocalContextData = - context.LocalContextData.SetItem( - nameof(FilterDefinition), - whereQuery); - - await next(context).ConfigureAwait(false); - - if (context.Result is IMongoDbExecutable executable) - { - context.Result = executable.WithFiltering(whereQuery); - } + context.ReportError(error.WithPath(context.Path)); } } else { + context.LocalContextData = + context.LocalContextData.SetItem( + nameof(FilterDefinition), + whereQuery); + await next(context).ConfigureAwait(false); + + if (context.Result is IMongoDbExecutable executable) + { + context.Result = executable.WithFiltering(whereQuery); + } } } + else + { + await next(context).ConfigureAwait(false); + } } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterScope.cs b/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterScope.cs index 4f740dc272a..5c817b9f77c 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterScope.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterScope.cs @@ -1,15 +1,14 @@ using System.Collections.Generic; using HotChocolate.Data.Filters; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +public class MongoDbFilterScope + : FilterScope { - /// - public class MongoDbFilterScope - : FilterScope - { - /// - /// The path from the root to the current position in the input object - /// - public Stack Path { get; } = new Stack(); - } + /// + /// The path from the root to the current position in the input object + /// + public Stack Path { get; } = new Stack(); } diff --git a/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterVisitorContext.cs b/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterVisitorContext.cs index 2d43e054e09..81953f3d8b7 100644 --- a/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterVisitorContext.cs +++ b/src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterVisitorContext.cs @@ -2,26 +2,25 @@ using HotChocolate.Data.Filters; using HotChocolate.Internal; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +/// +public class MongoDbFilterVisitorContext + : FilterVisitorContext { - /// - public class MongoDbFilterVisitorContext - : FilterVisitorContext + public MongoDbFilterVisitorContext(IFilterInputType initialType) + : base(initialType) { - public MongoDbFilterVisitorContext(IFilterInputType initialType) - : base(initialType) - { - RuntimeTypes = new Stack(); - RuntimeTypes.Push(initialType.EntityType); - } + RuntimeTypes = new Stack(); + RuntimeTypes.Push(initialType.EntityType); + } - /// - /// The already visited runtime types - /// - public Stack RuntimeTypes { get; } + /// + /// The already visited runtime types + /// + public Stack RuntimeTypes { get; } - /// - public override FilterScope CreateScope() => - new MongoDbFilterScope(); - } + /// + public override FilterScope CreateScope() => + new MongoDbFilterScope(); } diff --git a/src/HotChocolate/MongoDb/src/Data/Paging/AggregateFluentPagingContainer.cs b/src/HotChocolate/MongoDb/src/Data/Paging/AggregateFluentPagingContainer.cs index dfff857f9eb..5f326f975ce 100644 --- a/src/HotChocolate/MongoDb/src/Data/Paging/AggregateFluentPagingContainer.cs +++ b/src/HotChocolate/MongoDb/src/Data/Paging/AggregateFluentPagingContainer.cs @@ -4,66 +4,65 @@ using HotChocolate.Types.Pagination; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +internal class AggregateFluentPagingContainer : IMongoPagingContainer { - internal class AggregateFluentPagingContainer : IMongoPagingContainer - { - private readonly IAggregateFluent _source; - private readonly IAggregateFluent _countSource; + private readonly IAggregateFluent _source; + private readonly IAggregateFluent _countSource; - public AggregateFluentPagingContainer(IAggregateFluent source) - { - _countSource = source.Count(); - _source = source; - } + public AggregateFluentPagingContainer(IAggregateFluent source) + { + _countSource = source.Count(); + _source = source; + } - public async Task CountAsync(CancellationToken cancellationToken) - { - AggregateCountResult result = await _countSource - .FirstOrDefaultAsync(cancellationToken) - .ConfigureAwait(false); + public async Task CountAsync(CancellationToken cancellationToken) + { + AggregateCountResult result = await _countSource + .FirstOrDefaultAsync(cancellationToken) + .ConfigureAwait(false); - return (int)(result?.Count ?? 0L); - } + return (int)(result?.Count ?? 0L); + } - public async ValueTask>> ExecuteQueryAsync( - int offset, - CancellationToken cancellationToken) - { - var list = new List>(); + public async ValueTask>> ExecuteQueryAsync( + int offset, + CancellationToken cancellationToken) + { + var list = new List>(); - using IAsyncCursor cursor = await _source - .ToCursorAsync(cancellationToken) - .ConfigureAwait(false); + using IAsyncCursor cursor = await _source + .ToCursorAsync(cancellationToken) + .ConfigureAwait(false); - var index = offset; - while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false)) + var index = offset; + while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false)) + { + foreach (TEntity item in cursor.Current) { - foreach (TEntity item in cursor.Current) - { - list.Add(IndexEdge.Create(item, index++)); - } + list.Add(IndexEdge.Create(item, index++)); } - - return list; } - public async ValueTask> ToListAsync(CancellationToken cancellationToken) - { - return await _source.ToListAsync(cancellationToken).ConfigureAwait(false); - } + return list; + } - public IMongoPagingContainer Skip(int skip) - { - return new AggregateFluentPagingContainer(_source.Skip(skip)); - } + public async ValueTask> ToListAsync(CancellationToken cancellationToken) + { + return await _source.ToListAsync(cancellationToken).ConfigureAwait(false); + } - public IMongoPagingContainer Take(int take) - { - return new AggregateFluentPagingContainer(_source.Limit(take)); - } + public IMongoPagingContainer Skip(int skip) + { + return new AggregateFluentPagingContainer(_source.Skip(skip)); + } - public static AggregateFluentPagingContainer New( - IAggregateFluent aggregate) => new(aggregate); + public IMongoPagingContainer Take(int take) + { + return new AggregateFluentPagingContainer(_source.Limit(take)); } + + public static AggregateFluentPagingContainer New( + IAggregateFluent aggregate) => new(aggregate); } diff --git a/src/HotChocolate/MongoDb/src/Data/Paging/FindFluentPagingContainer.cs b/src/HotChocolate/MongoDb/src/Data/Paging/FindFluentPagingContainer.cs index 05718cba0fa..0ac9b0ecaf6 100644 --- a/src/HotChocolate/MongoDb/src/Data/Paging/FindFluentPagingContainer.cs +++ b/src/HotChocolate/MongoDb/src/Data/Paging/FindFluentPagingContainer.cs @@ -5,66 +5,65 @@ using MongoDB.Bson; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +internal class FindFluentPagingContainer : IMongoPagingContainer { - internal class FindFluentPagingContainer : IMongoPagingContainer - { - public readonly IFindFluent _source; - private readonly IFindFluent _initSource; + public readonly IFindFluent _source; + private readonly IFindFluent _initSource; - public FindFluentPagingContainer(IFindFluent source) - { - // This is the only way to somewhat clone the IFindFluent - _initSource = source.Project(Builders.Projection.As()); - _source = source; - } + public FindFluentPagingContainer(IFindFluent source) + { + // This is the only way to somewhat clone the IFindFluent + _initSource = source.Project(Builders.Projection.As()); + _source = source; + } - public async Task CountAsync(CancellationToken cancellationToken) - { - return (int)await _initSource - .CountDocumentsAsync(cancellationToken) - .ConfigureAwait(false); - } + public async Task CountAsync(CancellationToken cancellationToken) + { + return (int)await _initSource + .CountDocumentsAsync(cancellationToken) + .ConfigureAwait(false); + } - public async ValueTask>> ExecuteQueryAsync( - int offset, - CancellationToken cancellationToken) - { - var list = new List>(); + public async ValueTask>> ExecuteQueryAsync( + int offset, + CancellationToken cancellationToken) + { + var list = new List>(); - using IAsyncCursor cursor = await _source - .ToCursorAsync(cancellationToken) - .ConfigureAwait(false); + using IAsyncCursor cursor = await _source + .ToCursorAsync(cancellationToken) + .ConfigureAwait(false); - var index = offset; - while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false)) + var index = offset; + while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false)) + { + foreach (TEntity item in cursor.Current) { - foreach (TEntity item in cursor.Current) - { - list.Add(IndexEdge.Create(item, index++)); - } + list.Add(IndexEdge.Create(item, index++)); } - - return list; } - public async ValueTask> ToListAsync(CancellationToken cancellationToken) - { - return await _source.ToListAsync(cancellationToken).ConfigureAwait(false); - } + return list; + } - public IMongoPagingContainer Skip(int skip) - { - return new FindFluentPagingContainer(_source.Skip(skip)); - } + public async ValueTask> ToListAsync(CancellationToken cancellationToken) + { + return await _source.ToListAsync(cancellationToken).ConfigureAwait(false); + } - public IMongoPagingContainer Take(int take) - { - return new FindFluentPagingContainer(_source.Limit(take)); - } + public IMongoPagingContainer Skip(int skip) + { + return new FindFluentPagingContainer(_source.Skip(skip)); + } - public static FindFluentPagingContainer New( - IFindFluent find) => - new FindFluentPagingContainer(find); + public IMongoPagingContainer Take(int take) + { + return new FindFluentPagingContainer(_source.Limit(take)); } + + public static FindFluentPagingContainer New( + IFindFluent find) => + new FindFluentPagingContainer(find); } diff --git a/src/HotChocolate/MongoDb/src/Data/Paging/IMongoPagingContainer.cs b/src/HotChocolate/MongoDb/src/Data/Paging/IMongoPagingContainer.cs index 20c8b62fcfb..d3f3048f11c 100644 --- a/src/HotChocolate/MongoDb/src/Data/Paging/IMongoPagingContainer.cs +++ b/src/HotChocolate/MongoDb/src/Data/Paging/IMongoPagingContainer.cs @@ -3,20 +3,19 @@ using System.Threading.Tasks; using HotChocolate.Types.Pagination; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +internal interface IMongoPagingContainer { - internal interface IMongoPagingContainer - { - Task CountAsync(CancellationToken cancellationToken); + Task CountAsync(CancellationToken cancellationToken); - ValueTask>> ExecuteQueryAsync( - int offset, - CancellationToken cancellationToken); + ValueTask>> ExecuteQueryAsync( + int offset, + CancellationToken cancellationToken); - ValueTask> ToListAsync(CancellationToken cancellationToken); + ValueTask> ToListAsync(CancellationToken cancellationToken); - IMongoPagingContainer Skip(int skip); + IMongoPagingContainer Skip(int skip); - IMongoPagingContainer Take(int take); - } + IMongoPagingContainer Take(int take); } diff --git a/src/HotChocolate/MongoDb/src/Data/Paging/MongoCursorPagingHandler.cs b/src/HotChocolate/MongoDb/src/Data/Paging/MongoCursorPagingHandler.cs index 89e35e7431a..de58f7fc0a2 100644 --- a/src/HotChocolate/MongoDb/src/Data/Paging/MongoCursorPagingHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Paging/MongoCursorPagingHandler.cs @@ -3,30 +3,29 @@ using System.Threading.Tasks; using HotChocolate.Types.Pagination; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +internal sealed class MongoCursorPagination + : CursorPaginationAlgorithm, TEntity> { - internal sealed class MongoCursorPagination - : CursorPaginationAlgorithm, TEntity> - { - protected override IMongoPagingContainer ApplySkip( - IMongoPagingContainer query, - int skip) - => query.Skip(skip); + protected override IMongoPagingContainer ApplySkip( + IMongoPagingContainer query, + int skip) + => query.Skip(skip); - protected override IMongoPagingContainer ApplyTake( - IMongoPagingContainer query, - int take) - => query.Take(take); + protected override IMongoPagingContainer ApplyTake( + IMongoPagingContainer query, + int take) + => query.Take(take); - protected override async ValueTask CountAsync( - IMongoPagingContainer query, - CancellationToken cancellationToken) - => await query.CountAsync(cancellationToken).ConfigureAwait(false); + protected override async ValueTask CountAsync( + IMongoPagingContainer query, + CancellationToken cancellationToken) + => await query.CountAsync(cancellationToken).ConfigureAwait(false); - protected override ValueTask>> ExecuteAsync( - IMongoPagingContainer query, - int offset, - CancellationToken cancellationToken) - => query.ExecuteQueryAsync(offset, cancellationToken); - } + protected override ValueTask>> ExecuteAsync( + IMongoPagingContainer query, + int offset, + CancellationToken cancellationToken) + => query.ExecuteQueryAsync(offset, cancellationToken); } diff --git a/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbCursorPagingHandler.cs b/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbCursorPagingHandler.cs index 754b02d66a3..cb810e008d3 100644 --- a/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbCursorPagingHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbCursorPagingHandler.cs @@ -3,42 +3,41 @@ using HotChocolate.Types.Pagination; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +internal class MongoDbCursorPagingHandler : CursorPagingHandler { - internal class MongoDbCursorPagingHandler : CursorPagingHandler - { - private readonly MongoCursorPagination _pagination = new(); + private readonly MongoCursorPagination _pagination = new(); - public MongoDbCursorPagingHandler(PagingOptions options) : base(options) - { - } + public MongoDbCursorPagingHandler(PagingOptions options) : base(options) + { + } - protected override async ValueTask SliceAsync( - IResolverContext context, - object source, - CursorPagingArguments arguments) - => await _pagination.ApplyPaginationAsync( - CreatePagingContainer(source), - arguments, - context.RequestAborted) - .ConfigureAwait(false); + protected override async ValueTask SliceAsync( + IResolverContext context, + object source, + CursorPagingArguments arguments) + => await _pagination.ApplyPaginationAsync( + CreatePagingContainer(source), + arguments, + context.RequestAborted) + .ConfigureAwait(false); - private IMongoPagingContainer CreatePagingContainer(object source) + private IMongoPagingContainer CreatePagingContainer(object source) + { + return source switch { - return source switch - { - IAggregateFluent e => AggregateFluentPagingContainer.New(e), - IFindFluent f => FindFluentPagingContainer.New(f), - IMongoCollection m => FindFluentPagingContainer.New( - m.Find(FilterDefinition.Empty)), - MongoDbCollectionExecutable mce => - CreatePagingContainer(mce.BuildPipeline()), - MongoDbAggregateFluentExecutable mae => - CreatePagingContainer(mae.BuildPipeline()), - MongoDbFindFluentExecutable mfe => - CreatePagingContainer(mfe.BuildPipeline()), - _ => throw ThrowHelper.PagingTypeNotSupported(source.GetType()) - }; - } + IAggregateFluent e => AggregateFluentPagingContainer.New(e), + IFindFluent f => FindFluentPagingContainer.New(f), + IMongoCollection m => FindFluentPagingContainer.New( + m.Find(FilterDefinition.Empty)), + MongoDbCollectionExecutable mce => + CreatePagingContainer(mce.BuildPipeline()), + MongoDbAggregateFluentExecutable mae => + CreatePagingContainer(mae.BuildPipeline()), + MongoDbFindFluentExecutable mfe => + CreatePagingContainer(mfe.BuildPipeline()), + _ => throw ThrowHelper.PagingTypeNotSupported(source.GetType()) + }; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbCursorPagingProvider.cs b/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbCursorPagingProvider.cs index 4fc03d25c64..c065c31e00f 100644 --- a/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbCursorPagingProvider.cs +++ b/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbCursorPagingProvider.cs @@ -4,39 +4,38 @@ using HotChocolate.Types.Pagination; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +public class MongoDbCursorPagingProvider : CursorPagingProvider { - public class MongoDbCursorPagingProvider : CursorPagingProvider - { - private static readonly MethodInfo _createHandler = - typeof(MongoDbCursorPagingProvider).GetMethod( - nameof(CreateHandlerInternal), - BindingFlags.Static | BindingFlags.NonPublic)!; + private static readonly MethodInfo _createHandler = + typeof(MongoDbCursorPagingProvider).GetMethod( + nameof(CreateHandlerInternal), + BindingFlags.Static | BindingFlags.NonPublic)!; - public override bool CanHandle(IExtendedType source) - => typeof(IMongoDbExecutable).IsAssignableFrom(source.Source) || - source.Source.IsGenericType && - source.Source.GetGenericTypeDefinition() is { } type && ( - type == typeof(IAggregateFluent<>) || - type == typeof(IFindFluent<,>) || - type == typeof(IMongoCollection<>)); + public override bool CanHandle(IExtendedType source) + => typeof(IMongoDbExecutable).IsAssignableFrom(source.Source) || + source.Source.IsGenericType && + source.Source.GetGenericTypeDefinition() is { } type && ( + type == typeof(IAggregateFluent<>) || + type == typeof(IFindFluent<,>) || + type == typeof(IMongoCollection<>)); - protected override CursorPagingHandler CreateHandler( - IExtendedType source, - PagingOptions options) + protected override CursorPagingHandler CreateHandler( + IExtendedType source, + PagingOptions options) + { + if (source is null) { - if (source is null) - { - throw new ArgumentNullException(nameof(source)); - } - - return (CursorPagingHandler)_createHandler - .MakeGenericMethod(source.ElementType?.Source ?? source.Source) - .Invoke(null, new object[] { options })!; + throw new ArgumentNullException(nameof(source)); } - private static MongoDbCursorPagingHandler CreateHandlerInternal( - PagingOptions options) - => new(options); + return (CursorPagingHandler)_createHandler + .MakeGenericMethod(source.ElementType?.Source ?? source.Source) + .Invoke(null, new object[] { options })!; } + + private static MongoDbCursorPagingHandler CreateHandlerInternal( + PagingOptions options) + => new(options); } diff --git a/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbOffsetPagingHandler.cs b/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbOffsetPagingHandler.cs index 3519643817c..e929c8bb7cf 100644 --- a/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbOffsetPagingHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbOffsetPagingHandler.cs @@ -3,42 +3,41 @@ using HotChocolate.Types.Pagination; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +internal class MongoDbOffsetPagingHandler : OffsetPagingHandler { - internal class MongoDbOffsetPagingHandler : OffsetPagingHandler - { - private readonly MongoOffsetPagination _pagination = new(); + private readonly MongoOffsetPagination _pagination = new(); - public MongoDbOffsetPagingHandler(PagingOptions options) : base(options) - { - } + public MongoDbOffsetPagingHandler(PagingOptions options) : base(options) + { + } - protected override async ValueTask SliceAsync( - IResolverContext context, - object source, - OffsetPagingArguments arguments) - => await _pagination.ApplyPaginationAsync( - CreatePagingContainer(source), - arguments, - context.RequestAborted) - .ConfigureAwait(false); + protected override async ValueTask SliceAsync( + IResolverContext context, + object source, + OffsetPagingArguments arguments) + => await _pagination.ApplyPaginationAsync( + CreatePagingContainer(source), + arguments, + context.RequestAborted) + .ConfigureAwait(false); - private IMongoPagingContainer CreatePagingContainer(object source) + private IMongoPagingContainer CreatePagingContainer(object source) + { + return source switch { - return source switch - { - IAggregateFluent e => AggregateFluentPagingContainer.New(e), - IFindFluent f => FindFluentPagingContainer.New(f), - IMongoCollection m => FindFluentPagingContainer.New( - m.Find(FilterDefinition.Empty)), - MongoDbCollectionExecutable mce => - CreatePagingContainer(mce.BuildPipeline()), - MongoDbAggregateFluentExecutable mae => - CreatePagingContainer(mae.BuildPipeline()), - MongoDbFindFluentExecutable mfe => - CreatePagingContainer(mfe.BuildPipeline()), - _ => throw ThrowHelper.PagingTypeNotSupported(source.GetType()) - }; - } + IAggregateFluent e => AggregateFluentPagingContainer.New(e), + IFindFluent f => FindFluentPagingContainer.New(f), + IMongoCollection m => FindFluentPagingContainer.New( + m.Find(FilterDefinition.Empty)), + MongoDbCollectionExecutable mce => + CreatePagingContainer(mce.BuildPipeline()), + MongoDbAggregateFluentExecutable mae => + CreatePagingContainer(mae.BuildPipeline()), + MongoDbFindFluentExecutable mfe => + CreatePagingContainer(mfe.BuildPipeline()), + _ => throw ThrowHelper.PagingTypeNotSupported(source.GetType()) + }; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbOffsetPagingProvider.cs b/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbOffsetPagingProvider.cs index 56baaa43821..8ccbeb22a8e 100644 --- a/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbOffsetPagingProvider.cs +++ b/src/HotChocolate/MongoDb/src/Data/Paging/MongoDbOffsetPagingProvider.cs @@ -4,44 +4,43 @@ using HotChocolate.Types.Pagination; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +/// +/// An offset paging provider for MongoDb that create pagination queries +/// +public class MongoDbOffsetPagingProvider : OffsetPagingProvider { - /// - /// An offset paging provider for MongoDb that create pagination queries - /// - public class MongoDbOffsetPagingProvider : OffsetPagingProvider + private static readonly MethodInfo _createHandler = + typeof(MongoDbOffsetPagingProvider).GetMethod( + nameof(CreateHandlerInternal), + BindingFlags.Static | BindingFlags.NonPublic)!; + + public override bool CanHandle(IExtendedType source) { - private static readonly MethodInfo _createHandler = - typeof(MongoDbOffsetPagingProvider).GetMethod( - nameof(CreateHandlerInternal), - BindingFlags.Static | BindingFlags.NonPublic)!; + return typeof(IMongoDbExecutable).IsAssignableFrom(source.Source) || + source.Source.IsGenericType && + source.Source.GetGenericTypeDefinition() is { } type && ( + type == typeof(IAggregateFluent<>) || + type == typeof(IFindFluent<,>) || + type == typeof(IMongoCollection<>)); + } - public override bool CanHandle(IExtendedType source) + protected override OffsetPagingHandler CreateHandler( + IExtendedType source, + PagingOptions options) + { + if (source is null) { - return typeof(IMongoDbExecutable).IsAssignableFrom(source.Source) || - source.Source.IsGenericType && - source.Source.GetGenericTypeDefinition() is { } type && ( - type == typeof(IAggregateFluent<>) || - type == typeof(IFindFluent<,>) || - type == typeof(IMongoCollection<>)); + throw new ArgumentNullException(nameof(source)); } - protected override OffsetPagingHandler CreateHandler( - IExtendedType source, - PagingOptions options) - { - if (source is null) - { - throw new ArgumentNullException(nameof(source)); - } - - return (OffsetPagingHandler)_createHandler - .MakeGenericMethod(source.ElementType?.Source ?? source.Source) - .Invoke(null, new object[] { options })!; - } + return (OffsetPagingHandler)_createHandler + .MakeGenericMethod(source.ElementType?.Source ?? source.Source) + .Invoke(null, new object[] { options })!; + } - private static MongoDbOffsetPagingHandler CreateHandlerInternal( - PagingOptions options) => new(options); + private static MongoDbOffsetPagingHandler CreateHandlerInternal( + PagingOptions options) => new(options); - } } diff --git a/src/HotChocolate/MongoDb/src/Data/Paging/MongoOffsetPagination.cs b/src/HotChocolate/MongoDb/src/Data/Paging/MongoOffsetPagination.cs index b5ad3856a5d..2c111aeea17 100644 --- a/src/HotChocolate/MongoDb/src/Data/Paging/MongoOffsetPagination.cs +++ b/src/HotChocolate/MongoDb/src/Data/Paging/MongoOffsetPagination.cs @@ -3,32 +3,31 @@ using System.Threading.Tasks; using HotChocolate.Types.Pagination; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +internal sealed class MongoOffsetPagination + : OffsetPaginationAlgorithm, TEntity> { - internal sealed class MongoOffsetPagination - : OffsetPaginationAlgorithm, TEntity> - { - protected override IMongoPagingContainer ApplySkip( - IMongoPagingContainer query, - int skip) - => query.Skip(skip); + protected override IMongoPagingContainer ApplySkip( + IMongoPagingContainer query, + int skip) + => query.Skip(skip); - protected override IMongoPagingContainer ApplyTake( - IMongoPagingContainer query, - int take) - => query.Take(take); + protected override IMongoPagingContainer ApplyTake( + IMongoPagingContainer query, + int take) + => query.Take(take); - protected override async ValueTask CountAsync( - IMongoPagingContainer query, - CancellationToken cancellationToken) - => await query.CountAsync(cancellationToken).ConfigureAwait(false); + protected override async ValueTask CountAsync( + IMongoPagingContainer query, + CancellationToken cancellationToken) + => await query.CountAsync(cancellationToken).ConfigureAwait(false); - protected override async ValueTask> ExecuteAsync( - IMongoPagingContainer query, - CancellationToken cancellationToken) - { - List result = await query.ToListAsync(cancellationToken); - return result; - } + protected override async ValueTask> ExecuteAsync( + IMongoPagingContainer query, + CancellationToken cancellationToken) + { + List result = await query.ToListAsync(cancellationToken); + return result; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoDbProjectionProviderDescriptorExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoDbProjectionProviderDescriptorExtensions.cs index 2d5e768d3b9..2d2c2fd8ae9 100644 --- a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoDbProjectionProviderDescriptorExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoDbProjectionProviderDescriptorExtensions.cs @@ -3,40 +3,39 @@ using HotChocolate.Data.Projections; using HotChocolate.Data.Projections.Handlers; -namespace HotChocolate.Data +namespace HotChocolate.Data; + +public static class MongoDbProjectionProviderDescriptorExtensions { - public static class MongoDbProjectionProviderDescriptorExtensions - { - /// - /// Initializes the default configuration for MongoDb on the convention by adding handlers - /// - /// The descriptor where the handlers are registered - /// The - public static IProjectionProviderDescriptor AddMongoDbDefaults( - this IProjectionProviderDescriptor descriptor) => - descriptor.RegisterMongoDbHandlers(); + /// + /// Initializes the default configuration for MongoDb on the convention by adding handlers + /// + /// The descriptor where the handlers are registered + /// The + public static IProjectionProviderDescriptor AddMongoDbDefaults( + this IProjectionProviderDescriptor descriptor) => + descriptor.RegisterMongoDbHandlers(); - /// - /// Registers projection handlers for mongodb - /// - /// The descriptor where the handlers are registered - /// The - /// - /// Throws in case the argument is null - /// - public static IProjectionProviderDescriptor RegisterMongoDbHandlers( - this IProjectionProviderDescriptor descriptor) + /// + /// Registers projection handlers for mongodb + /// + /// The descriptor where the handlers are registered + /// The + /// + /// Throws in case the argument is null + /// + public static IProjectionProviderDescriptor RegisterMongoDbHandlers( + this IProjectionProviderDescriptor descriptor) + { + if (descriptor is null) { - if (descriptor is null) - { - throw new ArgumentNullException(nameof(descriptor)); - } - - descriptor.RegisterFieldHandler(); - descriptor.RegisterFieldHandler(); - descriptor.RegisterOptimizer(); - descriptor.RegisterOptimizer(); - return descriptor; + throw new ArgumentNullException(nameof(descriptor)); } + + descriptor.RegisterFieldHandler(); + descriptor.RegisterFieldHandler(); + descriptor.RegisterOptimizer(); + descriptor.RegisterOptimizer(); + return descriptor; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoProjectionConventionDescriptorExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoProjectionConventionDescriptorExtensions.cs index b2d3374e190..fca803da441 100644 --- a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoProjectionConventionDescriptorExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoProjectionConventionDescriptorExtensions.cs @@ -1,17 +1,16 @@ using HotChocolate.Data.MongoDb; using HotChocolate.Data.Projections; -namespace HotChocolate.Data +namespace HotChocolate.Data; + +public static class MongoDbProjectionConventionDescriptorExtensions { - public static class MongoDbProjectionConventionDescriptorExtensions - { - /// - /// Initializes the default configuration for MongoDb - /// - /// The descriptor where the handlers are registered - /// The - public static IProjectionConventionDescriptor AddMongoDbDefaults( - this IProjectionConventionDescriptor descriptor) => - descriptor.Provider(new MongoDbProjectionProvider(x => x.AddMongoDbDefaults())); - } + /// + /// Initializes the default configuration for MongoDb + /// + /// The descriptor where the handlers are registered + /// The + public static IProjectionConventionDescriptor AddMongoDbDefaults( + this IProjectionConventionDescriptor descriptor) => + descriptor.Provider(new MongoDbProjectionProvider(x => x.AddMongoDbDefaults())); } diff --git a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoProjectionVisitorContextExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoProjectionVisitorContextExtensions.cs index f8436531aae..0ccd0f39650 100644 --- a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoProjectionVisitorContextExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Extensions/MongoProjectionVisitorContextExtensions.cs @@ -2,26 +2,25 @@ using System.Linq; using HotChocolate.Data.MongoDb; -namespace HotChocolate.Data.Sorting +namespace HotChocolate.Data.Sorting; + +internal static class MongoProjectionVisitorContextExtensions { - internal static class MongoProjectionVisitorContextExtensions + public static string GetPath(this MongoDbProjectionVisitorContext ctx) => + string.Join(".", ctx.Path.Reverse()); + + public static bool TryCreateQuery( + this MongoDbProjectionVisitorContext context, + [NotNullWhen(true)] out MongoDbProjectionDefinition? query) { - public static string GetPath(this MongoDbProjectionVisitorContext ctx) => - string.Join(".", ctx.Path.Reverse()); + query = null; - public static bool TryCreateQuery( - this MongoDbProjectionVisitorContext context, - [NotNullWhen(true)] out MongoDbProjectionDefinition? query) + if (context.Projections.Count == 0) { - query = null; - - if (context.Projections.Count == 0) - { - return false; - } - - query = new MongoDbCombinedProjectionDefinition(context.Projections.ToArray()); - return true; + return false; } + + query = new MongoDbCombinedProjectionDefinition(context.Projections.ToArray()); + return true; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionFieldHandler.cs b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionFieldHandler.cs index 4b6c5f39ac1..74c3ae75404 100644 --- a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionFieldHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionFieldHandler.cs @@ -3,38 +3,37 @@ using HotChocolate.Execution.Processing; using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Projections +namespace HotChocolate.Data.MongoDb.Projections; + +/// +public class MongoDbProjectionFieldHandler + : MongoDbProjectionHandlerBase { /// - public class MongoDbProjectionFieldHandler - : MongoDbProjectionHandlerBase - { - /// - public override bool CanHandle(ISelection selection) => - selection.SelectionSet is not null; + public override bool CanHandle(ISelection selection) => + selection.SelectionSet is not null; - /// - public override bool TryHandleEnter( - MongoDbProjectionVisitorContext context, - ISelection selection, - [NotNullWhen(true)] out ISelectionVisitorAction? action) - { - IObjectField field = selection.Field; - context.Path.Push(field.GetName()); - action = SelectionVisitor.Continue; - return true; - } + /// + public override bool TryHandleEnter( + MongoDbProjectionVisitorContext context, + ISelection selection, + [NotNullWhen(true)] out ISelectionVisitorAction? action) + { + IObjectField field = selection.Field; + context.Path.Push(field.GetName()); + action = SelectionVisitor.Continue; + return true; + } - /// - public override bool TryHandleLeave( - MongoDbProjectionVisitorContext context, - ISelection selection, - [NotNullWhen(true)] out ISelectionVisitorAction? action) - { - context.Path.Pop(); + /// + public override bool TryHandleLeave( + MongoDbProjectionVisitorContext context, + ISelection selection, + [NotNullWhen(true)] out ISelectionVisitorAction? action) + { + context.Path.Pop(); - action = SelectionVisitor.Continue; - return true; - } + action = SelectionVisitor.Continue; + return true; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionHandlerBase.cs b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionHandlerBase.cs index cda52cb6779..b9baa931b05 100644 --- a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionHandlerBase.cs +++ b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionHandlerBase.cs @@ -3,33 +3,32 @@ using HotChocolate.Data.Projections.Expressions.Handlers; using HotChocolate.Execution.Processing; -namespace HotChocolate.Data.MongoDb.Projections +namespace HotChocolate.Data.MongoDb.Projections; + +/// +/// A handler that can intersect a and optimize the selection set for +/// mongodb projections. +/// +public abstract class MongoDbProjectionHandlerBase + : ProjectionFieldHandler { - /// - /// A handler that can intersect a and optimize the selection set for - /// mongodb projections. - /// - public abstract class MongoDbProjectionHandlerBase - : ProjectionFieldHandler + /// + public override bool TryHandleEnter( + MongoDbProjectionVisitorContext context, + ISelection selection, + [NotNullWhen(true)] out ISelectionVisitorAction? action) { - /// - public override bool TryHandleEnter( - MongoDbProjectionVisitorContext context, - ISelection selection, - [NotNullWhen(true)] out ISelectionVisitorAction? action) - { - action = SelectionVisitor.Continue; - return true; - } + action = SelectionVisitor.Continue; + return true; + } - /// - public override bool TryHandleLeave( - MongoDbProjectionVisitorContext context, - ISelection selection, - [NotNullWhen(true)] out ISelectionVisitorAction? action) - { - action = SelectionVisitor.Continue; - return true; - } + /// + public override bool TryHandleLeave( + MongoDbProjectionVisitorContext context, + ISelection selection, + [NotNullWhen(true)] out ISelectionVisitorAction? action) + { + action = SelectionVisitor.Continue; + return true; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionScalarHandler.cs b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionScalarHandler.cs index cee02733e4a..36b5cf2e3c6 100644 --- a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionScalarHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/Handlers/MongoDbProjectionScalarHandler.cs @@ -4,30 +4,29 @@ using HotChocolate.Execution.Processing; using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb.Projections +namespace HotChocolate.Data.MongoDb.Projections; + +/// +public class MongoDbProjectionScalarHandler + : MongoDbProjectionHandlerBase { /// - public class MongoDbProjectionScalarHandler - : MongoDbProjectionHandlerBase - { - /// - public override bool CanHandle(ISelection selection) => - selection.SelectionSet is null; + public override bool CanHandle(ISelection selection) => + selection.SelectionSet is null; - /// - public override bool TryHandleEnter( - MongoDbProjectionVisitorContext context, - ISelection selection, - [NotNullWhen(true)]out ISelectionVisitorAction? action) - { - IObjectField field = selection.Field; - context.Path.Push(field.GetName()); - context.Projections.Push( - new MongoDbIncludeProjectionOperation(context.GetPath())); - context.Path.Pop(); + /// + public override bool TryHandleEnter( + MongoDbProjectionVisitorContext context, + ISelection selection, + [NotNullWhen(true)] out ISelectionVisitorAction? action) + { + IObjectField field = selection.Field; + context.Path.Push(field.GetName()); + context.Projections.Push( + new MongoDbIncludeProjectionOperation(context.GetPath())); + context.Path.Pop(); - action = SelectionVisitor.SkipAndLeave; - return true; - } + action = SelectionVisitor.SkipAndLeave; + return true; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionProvider.cs b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionProvider.cs index 95cda8bf450..bc61f809330 100644 --- a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionProvider.cs +++ b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionProvider.cs @@ -5,67 +5,66 @@ using HotChocolate.Resolvers; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +public class MongoDbProjectionProvider + : ProjectionProvider { /// - public class MongoDbProjectionProvider - : ProjectionProvider + public MongoDbProjectionProvider() { - /// - public MongoDbProjectionProvider() - { - } + } - /// - public MongoDbProjectionProvider( - Action configure) - : base(configure) - { - } + /// + public MongoDbProjectionProvider( + Action configure) + : base(configure) + { + } - /// - public override FieldMiddleware CreateExecutor() + /// + public override FieldMiddleware CreateExecutor() + { + return next => context => ExecuteAsync(next, context); + + async ValueTask ExecuteAsync( + FieldDelegate next, + IMiddlewareContext context) { - return next => context => ExecuteAsync(next, context); + // first we let the pipeline run and produce a result. + await next(context).ConfigureAwait(false); - async ValueTask ExecuteAsync( - FieldDelegate next, - IMiddlewareContext context) + if (context.Result is not null) { - // first we let the pipeline run and produce a result. - await next(context).ConfigureAwait(false); + var visitorContext = + new MongoDbProjectionVisitorContext(context, context.ObjectType); - if (context.Result is not null) - { - var visitorContext = - new MongoDbProjectionVisitorContext(context, context.ObjectType); + var visitor = new ProjectionVisitor(); + visitor.Visit(visitorContext); - var visitor = new ProjectionVisitor(); - visitor.Visit(visitorContext); - - if (!visitorContext.TryCreateQuery( - out MongoDbProjectionDefinition? projections) || - visitorContext.Errors.Count > 0) + if (!visitorContext.TryCreateQuery( + out MongoDbProjectionDefinition? projections) || + visitorContext.Errors.Count > 0) + { + context.Result = Array.Empty(); + foreach (IError error in visitorContext.Errors) { - context.Result = Array.Empty(); - foreach (IError error in visitorContext.Errors) - { - context.ReportError(error.WithPath(context.Path)); - } + context.ReportError(error.WithPath(context.Path)); } - else - { - context.LocalContextData = - context.LocalContextData.SetItem( - nameof(ProjectionDefinition), - projections); + } + else + { + context.LocalContextData = + context.LocalContextData.SetItem( + nameof(ProjectionDefinition), + projections); - await next(context).ConfigureAwait(false); + await next(context).ConfigureAwait(false); - if (context.Result is IMongoDbExecutable executable) - { - context.Result = executable.WithProjection(projections); - } + if (context.Result is IMongoDbExecutable executable) + { + context.Result = executable.WithProjection(projections); } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionScope.cs b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionScope.cs index 95ea1cc1fd1..26c6ce3b76a 100644 --- a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionScope.cs +++ b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionScope.cs @@ -1,10 +1,9 @@ using HotChocolate.Data.Projections; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +public class MongoDbProjectionScope + : ProjectionScope { - /// - public class MongoDbProjectionScope - : ProjectionScope - { - } } diff --git a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionVisitorContext.cs b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionVisitorContext.cs index 5fba5a1a7cd..4a1f8a0c4c6 100644 --- a/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionVisitorContext.cs +++ b/src/HotChocolate/MongoDb/src/Data/Projections/Convention/MongoDbProjectionVisitorContext.cs @@ -3,28 +3,27 @@ using HotChocolate.Resolvers; using HotChocolate.Types; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +/// +public class MongoDbProjectionVisitorContext + : ProjectionVisitorContext { /// - public class MongoDbProjectionVisitorContext - : ProjectionVisitorContext + public MongoDbProjectionVisitorContext( + IResolverContext context, + IOutputType initialType) + : base(context, initialType, new MongoDbProjectionScope()) { - /// - public MongoDbProjectionVisitorContext( - IResolverContext context, - IOutputType initialType) - : base(context, initialType, new MongoDbProjectionScope()) - { - } + } - /// - /// The path from the root to the current position in the input object - /// - public Stack Path { get; } = new(); + /// + /// The path from the root to the current position in the input object + /// + public Stack Path { get; } = new(); - /// - /// A list of already projected fields - /// - public Stack Projections { get; } = new(); - } + /// + /// A list of already projected fields + /// + public Stack Projections { get; } = new(); } diff --git a/src/HotChocolate/MongoDb/src/Data/Sorting/Convention/Extensions/MongoSortingConventionDescriptorExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Sorting/Convention/Extensions/MongoSortingConventionDescriptorExtensions.cs index d5b9c61fb6b..d5a48fcb29e 100644 --- a/src/HotChocolate/MongoDb/src/Data/Sorting/Convention/Extensions/MongoSortingConventionDescriptorExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Sorting/Convention/Extensions/MongoSortingConventionDescriptorExtensions.cs @@ -1,62 +1,61 @@ using System; using HotChocolate.Data.Sorting; -namespace HotChocolate.Data +namespace HotChocolate.Data; + +public static class MongoSortingConventionDescriptorExtensions { - public static class MongoSortingConventionDescriptorExtensions + /// + /// Initializes the default configuration for MongoDb on the convention by adding operations + /// + /// The descriptor where the handlers are registered + /// The + public static ISortConventionDescriptor AddMongoDbDefaults( + this ISortConventionDescriptor descriptor) => + descriptor.AddDefaultMongoDbOperations().BindDefaultMongoDbTypes().UseMongoDbProvider(); + + /// + /// Adds default operations for MongoDb to the descriptor + /// + /// The descriptor where the handlers are registered + /// The + /// + /// Throws in case the argument is null + /// + public static ISortConventionDescriptor AddDefaultMongoDbOperations( + this ISortConventionDescriptor descriptor) { - /// - /// Initializes the default configuration for MongoDb on the convention by adding operations - /// - /// The descriptor where the handlers are registered - /// The - public static ISortConventionDescriptor AddMongoDbDefaults( - this ISortConventionDescriptor descriptor) => - descriptor.AddDefaultMongoDbOperations().BindDefaultMongoDbTypes().UseMongoDbProvider(); - - /// - /// Adds default operations for MongoDb to the descriptor - /// - /// The descriptor where the handlers are registered - /// The - /// - /// Throws in case the argument is null - /// - public static ISortConventionDescriptor AddDefaultMongoDbOperations( - this ISortConventionDescriptor descriptor) + if (descriptor is null) { - if (descriptor is null) - { - throw new ArgumentNullException(nameof(descriptor)); - } + throw new ArgumentNullException(nameof(descriptor)); + } - descriptor.Operation(DefaultSortOperations.Ascending).Name("ASC"); - descriptor.Operation(DefaultSortOperations.Descending).Name("DESC"); + descriptor.Operation(DefaultSortOperations.Ascending).Name("ASC"); + descriptor.Operation(DefaultSortOperations.Descending).Name("DESC"); - return descriptor; - } + return descriptor; + } - /// - /// Binds common runtime types to the according that are - /// supported by MongoDb - /// - /// The descriptor where the handlers are registered - /// The descriptor that was passed in as a parameter - /// - /// Throws in case the argument is null - /// - public static ISortConventionDescriptor BindDefaultMongoDbTypes( - this ISortConventionDescriptor descriptor) + /// + /// Binds common runtime types to the according that are + /// supported by MongoDb + /// + /// The descriptor where the handlers are registered + /// The descriptor that was passed in as a parameter + /// + /// Throws in case the argument is null + /// + public static ISortConventionDescriptor BindDefaultMongoDbTypes( + this ISortConventionDescriptor descriptor) + { + if (descriptor is null) { - if (descriptor is null) - { - throw new ArgumentNullException(nameof(descriptor)); - } + throw new ArgumentNullException(nameof(descriptor)); + } - descriptor.BindRuntimeType(); - descriptor.DefaultBinding(); + descriptor.BindRuntimeType(); + descriptor.DefaultBinding(); - return descriptor; - } + return descriptor; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Sorting/Convention/Extensions/SortConventionDescriptorMongoExtensions.cs b/src/HotChocolate/MongoDb/src/Data/Sorting/Convention/Extensions/SortConventionDescriptorMongoExtensions.cs index 2ed60047368..3522999b75b 100644 --- a/src/HotChocolate/MongoDb/src/Data/Sorting/Convention/Extensions/SortConventionDescriptorMongoExtensions.cs +++ b/src/HotChocolate/MongoDb/src/Data/Sorting/Convention/Extensions/SortConventionDescriptorMongoExtensions.cs @@ -1,31 +1,30 @@ using HotChocolate.Data.MongoDb.Sorting; using HotChocolate.Data.Sorting; -namespace HotChocolate.Data +namespace HotChocolate.Data; + +public static class SortConventionDescriptorMongoExtensions { - public static class SortConventionDescriptorMongoExtensions - { - /// - /// Adds a with default configuration - /// - /// The descriptor where the provider is registered - /// The that was passed in as a parameter - public static ISortConventionDescriptor UseMongoDbProvider( - this ISortConventionDescriptor descriptor) => - descriptor.Provider(new MongoDbSortProvider(x => x.AddDefaultFieldHandlers())); + /// + /// Adds a with default configuration + /// + /// The descriptor where the provider is registered + /// The that was passed in as a parameter + public static ISortConventionDescriptor UseMongoDbProvider( + this ISortConventionDescriptor descriptor) => + descriptor.Provider(new MongoDbSortProvider(x => x.AddDefaultFieldHandlers())); - /// - /// Initializes the default configuration of the provider by registering handlers - /// - /// The descriptor where the handlers are registered - /// The that was passed in as a parameter - public static ISortProviderDescriptor AddDefaultFieldHandlers( - this ISortProviderDescriptor descriptor) - { - descriptor.AddOperationHandler(); - descriptor.AddOperationHandler(); - descriptor.AddFieldHandler(); - return descriptor; - } + /// + /// Initializes the default configuration of the provider by registering handlers + /// + /// The descriptor where the handlers are registered + /// The that was passed in as a parameter + public static ISortProviderDescriptor AddDefaultFieldHandlers( + this ISortProviderDescriptor descriptor) + { + descriptor.AddOperationHandler(); + descriptor.AddOperationHandler(); + descriptor.AddFieldHandler(); + return descriptor; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbAscendingSortOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbAscendingSortOperationHandler.cs index af6832f9dcb..f3a8e829097 100644 --- a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbAscendingSortOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbAscendingSortOperationHandler.cs @@ -1,13 +1,12 @@ using HotChocolate.Data.Sorting; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbAscendingSortOperationHandler : MongoDbSortOperationHandlerBase { - public class MongoDbAscendingSortOperationHandler : MongoDbSortOperationHandlerBase + public MongoDbAscendingSortOperationHandler() + : base(DefaultSortOperations.Ascending, SortDirection.Ascending) { - public MongoDbAscendingSortOperationHandler() - : base(DefaultSortOperations.Ascending, SortDirection.Ascending) - { - } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbDefaultSortFieldHandler.cs b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbDefaultSortFieldHandler.cs index 5b8e12840de..50fb43933d9 100644 --- a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbDefaultSortFieldHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbDefaultSortFieldHandler.cs @@ -4,50 +4,49 @@ using HotChocolate.Language; using HotChocolate.Language.Visitors; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbDefaultSortFieldHandler + : SortFieldHandler { - public class MongoDbDefaultSortFieldHandler - : SortFieldHandler - { - /// - public override bool CanHandle( - ITypeCompletionContext context, - ISortInputTypeDefinition typeDefinition, - ISortFieldDefinition fieldDefinition) => - fieldDefinition.Member is not null; + /// + public override bool CanHandle( + ITypeCompletionContext context, + ISortInputTypeDefinition typeDefinition, + ISortFieldDefinition fieldDefinition) => + fieldDefinition.Member is not null; - /// - public override bool TryHandleEnter( - MongoDbSortVisitorContext context, - ISortField field, - ObjectFieldNode node, - [NotNullWhen(true)] out ISyntaxVisitorAction? action) + /// + public override bool TryHandleEnter( + MongoDbSortVisitorContext context, + ISortField field, + ObjectFieldNode node, + [NotNullWhen(true)] out ISyntaxVisitorAction? action) + { + if (node.Value.IsNull()) { - if (node.Value.IsNull()) - { - context.ReportError( - ErrorHelper.CreateNonNullError(field, node.Value, context)); + context.ReportError( + ErrorHelper.CreateNonNullError(field, node.Value, context)); - action = SyntaxVisitor.Skip; - return true; - } - - context.Path.Push(field.GetName()); - action = SyntaxVisitor.Continue; + action = SyntaxVisitor.Skip; return true; } - /// - public override bool TryHandleLeave( - MongoDbSortVisitorContext context, - ISortField field, - ObjectFieldNode node, - [NotNullWhen(true)] out ISyntaxVisitorAction? action) - { - context.Path.Pop(); + context.Path.Push(field.GetName()); + action = SyntaxVisitor.Continue; + return true; + } - action = SyntaxVisitor.Continue; - return true; - } + /// + public override bool TryHandleLeave( + MongoDbSortVisitorContext context, + ISortField field, + ObjectFieldNode node, + [NotNullWhen(true)] out ISyntaxVisitorAction? action) + { + context.Path.Pop(); + + action = SyntaxVisitor.Continue; + return true; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbDescendingSortOperationHandler.cs b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbDescendingSortOperationHandler.cs index 457475d42ff..544110befb3 100644 --- a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbDescendingSortOperationHandler.cs +++ b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbDescendingSortOperationHandler.cs @@ -1,13 +1,12 @@ using HotChocolate.Data.Sorting; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbDescendingSortOperationHandler : MongoDbSortOperationHandlerBase { - public class MongoDbDescendingSortOperationHandler : MongoDbSortOperationHandlerBase + public MongoDbDescendingSortOperationHandler() + : base(DefaultSortOperations.Descending, SortDirection.Descending) { - public MongoDbDescendingSortOperationHandler() - : base(DefaultSortOperations.Descending, SortDirection.Descending) - { - } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortOperationHandlerBase.cs b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortOperationHandlerBase.cs index 7c93e240610..0f38d5fc97f 100644 --- a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortOperationHandlerBase.cs +++ b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortOperationHandlerBase.cs @@ -6,57 +6,56 @@ using HotChocolate.Types.Descriptors.Definitions; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +/// +/// Represents a mongodb handler that can be bound to a . The handler is +/// executed during the visitation of a input object. +/// +public abstract class MongoDbSortOperationHandlerBase + : SortOperationHandler { - /// - /// Represents a mongodb handler that can be bound to a . The handler is - /// executed during the visitation of a input object. - /// - public abstract class MongoDbSortOperationHandlerBase - : SortOperationHandler - { - private readonly SortDirection _sortDirection; - private readonly int _operation; + private readonly SortDirection _sortDirection; + private readonly int _operation; - protected MongoDbSortOperationHandlerBase( - int operation, - SortDirection sortDirection) - { - _sortDirection = sortDirection; - _operation = operation; - } + protected MongoDbSortOperationHandlerBase( + int operation, + SortDirection sortDirection) + { + _sortDirection = sortDirection; + _operation = operation; + } - /// - public override bool CanHandle( - ITypeCompletionContext context, - EnumTypeDefinition typeDefinition, - SortEnumValueDefinition valueDefinition) - { - return valueDefinition.Operation == _operation; - } + /// + public override bool CanHandle( + ITypeCompletionContext context, + EnumTypeDefinition typeDefinition, + SortEnumValueDefinition valueDefinition) + { + return valueDefinition.Operation == _operation; + } - /// - public override bool TryHandleEnter( - MongoDbSortVisitorContext context, - ISortField field, - ISortEnumValue? sortValue, - EnumValueNode node, - [NotNullWhen(true)] out ISyntaxVisitorAction? action) + /// + public override bool TryHandleEnter( + MongoDbSortVisitorContext context, + ISortField field, + ISortEnumValue? sortValue, + EnumValueNode node, + [NotNullWhen(true)] out ISyntaxVisitorAction? action) + { + if (sortValue is null) { - if (sortValue is null) - { - context.ReportError( - ErrorHelper.CreateNonNullError(field, node, context)); + context.ReportError( + ErrorHelper.CreateNonNullError(field, node, context)); - action = null!; - return false; - } + action = null!; + return false; + } - context.Operations.Enqueue( - new MongoDbDirectionalSortOperation(context.GetPath(), _sortDirection)); + context.Operations.Enqueue( + new MongoDbDirectionalSortOperation(context.GetPath(), _sortDirection)); - action = SyntaxVisitor.Continue; - return true; - } + action = SyntaxVisitor.Continue; + return true; } } diff --git a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortProvider.cs b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortProvider.cs index a23a053fb89..ef0a66336a1 100644 --- a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortProvider.cs +++ b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortProvider.cs @@ -6,80 +6,80 @@ using HotChocolate.Types; using MongoDB.Driver; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +/// +public class MongoDbSortProvider + : SortProvider { - /// - public class MongoDbSortProvider - : SortProvider + /// + public MongoDbSortProvider() { - /// - public MongoDbSortProvider() - { - } + } - /// - public MongoDbSortProvider( - Action> configure) - : base(configure) - { - } + /// + public MongoDbSortProvider( + Action> configure) + : base(configure) + { + } + + /// + /// The visitor thar will traverse a incoming query and execute the sorting handlers + /// + protected virtual SortVisitor + Visitor + { get; } = new(); - /// - /// The visitor thar will traverse a incoming query and execute the sorting handlers - /// - protected virtual SortVisitor - Visitor { get; } = new(); + /// + public override FieldMiddleware CreateExecutor(NameString argumentName) + { + return next => context => ExecuteAsync(next, context); - /// - public override FieldMiddleware CreateExecutor(NameString argumentName) + async ValueTask ExecuteAsync( + FieldDelegate next, + IMiddlewareContext context) { - return next => context => ExecuteAsync(next, context); + IInputField argument = context.Selection.Field.Arguments[argumentName]; + IValueNode filter = context.ArgumentLiteral(argumentName); - async ValueTask ExecuteAsync( - FieldDelegate next, - IMiddlewareContext context) + if (filter is not NullValueNode && + argument.Type is ListType listType && + listType.ElementType is NonNullType nn && + nn.NamedType() is SortInputType sortInputType) { - IInputField argument = context.Selection.Field.Arguments[argumentName]; - IValueNode filter = context.ArgumentLiteral(argumentName); + var visitorContext = new MongoDbSortVisitorContext(sortInputType); - if (filter is not NullValueNode && - argument.Type is ListType listType && - listType.ElementType is NonNullType nn && - nn.NamedType() is SortInputType sortInputType) - { - var visitorContext = new MongoDbSortVisitorContext(sortInputType); + Visitor.Visit(filter, visitorContext); - Visitor.Visit(filter, visitorContext); - - if (!visitorContext.TryCreateQuery(out MongoDbSortDefinition? order) || - visitorContext.Errors.Count > 0) - { - context.Result = Array.Empty(); - foreach (IError error in visitorContext.Errors) - { - context.ReportError(error.WithPath(context.Path)); - } - } - else + if (!visitorContext.TryCreateQuery(out MongoDbSortDefinition? order) || + visitorContext.Errors.Count > 0) + { + context.Result = Array.Empty(); + foreach (IError error in visitorContext.Errors) { - context.LocalContextData = - context.LocalContextData.SetItem( - nameof(SortDefinition), - order); - - await next(context).ConfigureAwait(false); - - if (context.Result is IMongoDbExecutable executable) - { - context.Result = executable.WithSorting(order); - } + context.ReportError(error.WithPath(context.Path)); } } else { + context.LocalContextData = + context.LocalContextData.SetItem( + nameof(SortDefinition), + order); + await next(context).ConfigureAwait(false); + + if (context.Result is IMongoDbExecutable executable) + { + context.Result = executable.WithSorting(order); + } } } + else + { + await next(context).ConfigureAwait(false); + } } } } diff --git a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortVisitorContext.cs b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortVisitorContext.cs index 6aee4febff6..3cd20059872 100644 --- a/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortVisitorContext.cs +++ b/src/HotChocolate/MongoDb/src/Data/Sorting/Handlers/MongoDbSortVisitorContext.cs @@ -1,18 +1,17 @@ using System.Collections.Generic; using HotChocolate.Data.Sorting; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbSortVisitorContext : SortVisitorContext { - public class MongoDbSortVisitorContext : SortVisitorContext + public MongoDbSortVisitorContext(ISortInputType initialType) + : base(initialType) { - public MongoDbSortVisitorContext(ISortInputType initialType) - : base(initialType) - { - } - - /// - /// The path from the root to the current position in the input object - /// - public Stack Path { get; } = new Stack(); } + + /// + /// The path from the root to the current position in the input object + /// + public Stack Path { get; } = new Stack(); } diff --git a/src/HotChocolate/MongoDb/src/Data/ThrowHelper.cs b/src/HotChocolate/MongoDb/src/Data/ThrowHelper.cs index 3881644cc6f..1aece437b13 100644 --- a/src/HotChocolate/MongoDb/src/Data/ThrowHelper.cs +++ b/src/HotChocolate/MongoDb/src/Data/ThrowHelper.cs @@ -3,35 +3,34 @@ using HotChocolate.Data.Filters; using HotChocolate.Data.MongoDb.Filters; -namespace HotChocolate.Data.MongoDb +namespace HotChocolate.Data.MongoDb; + +internal static class ThrowHelper { - internal static class ThrowHelper + public static GraphQLException PagingTypeNotSupported(Type type) { - public static GraphQLException PagingTypeNotSupported(Type type) - { - return new GraphQLException( - ErrorBuilder.New() - .SetMessage( - MongoDbResources.Paging_SourceIsNotSupported, - type.FullName ?? type.Name) - .SetCode(ErrorCodes.Data.NoPaginationProviderFound) - .Build()); - } + return new GraphQLException( + ErrorBuilder.New() + .SetMessage( + MongoDbResources.Paging_SourceIsNotSupported, + type.FullName ?? type.Name) + .SetCode(ErrorCodes.Data.NoPaginationProviderFound) + .Build()); + } - public static InvalidOperationException Filtering_MongoDbCombinator_QueueEmpty( - MongoDbFilterCombinator combinator) => - new(string.Format( - CultureInfo.CurrentCulture, - MongoDbResources.Filtering_MongoDbCombinator_QueueEmpty, - combinator.GetType())); + public static InvalidOperationException Filtering_MongoDbCombinator_QueueEmpty( + MongoDbFilterCombinator combinator) => + new(string.Format( + CultureInfo.CurrentCulture, + MongoDbResources.Filtering_MongoDbCombinator_QueueEmpty, + combinator.GetType())); - public static InvalidOperationException Filtering_MongoDbCombinator_InvalidCombinator( - MongoDbFilterCombinator combinator, - FilterCombinator operation) => - new(string.Format( - CultureInfo.CurrentCulture, - MongoDbResources.Filtering_MongoDbCombinator_InvalidCombinator, - combinator.GetType(), - operation.ToString())); - } + public static InvalidOperationException Filtering_MongoDbCombinator_InvalidCombinator( + MongoDbFilterCombinator combinator, + FilterCombinator operation) => + new(string.Format( + CultureInfo.CurrentCulture, + MongoDbResources.Filtering_MongoDbCombinator_InvalidCombinator, + combinator.GetType(), + operation.ToString())); } diff --git a/src/HotChocolate/MongoDb/src/Types/BsonType.cs b/src/HotChocolate/MongoDb/src/Types/BsonType.cs index 85e0cd67b12..48ce3a69e2f 100644 --- a/src/HotChocolate/MongoDb/src/Types/BsonType.cs +++ b/src/HotChocolate/MongoDb/src/Types/BsonType.cs @@ -347,42 +347,42 @@ public override bool TryDeserialize(object? resultValue, out object? runtimeValu switch (resultValue) { case IDictionary dictionary: - { - var result = new BsonDocument(); - foreach (KeyValuePair element in dictionary) { - if (TryDeserialize(element.Value, out elementValue)) + var result = new BsonDocument(); + foreach (KeyValuePair element in dictionary) { - result[element.Key] = (BsonValue?)elementValue; + if (TryDeserialize(element.Value, out elementValue)) + { + result[element.Key] = (BsonValue?)elementValue; + } + else + { + return false; + } } - else - { - return false; - } - } - runtimeValue = result; - return true; - } + runtimeValue = result; + return true; + } case IList list: - { - var result = new BsonValue?[list.Count]; - for (var i = 0; i < list.Count; i++) { - if (TryDeserialize(list[i], out elementValue)) + var result = new BsonValue?[list.Count]; + for (var i = 0; i < list.Count; i++) { - result[i] = (BsonValue?)elementValue; + if (TryDeserialize(list[i], out elementValue)) + { + result[i] = (BsonValue?)elementValue; + } + else + { + return false; + } } - else - { - return false; - } - } - runtimeValue = new BsonArray(result); - return true; - } + runtimeValue = new BsonArray(result); + return true; + } case IValueNode literal: runtimeValue = ParseLiteral(literal); diff --git a/src/HotChocolate/MongoDb/src/Types/MongoDbScalarNames.cs b/src/HotChocolate/MongoDb/src/Types/MongoDbScalarNames.cs index 7612f11c70c..56491818bee 100644 --- a/src/HotChocolate/MongoDb/src/Types/MongoDbScalarNames.cs +++ b/src/HotChocolate/MongoDb/src/Types/MongoDbScalarNames.cs @@ -1,21 +1,20 @@ -namespace HotChocolate.Types.MongoDb +namespace HotChocolate.Types.MongoDb; + +/// +/// This class holds the MongoDB specific scalar type names. +/// sequences. +/// +public static class MongoDbScalarNames { /// - /// This class holds the MongoDB specific scalar type names. + /// The name of the ObjectId scalar type. /// sequences. /// - public static class MongoDbScalarNames - { - /// - /// The name of the ObjectId scalar type. - /// sequences. - /// - public static readonly string ObjectId = nameof(ObjectId); + public static readonly string ObjectId = nameof(ObjectId); - /// - /// The name of the Bson scalar type. - /// sequences. - /// - public static readonly string Bson = nameof(Bson); - } + /// + /// The name of the Bson scalar type. + /// sequences. + /// + public static readonly string Bson = nameof(Bson); } diff --git a/src/HotChocolate/MongoDb/src/Types/ObjectIdType.cs b/src/HotChocolate/MongoDb/src/Types/ObjectIdType.cs index 3ce82b53d04..e4315c47ebe 100644 --- a/src/HotChocolate/MongoDb/src/Types/ObjectIdType.cs +++ b/src/HotChocolate/MongoDb/src/Types/ObjectIdType.cs @@ -3,49 +3,48 @@ using HotChocolate.Types.MongoDb.Resources; using MongoDB.Bson; -namespace HotChocolate.Types.MongoDb +namespace HotChocolate.Types.MongoDb; + +/// +/// The ObjectId scalar type represents a 12 byte ObjectId, represented as UTF-8 character +/// sequences. +/// +public class ObjectIdType + : ScalarType { /// - /// The ObjectId scalar type represents a 12 byte ObjectId, represented as UTF-8 character - /// sequences. + /// Initializes a new instance of the class. /// - public class ObjectIdType - : ScalarType + public ObjectIdType() + : this( + MongoDbScalarNames.ObjectId, + MongoDbTypesResources.ObjectId_Type_Description, + BindingBehavior.Implicit) { - /// - /// Initializes a new instance of the class. - /// - public ObjectIdType() - : this( - MongoDbScalarNames.ObjectId, - MongoDbTypesResources.ObjectId_Type_Description, - BindingBehavior.Implicit) - { - } + } - /// - /// Initializes a new instance of the class. - /// - public ObjectIdType( - NameString name, - string? description = null, - BindingBehavior bind = BindingBehavior.Explicit) - : base(name, bind) - { - SpecifiedBy = new Uri("https://docs.mongodb.com/manual/reference/bson-types/#objectid"); - Description = description; - } + /// + /// Initializes a new instance of the class. + /// + public ObjectIdType( + NameString name, + string? description = null, + BindingBehavior bind = BindingBehavior.Explicit) + : base(name, bind) + { + SpecifiedBy = new Uri("https://docs.mongodb.com/manual/reference/bson-types/#objectid"); + Description = description; + } - /// - protected override ObjectId ParseLiteral(StringValueNode valueSyntax) => - new(valueSyntax.Value); + /// + protected override ObjectId ParseLiteral(StringValueNode valueSyntax) => + new(valueSyntax.Value); - /// - protected override StringValueNode ParseValue(ObjectId runtimeValue) => - new(runtimeValue.ToString()); + /// + protected override StringValueNode ParseValue(ObjectId runtimeValue) => + new(runtimeValue.ToString()); - /// - public override IValueNode ParseResult(object? resultValue) => - ParseValue(resultValue); - } + /// + public override IValueNode ParseResult(object? resultValue) => + ParseValue(resultValue); } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/Extensions/TestExtensions.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/Extensions/TestExtensions.cs index fd9fde8c19b..0949e26bc5d 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/Extensions/TestExtensions.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/Extensions/TestExtensions.cs @@ -2,24 +2,23 @@ using Snapshooter; using Snapshooter.Xunit; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public static class TestExtensions { - public static class TestExtensions + public static void MatchDocumentSnapshot( + this IExecutionResult? result, + string snapshotName) { - public static void MatchDocumentSnapshot( - this IExecutionResult? result, - string snapshotName) + if (result is { }) { - if (result is { }) + result.ToJson().MatchSnapshot(new SnapshotNameExtension(snapshotName)); + if (result.ContextData is { } && + result.ContextData.TryGetValue("query", out object? queryResult) && + queryResult is string queryString && + !string.IsNullOrWhiteSpace(queryString)) { - result.ToJson().MatchSnapshot(new SnapshotNameExtension(snapshotName)); - if (result.ContextData is { } && - result.ContextData.TryGetValue("query", out object? queryResult) && - queryResult is string queryString && - !string.IsNullOrWhiteSpace(queryString)) - { - queryString.MatchSnapshot(new SnapshotNameExtension(snapshotName + "_query")); - } + queryString.MatchSnapshot(new SnapshotNameExtension(snapshotName + "_query")); } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/FilterVisitorTestBase.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/FilterVisitorTestBase.cs index 1cbe88ac93a..ed4bf688116 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/FilterVisitorTestBase.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/FilterVisitorTestBase.cs @@ -8,74 +8,73 @@ using MongoDB.Driver; using Squadron; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class FilterVisitorTestBase { - public class FilterVisitorTestBase + private Func> BuildResolver( + MongoResource mongoResource, + params TResult[] results) + where TResult : class { - private Func> BuildResolver( - MongoResource mongoResource, - params TResult[] results) - where TResult : class - { - IMongoCollection collection = - mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + IMongoCollection collection = + mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - collection.InsertMany(results); + collection.InsertMany(results); - return ctx => collection.AsExecutable(); - } + return ctx => collection.AsExecutable(); + } - protected IRequestExecutor CreateSchema( - TEntity[] entities, - MongoResource mongoResource, - bool withPaging = false) - where TEntity : class - where T : FilterInputType - { - Func> resolver = BuildResolver( - mongoResource, - entities); + protected IRequestExecutor CreateSchema( + TEntity[] entities, + MongoResource mongoResource, + bool withPaging = false) + where TEntity : class + where T : FilterInputType + { + Func> resolver = BuildResolver( + mongoResource, + entities); - return new ServiceCollection() - .AddGraphQL() - .AddObjectIdConverters() - .AddFiltering(x => x.BindRuntimeType().AddMongoDbDefaults()) - .AddQueryType( - c => c - .Name("Query") - .Field("root") - .Resolve(resolver) - .Use( - next => async context => + return new ServiceCollection() + .AddGraphQL() + .AddObjectIdConverters() + .AddFiltering(x => x.BindRuntimeType().AddMongoDbDefaults()) + .AddQueryType( + c => c + .Name("Query") + .Field("root") + .Resolve(resolver) + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseFiltering()) - .AddType(new TimeSpanType(TimeSpanFormat.DotNet)) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UseFiltering()) + .AddType(new TimeSpanType(TimeSpanFormat.DotNet)) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync() - .GetAwaiter() - .GetResult(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync() + .GetAwaiter() + .GetResult(); } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbAggregateFluentTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbAggregateFluentTests.cs index 5fb3c6702ef..f315a7f2a67 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbAggregateFluentTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbAggregateFluentTests.cs @@ -12,158 +12,157 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbAggregateFluentTests : IClassFixture { - public class MongoDbAggregateFluentTests : IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = true }, new Foo { Bar = false } }; - private static readonly Bar[] _barEntities = - { + private static readonly Bar[] _barEntities = + { new Bar { Baz = new DateTimeOffset(2020, 1, 12, 0, 0, 0, TimeSpan.Zero) }, new Bar { Baz = new DateTimeOffset(2020, 1, 11, 0, 0, 0, TimeSpan.Zero) } }; - private readonly MongoResource _resource; + private readonly MongoResource _resource; + + public MongoDbAggregateFluentTests(MongoResource resource) + { + _resource = resource; + } - public MongoDbAggregateFluentTests(MongoResource resource) - { - _resource = resource; - } + [Fact] + public async Task BsonElement_Rename() + { + // arrange + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - [Fact] - public async Task BsonElement_Rename() - { - // arrange - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_fooEntities); - - return collection.Aggregate().AsExecutable(); - }); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: true}}){ bar}}") - .Create()); - - res1.MatchDocumentSnapshot("true"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: false}}){ bar}}") - .Create()); - - res2.MatchDocumentSnapshot("false"); - } - - [Fact] - public async Task AggregateFluent_Serializer() - { - // arrange - BsonClassMap.RegisterClassMap( - x => x.MapField(y => y.Baz) - .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) - .SetElementName("testName")); - - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_barEntities); - - return collection.Aggregate().AsExecutable(); - }); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { baz: { eq: \"2020-01-11T00:00:00Z\"}}){ baz}}") - .Create()); - - res1.MatchDocumentSnapshot("2020-01-11"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { baz: { eq: \"2020-01-12T00:00:00Z\"}}){ baz}}") - .Create()); - - res2.MatchDocumentSnapshot("2020-01-12"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - [BsonElement("renameTest")] - public bool Bar { get; set; } - } - - public class Bar - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public DateTimeOffset Baz { get; set; } - } - - private static IRequestExecutor CreateSchema( - Func> resolver) - where TEntity : class - { - return new ServiceCollection() - .AddGraphQL() - .AddFiltering(x => x.AddMongoDbDefaults()) - .AddQueryType( - c => c - .Name("Query") - .Field("root") - .Type>>() - .Resolve( - async ctx => await new ValueTask>(resolver())) - .Use( - next => async context => + collection.InsertMany(_fooEntities); + + return collection.Aggregate().AsExecutable(); + }); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: true}}){ bar}}") + .Create()); + + res1.MatchDocumentSnapshot("true"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: false}}){ bar}}") + .Create()); + + res2.MatchDocumentSnapshot("false"); + } + + [Fact] + public async Task AggregateFluent_Serializer() + { + // arrange + BsonClassMap.RegisterClassMap( + x => x.MapField(y => y.Baz) + .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) + .SetElementName("testName")); + + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_barEntities); + + return collection.Aggregate().AsExecutable(); + }); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { baz: { eq: \"2020-01-11T00:00:00Z\"}}){ baz}}") + .Create()); + + res1.MatchDocumentSnapshot("2020-01-11"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { baz: { eq: \"2020-01-12T00:00:00Z\"}}){ baz}}") + .Create()); + + res2.MatchDocumentSnapshot("2020-01-12"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + [BsonElement("renameTest")] + public bool Bar { get; set; } + } + + public class Bar + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public DateTimeOffset Baz { get; set; } + } + + private static IRequestExecutor CreateSchema( + Func> resolver) + where TEntity : class + { + return new ServiceCollection() + .AddGraphQL() + .AddFiltering(x => x.AddMongoDbDefaults()) + .AddQueryType( + c => c + .Name("Query") + .Field("root") + .Type>>() + .Resolve( + async ctx => await new ValueTask>(resolver())) + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseFiltering>()) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UseFiltering>()) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync() - .GetAwaiter() - .GetResult(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync() + .GetAwaiter() + .GetResult(); } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbCollectionTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbCollectionTests.cs index 63cde607835..58191c1c1b6 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbCollectionTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbCollectionTests.cs @@ -12,156 +12,155 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbCollectionTests : IClassFixture { - public class MongoDbCollectionTests : IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = true }, new Foo { Bar = false } }; - private static readonly Bar[] _barEntities = - { + private static readonly Bar[] _barEntities = + { new Bar { Baz = new DateTimeOffset(2020, 1, 12, 0, 0, 0, TimeSpan.Zero) }, new Bar { Baz = new DateTimeOffset(2020, 1, 11, 0, 0, 0, TimeSpan.Zero) } }; - private readonly MongoResource _resource; + private readonly MongoResource _resource; - public MongoDbCollectionTests(MongoResource resource) - { - _resource = resource; - } + public MongoDbCollectionTests(MongoResource resource) + { + _resource = resource; + } - [Fact] - public async Task BsonElement_Rename() - { - // arrange - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_fooEntities); - return collection.AsExecutable(); - }); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: true}}){ bar}}") - .Create()); - - res1.MatchDocumentSnapshot("true"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: false}}){ bar}}") - .Create()); - - res2.MatchDocumentSnapshot("false"); - } - - [Fact] - public async Task Collection_Serializer() - { - // arrange - BsonClassMap.RegisterClassMap( - x => x.MapField(y => y.Baz) - .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) - .SetElementName("testName")); - - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_barEntities); - return collection.AsExecutable(); - }); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { baz: { eq: \"2020-01-11T00:00:00Z\"}}){ baz}}") - .Create()); - - res1.MatchDocumentSnapshot("2020-01-11"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { baz: { eq: \"2020-01-12T00:00:00Z\"}}){ baz}}") - .Create()); - - res2.MatchDocumentSnapshot("2020-01-12"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - [BsonElement("renameTest")] - public bool Bar { get; set; } - } - - public class Bar - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public DateTimeOffset Baz { get; set; } - } - - private static IRequestExecutor CreateSchema( - Func> resolver) - where TEntity : class - { - return new ServiceCollection() - .AddGraphQL() - .AddFiltering(x => x.AddMongoDbDefaults()) - .AddQueryType( - c => c - .Name("Query") - .Field("root") - .Type>>() - .Resolve( - async ctx => await new ValueTask>(resolver())) - .Use( - next => async context => + [Fact] + public async Task BsonElement_Rename() + { + // arrange + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_fooEntities); + return collection.AsExecutable(); + }); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: true}}){ bar}}") + .Create()); + + res1.MatchDocumentSnapshot("true"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: false}}){ bar}}") + .Create()); + + res2.MatchDocumentSnapshot("false"); + } + + [Fact] + public async Task Collection_Serializer() + { + // arrange + BsonClassMap.RegisterClassMap( + x => x.MapField(y => y.Baz) + .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) + .SetElementName("testName")); + + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_barEntities); + return collection.AsExecutable(); + }); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { baz: { eq: \"2020-01-11T00:00:00Z\"}}){ baz}}") + .Create()); + + res1.MatchDocumentSnapshot("2020-01-11"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { baz: { eq: \"2020-01-12T00:00:00Z\"}}){ baz}}") + .Create()); + + res2.MatchDocumentSnapshot("2020-01-12"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + [BsonElement("renameTest")] + public bool Bar { get; set; } + } + + public class Bar + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public DateTimeOffset Baz { get; set; } + } + + private static IRequestExecutor CreateSchema( + Func> resolver) + where TEntity : class + { + return new ServiceCollection() + .AddGraphQL() + .AddFiltering(x => x.AddMongoDbDefaults()) + .AddQueryType( + c => c + .Name("Query") + .Field("root") + .Type>>() + .Resolve( + async ctx => await new ValueTask>(resolver())) + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseFiltering>()) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UseFiltering>()) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync() - .GetAwaiter() - .GetResult(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync() + .GetAwaiter() + .GetResult(); } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorBooleanTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorBooleanTests.cs index 851f25620bd..70bb4fdb0a8 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorBooleanTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorBooleanTests.cs @@ -3,165 +3,164 @@ using HotChocolate.Data.Filters; using HotChocolate.Execution; using MongoDB.Bson.Serialization.Attributes; -using Xunit; using Squadron; +using Xunit; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbFilterVisitorBooleanTests + : SchemaCache + , IClassFixture { - public class MongoDbFilterVisitorBooleanTests - : SchemaCache - , IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = true }, new Foo { Bar = false } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new FooNullable { Bar = true }, new FooNullable { Bar = null }, new FooNullable { Bar = false } }; - public MongoDbFilterVisitorBooleanTests(MongoResource resource) - { - Init(resource); - } - - [Fact] - public async Task Create_BooleanEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: true}}){ bar}}") - .Create()); - - res1.MatchDocumentSnapshot("true"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: false}}){ bar}}") - .Create()); - - res2.MatchDocumentSnapshot("false"); - } - - [Fact] - public async Task Create_BooleanNotEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: true}}){ bar}}") - .Create()); - - res1.MatchDocumentSnapshot("true"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: false}}){ bar}}") - .Create()); - - res2.MatchDocumentSnapshot("false"); - } - - [Fact] - public async Task Create_NullableBooleanEqual_Expression() - { - // arrange - IRequestExecutor? tester = CreateSchema( - _fooNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: true}}){ bar}}") - .Create()); - - res1.MatchDocumentSnapshot("true"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: false}}){ bar}}") - .Create()); - - res2.MatchDocumentSnapshot("false"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: null}}){ bar}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_NullableBooleanNotEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: true}}){ bar}}") - .Create()); - - res1.MatchDocumentSnapshot("true"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: false}}){ bar}}") - .Create()); - - res2.MatchDocumentSnapshot("false"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: null}}){ bar}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public bool Bar { get; set; } - } - - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public bool? Bar { get; set; } - } - - public class FooFilterType - : FilterInputType - { - } - - public class FooNullableFilterType - : FilterInputType - { - } + public MongoDbFilterVisitorBooleanTests(MongoResource resource) + { + Init(resource); + } + + [Fact] + public async Task Create_BooleanEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: true}}){ bar}}") + .Create()); + + res1.MatchDocumentSnapshot("true"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: false}}){ bar}}") + .Create()); + + res2.MatchDocumentSnapshot("false"); + } + + [Fact] + public async Task Create_BooleanNotEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: true}}){ bar}}") + .Create()); + + res1.MatchDocumentSnapshot("true"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: false}}){ bar}}") + .Create()); + + res2.MatchDocumentSnapshot("false"); + } + + [Fact] + public async Task Create_NullableBooleanEqual_Expression() + { + // arrange + IRequestExecutor? tester = CreateSchema( + _fooNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: true}}){ bar}}") + .Create()); + + res1.MatchDocumentSnapshot("true"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: false}}){ bar}}") + .Create()); + + res2.MatchDocumentSnapshot("false"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: null}}){ bar}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_NullableBooleanNotEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: true}}){ bar}}") + .Create()); + + res1.MatchDocumentSnapshot("true"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: false}}){ bar}}") + .Create()); + + res2.MatchDocumentSnapshot("false"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: null}}){ bar}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public bool Bar { get; set; } + } + + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public bool? Bar { get; set; } + } + + public class FooFilterType + : FilterInputType + { + } + + public class FooNullableFilterType + : FilterInputType + { } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorComparableTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorComparableTests.cs index 52a83087470..39cb335ebcb 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorComparableTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorComparableTests.cs @@ -9,14 +9,14 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbFilterVisitorComparableTests + : SchemaCache + , IClassFixture { - public class MongoDbFilterVisitorComparableTests - : SchemaCache - , IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new() { BarShort = 12, @@ -34,8 +34,8 @@ public class MongoDbFilterVisitorComparableTests } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new() { BarShort = 12, @@ -54,981 +54,980 @@ public class MongoDbFilterVisitorComparableTests } }; - public MongoDbFilterVisitorComparableTests(MongoResource resource) - { - Init(resource); - } - - [Fact] - public async Task Create_ShortEqual_Expression_DateTime() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barDateTime: { eq: \"2000-01-12T00:00Z\"}})" + - "{ barDateTime}}") - .Create()); - - res1.MatchDocumentSnapshot("12"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barDateTime: { eq: \"2000-01-12T00:00Z\"}})" + - "{ barDateTime}}") - .Create()); - - res2.MatchDocumentSnapshot("13"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barDateTime: { eq: null}}){ barDateTime}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ShortEqual_Expression_DateTime_Nullable() - { - // arrange - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barDateTime: { eq: \"2000-01-12T00:00:00Z\"}})" + - "{ barDateTime}}") - .Create()); - - res1.MatchDocumentSnapshot("12"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barDateTime: { eq: \"2000-01-12T00:00:00Z\"}})" + - "{ barDateTime}}") - .Create()); - - res2.MatchDocumentSnapshot("13"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barDateTime: { eq: null}}){ barDateTime}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ShortEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { eq: 12}}){ barShort}}") - .Create()); - - res1.MatchDocumentSnapshot("12"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { eq: 13}}){ barShort}}") - .Create()); - - res2.MatchDocumentSnapshot("13"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { eq: null}}){ barShort}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ShortNotEqual_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { neq: 12}}){ barShort}}") - .Create()); - - res1.MatchDocumentSnapshot("12"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { neq: 13}}){ barShort}}") - .Create()); - - res2.MatchDocumentSnapshot("13"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { neq: null}}){ barShort}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ShortGreaterThan_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gt: 12}}){ barShort}}") - .Create()); - - res1.MatchDocumentSnapshot("12"); + public MongoDbFilterVisitorComparableTests(MongoResource resource) + { + Init(resource); + } + + [Fact] + public async Task Create_ShortEqual_Expression_DateTime() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barDateTime: { eq: \"2000-01-12T00:00Z\"}})" + + "{ barDateTime}}") + .Create()); + + res1.MatchDocumentSnapshot("12"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barDateTime: { eq: \"2000-01-12T00:00Z\"}})" + + "{ barDateTime}}") + .Create()); + + res2.MatchDocumentSnapshot("13"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barDateTime: { eq: null}}){ barDateTime}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ShortEqual_Expression_DateTime_Nullable() + { + // arrange + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barDateTime: { eq: \"2000-01-12T00:00:00Z\"}})" + + "{ barDateTime}}") + .Create()); + + res1.MatchDocumentSnapshot("12"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barDateTime: { eq: \"2000-01-12T00:00:00Z\"}})" + + "{ barDateTime}}") + .Create()); + + res2.MatchDocumentSnapshot("13"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barDateTime: { eq: null}}){ barDateTime}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ShortEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { eq: 12}}){ barShort}}") + .Create()); + + res1.MatchDocumentSnapshot("12"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { eq: 13}}){ barShort}}") + .Create()); + + res2.MatchDocumentSnapshot("13"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { eq: null}}){ barShort}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ShortNotEqual_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { neq: 12}}){ barShort}}") + .Create()); + + res1.MatchDocumentSnapshot("12"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { neq: 13}}){ barShort}}") + .Create()); + + res2.MatchDocumentSnapshot("13"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { neq: null}}){ barShort}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ShortGreaterThan_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gt: 12}}){ barShort}}") + .Create()); + + res1.MatchDocumentSnapshot("12"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gt: 13}}){ barShort}}") + .Create()); + + res2.MatchDocumentSnapshot("13"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gt: 14}}){ barShort}}") + .Create()); + + res3.MatchDocumentSnapshot("14"); + + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gt: null}}){ barShort}}") + .Create()); + + res4.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ShortNotGreaterThan_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngt: 12}}){ barShort}}") + .Create()); + + res1.MatchDocumentSnapshot("12"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngt: 13}}){ barShort}}") + .Create()); + + res2.MatchDocumentSnapshot("13"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngt: 14}}){ barShort}}") + .Create()); + + res3.MatchDocumentSnapshot("14"); + + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngt: null}}){ barShort}}") + .Create()); + + res4.MatchDocumentSnapshot("null"); + } + + + [Fact] + public async Task Create_ShortGreaterThanOrEquals_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gte: 12}}){ barShort}}") + .Create()); + + res1.MatchDocumentSnapshot("12"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gte: 13}}){ barShort}}") + .Create()); + + res2.MatchDocumentSnapshot("13"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gte: 14}}){ barShort}}") + .Create()); + + res3.MatchDocumentSnapshot("14"); + + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gte: null}}){ barShort}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gt: 13}}){ barShort}}") - .Create()); - - res2.MatchDocumentSnapshot("13"); + res4.MatchDocumentSnapshot("null"); + } - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gt: 14}}){ barShort}}") - .Create()); - - res3.MatchDocumentSnapshot("14"); + [Fact] + public async Task Create_ShortNotGreaterThanOrEquals_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gt: null}}){ barShort}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngte: 12}}){ barShort}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } + res1.MatchDocumentSnapshot("12"); - [Fact] - public async Task Create_ShortNotGreaterThan_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngte: 13}}){ barShort}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngt: 12}}){ barShort}}") - .Create()); + res2.MatchDocumentSnapshot("13"); - res1.MatchDocumentSnapshot("12"); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngte: 14}}){ barShort}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngt: 13}}){ barShort}}") - .Create()); + res3.MatchDocumentSnapshot("14"); - res2.MatchDocumentSnapshot("13"); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngte: null}}){ barShort}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngt: 14}}){ barShort}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res3.MatchDocumentSnapshot("14"); + [Fact] + public async Task Create_ShortLowerThan_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngt: null}}){ barShort}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lt: 12}}){ barShort}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } + res1.MatchDocumentSnapshot("12"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lt: 13}}){ barShort}}") + .Create()); - [Fact] - public async Task Create_ShortGreaterThanOrEquals_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + res2.MatchDocumentSnapshot("13"); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gte: 12}}){ barShort}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lt: 14}}){ barShort}}") + .Create()); - res1.MatchDocumentSnapshot("12"); + res3.MatchDocumentSnapshot("14"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gte: 13}}){ barShort}}") - .Create()); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lt: null}}){ barShort}}") + .Create()); - res2.MatchDocumentSnapshot("13"); + res4.MatchDocumentSnapshot("null"); + } - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gte: 14}}){ barShort}}") - .Create()); + [Fact] + public async Task Create_ShortNotLowerThan_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - res3.MatchDocumentSnapshot("14"); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlt: 12}}){ barShort}}") + .Create()); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gte: null}}){ barShort}}") - .Create()); + res1.MatchDocumentSnapshot("12"); - res4.MatchDocumentSnapshot("null"); - } + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlt: 13}}){ barShort}}") + .Create()); - [Fact] - public async Task Create_ShortNotGreaterThanOrEquals_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + res2.MatchDocumentSnapshot("13"); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngte: 12}}){ barShort}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlt: 14}}){ barShort}}") + .Create()); - res1.MatchDocumentSnapshot("12"); + res3.MatchDocumentSnapshot("14"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngte: 13}}){ barShort}}") - .Create()); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlt: null}}){ barShort}}") + .Create()); - res2.MatchDocumentSnapshot("13"); + res4.MatchDocumentSnapshot("null"); + } - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngte: 14}}){ barShort}}") - .Create()); - res3.MatchDocumentSnapshot("14"); + [Fact] + public async Task Create_ShortLowerThanOrEquals_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngte: null}}){ barShort}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lte: 12}}){ barShort}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } + res1.MatchDocumentSnapshot("12"); - [Fact] - public async Task Create_ShortLowerThan_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lte: 13}}){ barShort}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lt: 12}}){ barShort}}") - .Create()); + res2.MatchDocumentSnapshot("13"); - res1.MatchDocumentSnapshot("12"); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lte: 14}}){ barShort}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lt: 13}}){ barShort}}") - .Create()); + res3.MatchDocumentSnapshot("14"); - res2.MatchDocumentSnapshot("13"); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lte: null}}){ barShort}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lt: 14}}){ barShort}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res3.MatchDocumentSnapshot("14"); + [Fact] + public async Task Create_ShortNotLowerThanOrEquals_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlte: 12}}){ barShort}}") + .Create()); + + res1.MatchDocumentSnapshot("12"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlte: 13}}){ barShort}}") + .Create()); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lt: null}}){ barShort}}") - .Create()); + res2.MatchDocumentSnapshot("13"); - res4.MatchDocumentSnapshot("null"); - } + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlte: 14}}){ barShort}}") + .Create()); - [Fact] - public async Task Create_ShortNotLowerThan_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + res3.MatchDocumentSnapshot("14"); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlt: 12}}){ barShort}}") - .Create()); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlte: null}}){ barShort}}") + .Create()); - res1.MatchDocumentSnapshot("12"); + res4.MatchDocumentSnapshot("null"); + } - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlt: 13}}){ barShort}}") - .Create()); + [Fact] + public async Task Create_ShortIn_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - res2.MatchDocumentSnapshot("13"); + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { in: [ 12, 13 ]}}){ barShort}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlt: 14}}){ barShort}}") - .Create()); + res1.MatchDocumentSnapshot("12and13"); - res3.MatchDocumentSnapshot("14"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { in: [ null, 14 ]}}){ barShort}}") + .Create()); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlt: null}}){ barShort}}") - .Create()); + res2.MatchDocumentSnapshot("13and14"); - res4.MatchDocumentSnapshot("null"); - } + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { in: [ null, 14 ]}}){ barShort}}") + .Create()); + res3.MatchDocumentSnapshot("nullAnd14"); + } - [Fact] - public async Task Create_ShortLowerThanOrEquals_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_ShortNotIn_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lte: 12}}){ barShort}}") - .Create()); + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nin: [ 12, 13 ]}}){ barShort}}") + .Create()); - res1.MatchDocumentSnapshot("12"); + res1.MatchDocumentSnapshot("12and13"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nin: [ null, 14 ]}}){ barShort}}") + .Create()); + + res2.MatchDocumentSnapshot("13and14"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nin: [ null, 14 ]}}){ barShort}}") + .Create()); + + res3.MatchDocumentSnapshot("nullAnd14"); + } + + [Fact] + public async Task Create_ShortNullableEqual_Expression() + { + // arrange + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { eq: 12}}){ barShort}}") + .Create()); + + res1.MatchDocumentSnapshot("12"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { eq: 13}}){ barShort}}") + .Create()); + + res2.MatchDocumentSnapshot("13"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { eq: null}}){ barShort}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ShortNullableNotEqual_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lte: 13}}){ barShort}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { neq: 12}}){ barShort}}") + .Create()); - res2.MatchDocumentSnapshot("13"); + res1.MatchDocumentSnapshot("12"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lte: 14}}){ barShort}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { neq: 13}}){ barShort}}") + .Create()); - res3.MatchDocumentSnapshot("14"); + res2.MatchDocumentSnapshot("13"); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lte: null}}){ barShort}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { neq: null}}){ barShort}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_ShortNotLowerThanOrEquals_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlte: 12}}){ barShort}}") - .Create()); + [Fact] + public async Task Create_ShortNullableGreaterThan_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - res1.MatchDocumentSnapshot("12"); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gt: 12}}){ barShort}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlte: 13}}){ barShort}}") - .Create()); + res1.MatchDocumentSnapshot("12"); - res2.MatchDocumentSnapshot("13"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gt: 13}}){ barShort}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlte: 14}}){ barShort}}") - .Create()); + res2.MatchDocumentSnapshot("13"); - res3.MatchDocumentSnapshot("14"); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gt: 14}}){ barShort}}") + .Create()); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlte: null}}){ barShort}}") - .Create()); - - res4.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("14"); - [Fact] - public async Task Create_ShortIn_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gt: null}}){ barShort}}") + .Create()); - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { in: [ 12, 13 ]}}){ barShort}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res1.MatchDocumentSnapshot("12and13"); + [Fact] + public async Task Create_ShortNullableNotGreaterThan_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { in: [ null, 14 ]}}){ barShort}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngt: 12}}){ barShort}}") + .Create()); - res2.MatchDocumentSnapshot("13and14"); + res1.MatchDocumentSnapshot("12"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { in: [ null, 14 ]}}){ barShort}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngt: 13}}){ barShort}}") + .Create()); - res3.MatchDocumentSnapshot("nullAnd14"); - } + res2.MatchDocumentSnapshot("13"); - [Fact] - public async Task Create_ShortNotIn_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngt: 14}}){ barShort}}") + .Create()); - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nin: [ 12, 13 ]}}){ barShort}}") - .Create()); + res3.MatchDocumentSnapshot("14"); - res1.MatchDocumentSnapshot("12and13"); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngt: null}}){ barShort}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nin: [ null, 14 ]}}){ barShort}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res2.MatchDocumentSnapshot("13and14"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nin: [ null, 14 ]}}){ barShort}}") - .Create()); + [Fact] + public async Task Create_ShortNullableGreaterThanOrEquals_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - res3.MatchDocumentSnapshot("nullAnd14"); - } + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gte: 12}}){ barShort}}") + .Create()); - [Fact] - public async Task Create_ShortNullableEqual_Expression() - { - // arrange - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + res1.MatchDocumentSnapshot("12"); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { eq: 12}}){ barShort}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gte: 13}}){ barShort}}") + .Create()); - res1.MatchDocumentSnapshot("12"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { eq: 13}}){ barShort}}") - .Create()); + res2.MatchDocumentSnapshot("13"); - res2.MatchDocumentSnapshot("13"); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gte: 14}}){ barShort}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { eq: null}}){ barShort}}") - .Create()); + res3.MatchDocumentSnapshot("14"); - res3.MatchDocumentSnapshot("null"); - } + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { gte: null}}){ barShort}}") + .Create()); - [Fact] - public async Task Create_ShortNullableNotEqual_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + res4.MatchDocumentSnapshot("null"); + } - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { neq: 12}}){ barShort}}") - .Create()); + [Fact] + public async Task Create_ShortNullableNotGreaterThanOrEquals_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - res1.MatchDocumentSnapshot("12"); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngte: 12}}){ barShort}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { neq: 13}}){ barShort}}") - .Create()); + res1.MatchDocumentSnapshot("12"); - res2.MatchDocumentSnapshot("13"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngte: 13}}){ barShort}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { neq: null}}){ barShort}}") - .Create()); + res2.MatchDocumentSnapshot("13"); - res3.MatchDocumentSnapshot("null"); - } + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngte: 14}}){ barShort}}") + .Create()); + res3.MatchDocumentSnapshot("14"); - [Fact] - public async Task Create_ShortNullableGreaterThan_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { ngte: null}}){ barShort}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gt: 12}}){ barShort}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res1.MatchDocumentSnapshot("12"); + [Fact] + public async Task Create_ShortNullableLowerThan_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gt: 13}}){ barShort}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lt: 12}}){ barShort}}") + .Create()); - res2.MatchDocumentSnapshot("13"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gt: 14}}){ barShort}}") - .Create()); + res1.MatchDocumentSnapshot("12"); - res3.MatchDocumentSnapshot("14"); - - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gt: null}}){ barShort}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lt: 13}}){ barShort}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ShortNullableNotGreaterThan_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + res2.MatchDocumentSnapshot("13"); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngt: 12}}){ barShort}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lt: 14}}){ barShort}}") + .Create()); - res1.MatchDocumentSnapshot("12"); + res3.MatchDocumentSnapshot("14"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngt: 13}}){ barShort}}") - .Create()); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lt: null}}){ barShort}}") + .Create()); - res2.MatchDocumentSnapshot("13"); + res4.MatchDocumentSnapshot("null"); + } - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngt: 14}}){ barShort}}") - .Create()); + [Fact] + public async Task Create_ShortNullableNotLowerThan_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - res3.MatchDocumentSnapshot("14"); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlt: 12}}){ barShort}}") + .Create()); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngt: null}}){ barShort}}") - .Create()); + res1.MatchDocumentSnapshot("12"); - res4.MatchDocumentSnapshot("null"); - } + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlt: 13}}){ barShort}}") + .Create()); + res2.MatchDocumentSnapshot("13"); - [Fact] - public async Task Create_ShortNullableGreaterThanOrEquals_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlt: 14}}){ barShort}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gte: 12}}){ barShort}}") - .Create()); + res3.MatchDocumentSnapshot("14"); - res1.MatchDocumentSnapshot("12"); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlt: null}}){ barShort}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gte: 13}}){ barShort}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res2.MatchDocumentSnapshot("13"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gte: 14}}){ barShort}}") - .Create()); - - res3.MatchDocumentSnapshot("14"); - - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { gte: null}}){ barShort}}") - .Create()); - res4.MatchDocumentSnapshot("null"); - } + [Fact] + public async Task Create_ShortNullableLowerThanOrEquals_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - [Fact] - public async Task Create_ShortNullableNotGreaterThanOrEquals_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lte: 12}}){ barShort}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngte: 12}}){ barShort}}") - .Create()); + res1.MatchDocumentSnapshot("12"); - res1.MatchDocumentSnapshot("12"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lte: 13}}){ barShort}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngte: 13}}){ barShort}}") - .Create()); + res2.MatchDocumentSnapshot("13"); - res2.MatchDocumentSnapshot("13"); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lte: 14}}){ barShort}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngte: 14}}){ barShort}}") - .Create()); + res3.MatchDocumentSnapshot("14"); - res3.MatchDocumentSnapshot("14"); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { lte: null}}){ barShort}}") + .Create()); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { ngte: null}}){ barShort}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res4.MatchDocumentSnapshot("null"); - } + [Fact] + public async Task Create_ShortNullableNotLowerThanOrEquals_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - [Fact] - public async Task Create_ShortNullableLowerThan_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlte: 12}}){ barShort}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lt: 12}}){ barShort}}") - .Create()); + res1.MatchDocumentSnapshot("12"); - res1.MatchDocumentSnapshot("12"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlte: 13}}){ barShort}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lt: 13}}){ barShort}}") - .Create()); + res2.MatchDocumentSnapshot("13"); - res2.MatchDocumentSnapshot("13"); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlte: 14}}){ barShort}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lt: 14}}){ barShort}}") - .Create()); - - res3.MatchDocumentSnapshot("14"); - - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lt: null}}){ barShort}}") - .Create()); + res3.MatchDocumentSnapshot("14"); - res4.MatchDocumentSnapshot("null"); - } + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nlte: null}}){ barShort}}") + .Create()); - [Fact] - public async Task Create_ShortNullableNotLowerThan_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + res4.MatchDocumentSnapshot("null"); + } - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlt: 12}}){ barShort}}") - .Create()); + [Fact] + public async Task Create_ShortNullableIn_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - res1.MatchDocumentSnapshot("12"); + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { in: [ 12, 13 ]}}){ barShort}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlt: 13}}){ barShort}}") - .Create()); - - res2.MatchDocumentSnapshot("13"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlt: 14}}){ barShort}}") - .Create()); - - res3.MatchDocumentSnapshot("14"); - - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlt: null}}){ barShort}}") - .Create()); + res1.MatchDocumentSnapshot("12and13"); - res4.MatchDocumentSnapshot("null"); - } + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { in: [ 13, 14 ]}}){ barShort}}") + .Create()); + res2.MatchDocumentSnapshot("13and14"); - [Fact] - public async Task Create_ShortNullableLowerThanOrEquals_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { in: [ 13, null ]}}){ barShort}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lte: 12}}){ barShort}}") - .Create()); + res3.MatchDocumentSnapshot("13andNull"); + } - res1.MatchDocumentSnapshot("12"); + [Fact] + public async Task Create_ShortNullableNotIn_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lte: 13}}){ barShort}}") - .Create()); + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nin: [ 12, 13 ]}}){ barShort}}") + .Create()); - res2.MatchDocumentSnapshot("13"); + res1.MatchDocumentSnapshot("12and13"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lte: 14}}){ barShort}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nin: [ 13, 14 ]}}){ barShort}}") + .Create()); - res3.MatchDocumentSnapshot("14"); + res2.MatchDocumentSnapshot("13and14"); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { lte: null}}){ barShort}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barShort: { nin: [ 13, null ]}}){ barShort}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("13andNull"); + } - [Fact] - public async Task Create_ShortNullableNotLowerThanOrEquals_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlte: 12}}){ barShort}}") - .Create()); - - res1.MatchDocumentSnapshot("12"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlte: 13}}){ barShort}}") - .Create()); - - res2.MatchDocumentSnapshot("13"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlte: 14}}){ barShort}}") - .Create()); - - res3.MatchDocumentSnapshot("14"); - - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nlte: null}}){ barShort}}") - .Create()); - - res4.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ShortNullableIn_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); - - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { in: [ 12, 13 ]}}){ barShort}}") - .Create()); - - res1.MatchDocumentSnapshot("12and13"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { in: [ 13, 14 ]}}){ barShort}}") - .Create()); - - res2.MatchDocumentSnapshot("13and14"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { in: [ 13, null ]}}){ barShort}}") - .Create()); - - res3.MatchDocumentSnapshot("13andNull"); - } - - [Fact] - public async Task Create_ShortNullableNotIn_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); - - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nin: [ 12, 13 ]}}){ barShort}}") - .Create()); - - res1.MatchDocumentSnapshot("12and13"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nin: [ 13, 14 ]}}){ barShort}}") - .Create()); - - res2.MatchDocumentSnapshot("13and14"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barShort: { nin: [ 13, null ]}}){ barShort}}") - .Create()); - - res3.MatchDocumentSnapshot("13andNull"); - } - - [Fact] - public void Create_Implicit_Operation() - { - // arrange - // act - ISchema schema = SchemaBuilder.New() - .AddQueryType( - t => t - .Name("Query") - .Field("foo") - .Type() - .Resolve("foo") - .Argument("test", a => a.Type>())) - .AddMongoDbFiltering(compatabilityMode: true) - .Create(); - - // assert + [Fact] + public void Create_Implicit_Operation() + { + // arrange + // act + ISchema schema = SchemaBuilder.New() + .AddQueryType( + t => t + .Name("Query") + .Field("foo") + .Type() + .Resolve("foo") + .Argument("test", a => a.Type>())) + .AddMongoDbFiltering(compatabilityMode: true) + .Create(); + + // assert #if NET6_0_OR_GREATER - schema.ToString().MatchSnapshot(new SnapshotNameExtension("NET6")); + schema.ToString().MatchSnapshot(new SnapshotNameExtension("NET6")); #else schema.ToString().MatchSnapshot(); #endif - } - - [Fact] - public void Create_Implicit_Operation_Normalized() - { - // arrange - // act - ISchema schema = SchemaBuilder.New() - .AddQueryType( - t => t - .Name("Query") - .Field("foo") - .Type() - .Resolve("foo") - .Argument("test", a => a.Type>())) - .AddMongoDbFiltering() - .Create(); - - // assert + } + + [Fact] + public void Create_Implicit_Operation_Normalized() + { + // arrange + // act + ISchema schema = SchemaBuilder.New() + .AddQueryType( + t => t + .Name("Query") + .Field("foo") + .Type() + .Resolve("foo") + .Argument("test", a => a.Type>())) + .AddMongoDbFiltering() + .Create(); + + // assert #if NET6_0_OR_GREATER - schema.ToString().MatchSnapshot(new SnapshotNameExtension("NET6")); + schema.ToString().MatchSnapshot(new SnapshotNameExtension("NET6")); #else schema.ToString().MatchSnapshot(); #endif - } + } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public short BarShort { get; set; } + public short BarShort { get; set; } - public int BarInt { get; set; } + public int BarInt { get; set; } - public long BarLong { get; set; } + public long BarLong { get; set; } - public float BarFloat { get; set; } + public float BarFloat { get; set; } - public double BarDouble { get; set; } + public double BarDouble { get; set; } - public decimal BarDecimal { get; set; } + public decimal BarDecimal { get; set; } - public DateTime BarDateTime { get; set; } - } + public DateTime BarDateTime { get; set; } + } - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public short? BarShort { get; set; } + public short? BarShort { get; set; } - public DateTime? BarDateTime { get; set; } - } + public DateTime? BarDateTime { get; set; } + } - public class FooFilterType - : FilterInputType - { - } + public class FooFilterType + : FilterInputType + { + } - public class FooNullableFilterType - : FilterInputType - { - } + public class FooNullableFilterType + : FilterInputType + { } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorDateOnlyTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorDateOnlyTests.cs index 1f892840ba5..40541b9d64c 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorDateOnlyTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorDateOnlyTests.cs @@ -6,202 +6,201 @@ using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Attributes; using MongoDB.Bson.Serialization.Serializers; -using Xunit; using Squadron; +using Xunit; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbFilterVisitorDateOnlyTests + : SchemaCache + , IClassFixture { - public class MongoDbFilterVisitorDateOnlyTests - : SchemaCache - , IClassFixture - { #if NET6_0_OR_GREATER - private static readonly Foo[] _fooEntities = - { + private static readonly Foo[] _fooEntities = + { new Foo { Bar = new DateOnly(2022, 01, 16) }, new Foo { Bar = new DateOnly(2022, 01, 15) } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new FooNullable { Bar = new DateOnly(2022, 01, 16) }, new FooNullable { Bar = null }, new FooNullable { Bar = new DateOnly(2022, 01, 15) } }; - public MongoDbFilterVisitorDateOnlyTests(MongoResource resource) - { - Init(resource); + public MongoDbFilterVisitorDateOnlyTests(MongoResource resource) + { + Init(resource); - // NOTE: At the time of coding, MongoDB C# Driver doesn't natively support DateOnly - BsonSerializer.RegisterSerializationProvider(new LocalDateOnlySerializationProvider()); - } + // NOTE: At the time of coding, MongoDB C# Driver doesn't natively support DateOnly + BsonSerializer.RegisterSerializationProvider(new LocalDateOnlySerializationProvider()); + } - [Fact] - public async Task Create_DateOnlyEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_DateOnlyEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"2022-01-16\" } }){ bar } }") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"2022-01-16\" } }){ bar } }") + .Create()); - res1.MatchDocumentSnapshot("2022-01-16"); + res1.MatchDocumentSnapshot("2022-01-16"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"2022-01-15\" } }){ bar } }") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"2022-01-15\" } }){ bar } }") + .Create()); - res2.MatchDocumentSnapshot("2022-01-15"); - } + res2.MatchDocumentSnapshot("2022-01-15"); + } - [Fact] - public async Task Create_DateOnlyNotEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_DateOnlyNotEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"2022-01-15\" } }){ bar } }") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"2022-01-15\" } }){ bar } }") + .Create()); - res1.MatchDocumentSnapshot("2022-01-15"); + res1.MatchDocumentSnapshot("2022-01-15"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"2022-01-16\" } }){ bar } }") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"2022-01-16\" } }){ bar } }") + .Create()); - res2.MatchDocumentSnapshot("2022-01-16"); - } + res2.MatchDocumentSnapshot("2022-01-16"); + } - [Fact] - public async Task Create_NullableDateOnlyEqual_Expression() - { - // arrange - IRequestExecutor? tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableDateOnlyEqual_Expression() + { + // arrange + IRequestExecutor? tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"2022-01-16\" } }){ bar } }") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"2022-01-16\" } }){ bar } }") + .Create()); - res1.MatchDocumentSnapshot("2022-01-16"); + res1.MatchDocumentSnapshot("2022-01-16"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"2022-01-15\" } }){ bar } }") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"2022-01-15\" } }){ bar } }") + .Create()); - res2.MatchDocumentSnapshot("2022-01-15"); + res2.MatchDocumentSnapshot("2022-01-15"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: null } }){ bar } }") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: null } }){ bar } }") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_NullableDateOnlyNotEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableDateOnlyNotEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"2022-01-15\" } }){ bar } }") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"2022-01-15\" } }){ bar } }") + .Create()); - res1.MatchDocumentSnapshot("2022-01-15"); + res1.MatchDocumentSnapshot("2022-01-15"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"2022-01-16\" } }){ bar } }") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"2022-01-16\" } }){ bar } }") + .Create()); - res2.MatchDocumentSnapshot("2022-01-16"); + res2.MatchDocumentSnapshot("2022-01-16"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: null } }){ bar } }") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: null } }){ bar } }") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public DateOnly Bar { get; set; } - } + public DateOnly Bar { get; set; } + } - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public DateOnly? Bar { get; set; } - } + public DateOnly? Bar { get; set; } + } - public class FooFilterType - : FilterInputType - { - } + public class FooFilterType + : FilterInputType + { + } + + public class FooNullableFilterType + : FilterInputType + { + } - public class FooNullableFilterType - : FilterInputType + internal class LocalDateOnlySerializationProvider : IBsonSerializationProvider + { + public IBsonSerializer? GetSerializer(Type type) { + return type == typeof(DateOnly) ? new DateOnlySerializer() : null; } + } + + internal class DateOnlySerializer : StructSerializerBase + { + private static readonly TimeOnly zeroTimeComponent = new(); - internal class LocalDateOnlySerializationProvider : IBsonSerializationProvider + public override void Serialize( + BsonSerializationContext context, + BsonSerializationArgs args, + DateOnly value) { - public IBsonSerializer? GetSerializer(Type type) - { - return type == typeof(DateOnly) ? new DateOnlySerializer() : null; - } + var dateTime = value.ToDateTime(zeroTimeComponent, DateTimeKind.Utc); + var ticks = BsonUtils.ToMillisecondsSinceEpoch(dateTime); + context.Writer.WriteDateTime(ticks); } - internal class DateOnlySerializer : StructSerializerBase + public override DateOnly Deserialize( + BsonDeserializationContext context, + BsonDeserializationArgs args) { - private static readonly TimeOnly zeroTimeComponent = new(); - - public override void Serialize( - BsonSerializationContext context, - BsonSerializationArgs args, - DateOnly value) - { - var dateTime = value.ToDateTime(zeroTimeComponent, DateTimeKind.Utc); - var ticks = BsonUtils.ToMillisecondsSinceEpoch(dateTime); - context.Writer.WriteDateTime(ticks); - } - - public override DateOnly Deserialize( - BsonDeserializationContext context, - BsonDeserializationArgs args) - { - long ticks = context.Reader.ReadDateTime(); - DateTime dateTime = BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(ticks); - return new DateOnly(dateTime.Year, dateTime.Month, dateTime.Day); - } + long ticks = context.Reader.ReadDateTime(); + DateTime dateTime = BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(ticks); + return new DateOnly(dateTime.Year, dateTime.Month, dateTime.Day); } -#endif } +#endif } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorEnumTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorEnumTests.cs index af5d4c98bd3..8e9f62d917d 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorEnumTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorEnumTests.cs @@ -3,25 +3,25 @@ using HotChocolate.Data.Filters; using HotChocolate.Execution; using MongoDB.Bson.Serialization.Attributes; -using Xunit; using Squadron; +using Xunit; + +namespace HotChocolate.Data.MongoDb.Filters; -namespace HotChocolate.Data.MongoDb.Filters +public class MongoDbFilterVisitorEnumTests + : SchemaCache + , IClassFixture { - public class MongoDbFilterVisitorEnumTests - : SchemaCache - , IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { BarEnum = FooEnum.BAR }, new Foo { BarEnum = FooEnum.BAZ }, new Foo { BarEnum = FooEnum.FOO }, new Foo { BarEnum = FooEnum.QUX } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new FooNullable { BarEnum = FooEnum.BAR }, new FooNullable { BarEnum = FooEnum.BAZ }, new FooNullable { BarEnum = FooEnum.FOO }, @@ -29,279 +29,278 @@ public class MongoDbFilterVisitorEnumTests new FooNullable { BarEnum = FooEnum.QUX } }; - public MongoDbFilterVisitorEnumTests(MongoResource resource) - { - Init(resource); - } - - [Fact] - public async Task Create_EnumEqual_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { eq: BAR } }) { barEnum } }") - .Create()); - - res1.MatchDocumentSnapshot("BAR"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { eq: FOO } }) { barEnum } }") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { eq: null } }) { barEnum } }") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_EnumNotEqual_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { neq: BAR } }) { barEnum } }") - .Create()); - - res1.MatchDocumentSnapshot("BAR"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { neq: FOO } }) { barEnum } }") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { neq: null } }){ barEnum } }") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_EnumIn_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { in: [ BAR FOO ]}}){ barEnum}}") - .Create()); - - res1.MatchDocumentSnapshot("BarAndFoo"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { in: [ FOO ]}}){ barEnum}}") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { in: [ null FOO ]}}){ barEnum}}") - .Create()); - - res3.MatchDocumentSnapshot("nullAndFoo"); - } - - [Fact] - public async Task Create_EnumNotIn_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { nin: [ BAR FOO ] } }) { barEnum } }") - .Create()); - - res1.MatchDocumentSnapshot("BarAndFoo"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { nin: [ FOO ] } }) { barEnum } }") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { nin: [ null FOO ] } }) { barEnum } }") - .Create()); - - res3.MatchDocumentSnapshot("nullAndFoo"); - } - - [Fact] - public async Task Create_NullableEnumEqual_Expression() - { - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { eq: BAR } }) { barEnum } }") - .Create()); - - res1.MatchDocumentSnapshot("BAR"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { eq: FOO } }) { barEnum } }") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { eq: null } }){ barEnum } }") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_NullableEnumNotEqual_Expression() - { - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { neq: BAR } }) { barEnum } }") - .Create()); - - res1.MatchDocumentSnapshot("BAR"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { neq: FOO } }) { barEnum } }") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { neq: null } }) { barEnum } }") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_NullableEnumIn_Expression() - { - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { in: [ BAR FOO ] } }) { barEnum } }") - .Create()); - - res1.MatchDocumentSnapshot("BarAndFoo"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { in: [ FOO ] } }) { barEnum } }") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { in: [ null FOO ] } }) { barEnum } }") - .Create()); - - res3.MatchDocumentSnapshot("nullAndFoo"); - } - - [Fact] - public async Task Create_NullableEnumNotIn_Expression() - { - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { nin: [ BAR FOO ] } }){ barEnum } }") - .Create()); - - res1.MatchDocumentSnapshot("BarAndFoo"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { nin: [ FOO ] } }) { barEnum } }") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { barEnum: { nin: [ null FOO ] } }) { barEnum } }") - .Create()); - - res3.MatchDocumentSnapshot("nullAndFoo"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public FooEnum BarEnum { get; set; } - } - - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public FooEnum? BarEnum { get; set; } - } - - public enum FooEnum - { - FOO, - BAR, - BAZ, - QUX - } - - public class FooFilterType - : FilterInputType - { - } - - public class FooNullableFilterType - : FilterInputType - { - } + public MongoDbFilterVisitorEnumTests(MongoResource resource) + { + Init(resource); + } + + [Fact] + public async Task Create_EnumEqual_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { eq: BAR } }) { barEnum } }") + .Create()); + + res1.MatchDocumentSnapshot("BAR"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { eq: FOO } }) { barEnum } }") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { eq: null } }) { barEnum } }") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_EnumNotEqual_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { neq: BAR } }) { barEnum } }") + .Create()); + + res1.MatchDocumentSnapshot("BAR"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { neq: FOO } }) { barEnum } }") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { neq: null } }){ barEnum } }") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_EnumIn_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { in: [ BAR FOO ]}}){ barEnum}}") + .Create()); + + res1.MatchDocumentSnapshot("BarAndFoo"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { in: [ FOO ]}}){ barEnum}}") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { in: [ null FOO ]}}){ barEnum}}") + .Create()); + + res3.MatchDocumentSnapshot("nullAndFoo"); + } + + [Fact] + public async Task Create_EnumNotIn_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { nin: [ BAR FOO ] } }) { barEnum } }") + .Create()); + + res1.MatchDocumentSnapshot("BarAndFoo"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { nin: [ FOO ] } }) { barEnum } }") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { nin: [ null FOO ] } }) { barEnum } }") + .Create()); + + res3.MatchDocumentSnapshot("nullAndFoo"); + } + + [Fact] + public async Task Create_NullableEnumEqual_Expression() + { + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { eq: BAR } }) { barEnum } }") + .Create()); + + res1.MatchDocumentSnapshot("BAR"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { eq: FOO } }) { barEnum } }") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { eq: null } }){ barEnum } }") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_NullableEnumNotEqual_Expression() + { + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { neq: BAR } }) { barEnum } }") + .Create()); + + res1.MatchDocumentSnapshot("BAR"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { neq: FOO } }) { barEnum } }") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { neq: null } }) { barEnum } }") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_NullableEnumIn_Expression() + { + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { in: [ BAR FOO ] } }) { barEnum } }") + .Create()); + + res1.MatchDocumentSnapshot("BarAndFoo"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { in: [ FOO ] } }) { barEnum } }") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { in: [ null FOO ] } }) { barEnum } }") + .Create()); + + res3.MatchDocumentSnapshot("nullAndFoo"); + } + + [Fact] + public async Task Create_NullableEnumNotIn_Expression() + { + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { nin: [ BAR FOO ] } }){ barEnum } }") + .Create()); + + res1.MatchDocumentSnapshot("BarAndFoo"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { nin: [ FOO ] } }) { barEnum } }") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { barEnum: { nin: [ null FOO ] } }) { barEnum } }") + .Create()); + + res3.MatchDocumentSnapshot("nullAndFoo"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public FooEnum BarEnum { get; set; } + } + + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public FooEnum? BarEnum { get; set; } + } + + public enum FooEnum + { + FOO, + BAR, + BAZ, + QUX + } + + public class FooFilterType + : FilterInputType + { + } + + public class FooNullableFilterType + : FilterInputType + { } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorListTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorListTests.cs index 71c805d79a4..424fbb94c05 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorListTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorListTests.cs @@ -7,14 +7,14 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbFilterVisitorListTests + : SchemaCache + , IClassFixture { - public class MongoDbFilterVisitorListTests - : SchemaCache - , IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { FooNested = new[] @@ -64,8 +64,8 @@ public class MongoDbFilterVisitorListTests new Foo { FooNested = new FooNested[0] } }; - private static readonly FooSimple[] _fooSimple = new[] - { + private static readonly FooSimple[] _fooSimple = new[] + { new FooSimple { Bar = new[] @@ -115,23 +115,23 @@ public class MongoDbFilterVisitorListTests new FooSimple { Bar = new string[0] } }; - public MongoDbFilterVisitorListTests(MongoResource resource) - { - Init(resource); - } + public MongoDbFilterVisitorListTests(MongoResource resource) + { + Init(resource); + } - [Fact] - public async Task Create_ArraySomeObjectStringEqualWithNull_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - @"{ + [Fact] + public async Task Create_ArraySomeObjectStringEqualWithNull_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + @"{ root(where: { fooNested: { some: { @@ -146,135 +146,135 @@ public async Task Create_ArraySomeObjectStringEqualWithNull_Expression() } } }") - .Create()); + .Create()); - res1.MatchDocumentSnapshot("a"); + res1.MatchDocumentSnapshot("a"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { fooNested: { some: {bar: { eq: \"d\"}}}}){ fooNested {bar}}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { fooNested: { some: {bar: { eq: \"d\"}}}}){ fooNested {bar}}}") + .Create()); - res2.MatchDocumentSnapshot("d"); + res2.MatchDocumentSnapshot("d"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { fooNested: { some: {bar: { eq: null}}}}){ fooNested {bar}}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { fooNested: { some: {bar: { eq: null}}}}){ fooNested {bar}}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_ArrayNoneObjectStringEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { fooNested: { none: {bar: { eq: \"a\"}}}}){ fooNested {bar}}}") - .Create()); - - res1.MatchDocumentSnapshot("a"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { fooNested: { none: {bar: { eq: \"d\"}}}}){ fooNested {bar}}}") - .Create()); - - res2.MatchDocumentSnapshot("d"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { fooNested: { none: {bar: { eq: null}}}}){ fooNested {bar}}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } + [Fact] + public async Task Create_ArrayNoneObjectStringEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { fooNested: { none: {bar: { eq: \"a\"}}}}){ fooNested {bar}}}") + .Create()); + + res1.MatchDocumentSnapshot("a"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { fooNested: { none: {bar: { eq: \"d\"}}}}){ fooNested {bar}}}") + .Create()); + + res2.MatchDocumentSnapshot("d"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { fooNested: { none: {bar: { eq: null}}}}){ fooNested {bar}}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_ArrayAllObjectStringEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { fooNested: { all: {bar: { eq: \"a\"}}}}){ fooNested {bar}}}") - .Create()); - - res1.MatchDocumentSnapshot("a"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { fooNested: { all: {bar: { eq: \"d\"}}}}){ fooNested {bar}}}") - .Create()); - - res2.MatchDocumentSnapshot("d"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { fooNested: { all: {bar: { eq: null}}}}){ fooNested {bar}}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } + [Fact] + public async Task Create_ArrayAllObjectStringEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { fooNested: { all: {bar: { eq: \"a\"}}}}){ fooNested {bar}}}") + .Create()); + + res1.MatchDocumentSnapshot("a"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { fooNested: { all: {bar: { eq: \"d\"}}}}){ fooNested {bar}}}") + .Create()); + + res2.MatchDocumentSnapshot("d"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { fooNested: { all: {bar: { eq: null}}}}){ fooNested {bar}}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_ArrayAnyObjectStringEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_ArrayAnyObjectStringEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { fooNested: { any: false}}){ fooNested {bar}}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { fooNested: { any: false}}){ fooNested {bar}}}") + .Create()); - res1.MatchDocumentSnapshot("false"); + res1.MatchDocumentSnapshot("false"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { fooNested: { any: true}}){ fooNested {bar}}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { fooNested: { any: true}}){ fooNested {bar}}}") + .Create()); - res2.MatchDocumentSnapshot("true"); + res2.MatchDocumentSnapshot("true"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { fooNested: { all: null}}){ fooNested {bar}}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { fooNested: { all: null}}){ fooNested {bar}}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_ArraySomeStringEqualWithNull_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooSimple); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - @"{ + [Fact] + public async Task Create_ArraySomeStringEqualWithNull_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooSimple); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + @"{ root(where: { bar: { some: { @@ -285,163 +285,162 @@ public async Task Create_ArraySomeStringEqualWithNull_Expression() bar } }") - .Create()); + .Create()); - res1.MatchDocumentSnapshot("a"); + res1.MatchDocumentSnapshot("a"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { some: { eq: \"d\"}}}){ bar }}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { some: { eq: \"d\"}}}){ bar }}") + .Create()); - res2.MatchDocumentSnapshot("d"); + res2.MatchDocumentSnapshot("d"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { some: { eq: null}}}){ bar }}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { some: { eq: null}}}){ bar }}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_ArrayNoneStringEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooSimple); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { none: { eq: \"a\"}}}){ bar }}") - .Create()); - - res1.MatchDocumentSnapshot("a"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { none: { eq: \"d\"}}}){ bar }}") - .Create()); - - res2.MatchDocumentSnapshot("d"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { none: { eq: null}}}){ bar }}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } + [Fact] + public async Task Create_ArrayNoneStringEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooSimple); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { none: { eq: \"a\"}}}){ bar }}") + .Create()); + + res1.MatchDocumentSnapshot("a"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { none: { eq: \"d\"}}}){ bar }}") + .Create()); + + res2.MatchDocumentSnapshot("d"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { none: { eq: null}}}){ bar }}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_ArrayAllStringEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooSimple); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { all: { eq: \"a\"}}}){ bar }}") - .Create()); - - res1.MatchDocumentSnapshot("a"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { all: { eq: \"d\"}}}){ bar }}") - .Create()); - - res2.MatchDocumentSnapshot("d"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { all: { eq: null}}}){ bar }}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } + [Fact] + public async Task Create_ArrayAllStringEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooSimple); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { all: { eq: \"a\"}}}){ bar }}") + .Create()); + + res1.MatchDocumentSnapshot("a"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { all: { eq: \"d\"}}}){ bar }}") + .Create()); + + res2.MatchDocumentSnapshot("d"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { all: { eq: null}}}){ bar }}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_ArrayAnyStringEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooSimple); + [Fact] + public async Task Create_ArrayAnyStringEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooSimple); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { any: false}}){ bar }}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { any: false}}){ bar }}") + .Create()); - res1.MatchDocumentSnapshot("false"); + res1.MatchDocumentSnapshot("false"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { any: true}}){ bar }}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { any: true}}){ bar }}") + .Create()); - res2.MatchDocumentSnapshot("true"); + res2.MatchDocumentSnapshot("true"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { all: null}}){ bar }}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { all: null}}){ bar }}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public IEnumerable? FooNested { get; set; } - } + public IEnumerable? FooNested { get; set; } + } - public class FooSimple - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class FooSimple + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public IEnumerable? Bar { get; set; } - } + public IEnumerable? Bar { get; set; } + } - public class FooNested - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class FooNested + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public string? Bar { get; set; } - } + public string? Bar { get; set; } + } - public class FooFilterType - : FilterInputType + public class FooFilterType + : FilterInputType + { + protected override void Configure(IFilterInputTypeDescriptor descriptor) { - protected override void Configure(IFilterInputTypeDescriptor descriptor) - { - descriptor.Field(t => t.FooNested); - } + descriptor.Field(t => t.FooNested); } + } - public class FooSimpleFilterType - : FilterInputType + public class FooSimpleFilterType + : FilterInputType + { + protected override void Configure(IFilterInputTypeDescriptor descriptor) { - protected override void Configure(IFilterInputTypeDescriptor descriptor) - { - descriptor.Field(t => t.Bar); - } + descriptor.Field(t => t.Bar); } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorObjectIdTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorObjectIdTests.cs index 38a5e3ba49c..74d6fb048d9 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorObjectIdTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorObjectIdTests.cs @@ -7,875 +7,874 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbFilterVisitorObjectIdTests + : SchemaCache + , IClassFixture { - public class MongoDbFilterVisitorObjectIdTests - : SchemaCache - , IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new() { ObjectId = new ObjectId("6124e80f3f5fc839830c1f69") }, new() { ObjectId = new ObjectId("6124e80f3f5fc839830c1f6a") }, new() { ObjectId = new ObjectId("6124e80f3f5fc839830c1f6b") } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new() { ObjectId = new ObjectId("6124e80f3f5fc839830c1f69") }, new() { }, new() { ObjectId = new ObjectId("6124e80f3f5fc839830c1f6a") }, new() { ObjectId = new ObjectId("6124e80f3f5fc839830c1f6b") } }; - public MongoDbFilterVisitorObjectIdTests(MongoResource resource) - { - Init(resource); - } + public MongoDbFilterVisitorObjectIdTests(MongoResource resource) + { + Init(resource); + } - [Fact] - public async Task Create_ObjectIdEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { eq: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); - - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { eq: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); - - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { eq: null}}){ objectId}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ObjectIdNotEqual_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_ObjectIdEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { neq: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); - - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { eq: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { neq: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { eq: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { neq: null}}){ objectId}}") - .Create()); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - res3.MatchDocumentSnapshot("null"); - } + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { eq: null}}){ objectId}}") + .Create()); - [Fact] - public async Task Create_ObjectIdGreaterThan_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + res3.MatchDocumentSnapshot("null"); + } - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + [Fact] + public async Task Create_ObjectIdNotEqual_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { neq: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); - - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { neq: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gt: null}}){ objectId}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { neq: null}}){ objectId}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_ObjectIdNotGreaterThan_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_ObjectIdGreaterThan_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngt: null}}){ objectId}}") - .Create()); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gt: null}}){ objectId}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } + res4.MatchDocumentSnapshot("null"); + } + [Fact] + public async Task Create_ObjectIdNotGreaterThan_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - [Fact] - public async Task Create_ObjectIdGreaterThanOrEquals_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngt: null}}){ objectId}}") + .Create()); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gte: null}}){ objectId}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res4.MatchDocumentSnapshot("null"); - } - [Fact] - public async Task Create_ObjectIdNotGreaterThanOrEquals_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_ObjectIdGreaterThanOrEquals_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngte: null}}){ objectId}}") - .Create()); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gte: null}}){ objectId}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } + res4.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_ObjectIdLowerThan_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_ObjectIdNotGreaterThanOrEquals_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lt: null}}){ objectId}}") - .Create()); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngte: null}}){ objectId}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } + res4.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_ObjectIdNotLowerThan_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_ObjectIdLowerThan_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlt: null}}){ objectId}}") - .Create()); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lt: null}}){ objectId}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } + res4.MatchDocumentSnapshot("null"); + } + [Fact] + public async Task Create_ObjectIdNotLowerThan_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - [Fact] - public async Task Create_ObjectIdLowerThanOrEquals_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlt: null}}){ objectId}}") + .Create()); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lte: null}}){ objectId}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res4.MatchDocumentSnapshot("null"); - } - [Fact] - public async Task Create_ObjectIdNotLowerThanOrEquals_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_ObjectIdLowerThanOrEquals_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlte: null}}){ objectId}}") - .Create()); - - res4.MatchDocumentSnapshot("null"); - } + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lte: null}}){ objectId}}") + .Create()); - [Fact] - public async Task Create_ObjectIdIn_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + res4.MatchDocumentSnapshot("null"); + } - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { in: [ \"6124e80f3f5fc839830c1f69\", \"6124e80f3f5fc839830c1f6a\" ]}}){ objectId}}") - .Create()); + [Fact] + public async Task Create_ObjectIdNotLowerThanOrEquals_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69and6124e80f3f5fc839830c1f6a"); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { in: [ null, \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") - .Create()); + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69"); - res2.MatchDocumentSnapshot("band6124e80f3f5fc839830c1f6b"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { in: [ null, \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") - .Create()); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - res3.MatchDocumentSnapshot("nullAnd6124e80f3f5fc839830c1f6b"); - } + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - [Fact] - public async Task Create_ObjectIdNotIn_Expression() - { - IRequestExecutor tester = CreateSchema(_fooEntities); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nin: [ \"6124e80f3f5fc839830c1f69\", \"6124e80f3f5fc839830c1f6a\" ]}}){ objectId}}") - .Create()); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlte: null}}){ objectId}}") + .Create()); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69and6124e80f3f5fc839830c1f6a"); + res4.MatchDocumentSnapshot("null"); + } - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nin: [ null, \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") - .Create()); + [Fact] + public async Task Create_ObjectIdIn_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - res2.MatchDocumentSnapshot("band6124e80f3f5fc839830c1f6b"); + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { in: [ \"6124e80f3f5fc839830c1f69\", \"6124e80f3f5fc839830c1f6a\" ]}}){ objectId}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nin: [ null, \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") - .Create()); + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69and6124e80f3f5fc839830c1f6a"); - res3.MatchDocumentSnapshot("nullAnd6124e80f3f5fc839830c1f6b"); - } + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { in: [ null, \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") + .Create()); - [Fact] - public async Task Create_ObjectIdNullableEqual_Expression() - { - // arrange - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + res2.MatchDocumentSnapshot("band6124e80f3f5fc839830c1f6b"); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { eq: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { in: [ null, \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") + .Create()); - res1.MatchDocumentSnapshot("a"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { eq: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + res3.MatchDocumentSnapshot("nullAnd6124e80f3f5fc839830c1f6b"); + } - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + [Fact] + public async Task Create_ObjectIdNotIn_Expression() + { + IRequestExecutor tester = CreateSchema(_fooEntities); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { eq: null}}){ objectId}}") - .Create()); + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nin: [ \"6124e80f3f5fc839830c1f69\", \"6124e80f3f5fc839830c1f6a\" ]}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69and6124e80f3f5fc839830c1f6a"); - [Fact] - public async Task Create_ObjectIdNullableNotEqual_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nin: [ null, \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { neq: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + res2.MatchDocumentSnapshot("band6124e80f3f5fc839830c1f6b"); - res1.MatchDocumentSnapshot("a"); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nin: [ null, \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { neq: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + res3.MatchDocumentSnapshot("nullAnd6124e80f3f5fc839830c1f6b"); + } - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + [Fact] + public async Task Create_ObjectIdNullableEqual_Expression() + { + // arrange + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { neq: null}}){ objectId}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { eq: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res1.MatchDocumentSnapshot("a"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { eq: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - [Fact] - public async Task Create_ObjectIdNullableGreaterThan_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { eq: null}}){ objectId}}") + .Create()); - res1.MatchDocumentSnapshot("a"); + res3.MatchDocumentSnapshot("null"); + } - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + [Fact] + public async Task Create_ObjectIdNullableNotEqual_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { neq: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gt: null}}){ objectId}}") - .Create()); + res1.MatchDocumentSnapshot("a"); - res4.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ObjectIdNullableNotGreaterThan_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { neq: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - res1.MatchDocumentSnapshot("a"); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { neq: null}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + res3.MatchDocumentSnapshot("null"); + } - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + [Fact] + public async Task Create_ObjectIdNullableGreaterThan_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngt: null}}){ objectId}}") - .Create()); + res1.MatchDocumentSnapshot("a"); - res4.MatchDocumentSnapshot("null"); - } + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - [Fact] - public async Task Create_ObjectIdNullableGreaterThanOrEquals_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - res1.MatchDocumentSnapshot("a"); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gt: null}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); - - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { gte: null}}){ objectId}}") - .Create()); + [Fact] + public async Task Create_ObjectIdNullableNotGreaterThan_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - res4.MatchDocumentSnapshot("null"); - } + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - [Fact] - public async Task Create_ObjectIdNullableNotGreaterThanOrEquals_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + res1.MatchDocumentSnapshot("a"); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - res1.MatchDocumentSnapshot("a"); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngt: null}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + res4.MatchDocumentSnapshot("null"); + } - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { ngte: null}}){ objectId}}") - .Create()); - res4.MatchDocumentSnapshot("null"); - } + [Fact] + public async Task Create_ObjectIdNullableGreaterThanOrEquals_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - [Fact] - public async Task Create_ObjectIdNullableLowerThan_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + res1.MatchDocumentSnapshot("a"); - res1.MatchDocumentSnapshot("a"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); - - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lt: null}}){ objectId}}") - .Create()); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - res4.MatchDocumentSnapshot("null"); - } + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { gte: null}}){ objectId}}") + .Create()); - [Fact] - public async Task Create_ObjectIdNullableNotLowerThan_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + res4.MatchDocumentSnapshot("null"); + } - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + [Fact] + public async Task Create_ObjectIdNullableNotGreaterThanOrEquals_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - res1.MatchDocumentSnapshot("a"); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); - - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); - - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlt: null}}){ objectId}}") - .Create()); + res1.MatchDocumentSnapshot("a"); - res4.MatchDocumentSnapshot("null"); - } + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - [Fact] - public async Task Create_ObjectIdNullableLowerThanOrEquals_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - res1.MatchDocumentSnapshot("a"); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { ngte: null}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + [Fact] + public async Task Create_ObjectIdNullableLowerThan_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + res1.MatchDocumentSnapshot("a"); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { lte: null}}){ objectId}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - res4.MatchDocumentSnapshot("null"); - } + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - [Fact] - public async Task Create_ObjectIdNullableNotLowerThanOrEquals_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") - .Create()); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - res1.MatchDocumentSnapshot("a"); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lt: null}}){ objectId}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + [Fact] + public async Task Create_ObjectIdNullableNotLowerThan_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") - .Create()); - - res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - IExecutionResult res4 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nlte: null}}){ objectId}}") - .Create()); + res1.MatchDocumentSnapshot("a"); - res4.MatchDocumentSnapshot("null"); - } + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - [Fact] - public async Task Create_ObjectIdNullableIn_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { in: [ \"6124e80f3f5fc839830c1f69\", \"6124e80f3f5fc839830c1f6a\" ]}}){ objectId}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlt: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69and6124e80f3f5fc839830c1f6a"); + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { in: [ \"6124e80f3f5fc839830c1f6a\", \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") - .Create()); - - res2.MatchDocumentSnapshot("band6124e80f3f5fc839830c1f6b"); + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlt: null}}){ objectId}}") + .Create()); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { in: [ \"6124e80f3f5fc839830c1f6a\", null ]}}){ objectId}}") - .Create()); + res4.MatchDocumentSnapshot("null"); + } - res3.MatchDocumentSnapshot("bandNull"); - } - - [Fact] - public async Task Create_ObjectIdNullableNotIn_Expression() - { - IRequestExecutor tester = - CreateSchema(_fooNullableEntities); - - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nin: [ \"6124e80f3f5fc839830c1f69\", \"6124e80f3f5fc839830c1f6a\" ]}}){ objectId}}") - .Create()); - res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69and6124e80f3f5fc839830c1f6a"); + [Fact] + public async Task Create_ObjectIdNullableLowerThanOrEquals_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nin: [ \"6124e80f3f5fc839830c1f6a\", \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); - res2.MatchDocumentSnapshot("band6124e80f3f5fc839830c1f6b"); + res1.MatchDocumentSnapshot("a"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { objectId: { nin: [ \"6124e80f3f5fc839830c1f6a\", null ]}}){ objectId}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); - res3.MatchDocumentSnapshot("bandNull"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public ObjectId ObjectId { get; set; } - } - - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); - public ObjectId? ObjectId { get; set; } - } + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); - public class FooFilterType - : FilterInputType - { - } + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); - public class FooNullableFilterType - : FilterInputType - { - } + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { lte: null}}){ objectId}}") + .Create()); + + res4.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ObjectIdNullableNotLowerThanOrEquals_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f69\"}}){ objectId}}") + .Create()); + + res1.MatchDocumentSnapshot("a"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f6a\"}}){ objectId}}") + .Create()); + + res2.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6a"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlte: \"6124e80f3f5fc839830c1f6b\"}}){ objectId}}") + .Create()); + + res3.MatchDocumentSnapshot("6124e80f3f5fc839830c1f6b"); + + IExecutionResult res4 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nlte: null}}){ objectId}}") + .Create()); + + res4.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ObjectIdNullableIn_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); + + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { in: [ \"6124e80f3f5fc839830c1f69\", \"6124e80f3f5fc839830c1f6a\" ]}}){ objectId}}") + .Create()); + + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69and6124e80f3f5fc839830c1f6a"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { in: [ \"6124e80f3f5fc839830c1f6a\", \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") + .Create()); + + res2.MatchDocumentSnapshot("band6124e80f3f5fc839830c1f6b"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { in: [ \"6124e80f3f5fc839830c1f6a\", null ]}}){ objectId}}") + .Create()); + + res3.MatchDocumentSnapshot("bandNull"); + } + + [Fact] + public async Task Create_ObjectIdNullableNotIn_Expression() + { + IRequestExecutor tester = + CreateSchema(_fooNullableEntities); + + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nin: [ \"6124e80f3f5fc839830c1f69\", \"6124e80f3f5fc839830c1f6a\" ]}}){ objectId}}") + .Create()); + + res1.MatchDocumentSnapshot("6124e80f3f5fc839830c1f69and6124e80f3f5fc839830c1f6a"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nin: [ \"6124e80f3f5fc839830c1f6a\", \"6124e80f3f5fc839830c1f6b\" ]}}){ objectId}}") + .Create()); + + res2.MatchDocumentSnapshot("band6124e80f3f5fc839830c1f6b"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { objectId: { nin: [ \"6124e80f3f5fc839830c1f6a\", null ]}}){ objectId}}") + .Create()); + + res3.MatchDocumentSnapshot("bandNull"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public ObjectId ObjectId { get; set; } + } + + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public ObjectId? ObjectId { get; set; } + } + + public class FooFilterType + : FilterInputType + { + } + + public class FooNullableFilterType + : FilterInputType + { } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorObjectTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorObjectTests.cs index 6e86096c9b4..db97a5b69fd 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorObjectTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorObjectTests.cs @@ -7,14 +7,14 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbFilterVisitorObjectTests + : SchemaCache + , IClassFixture { - public class MongoDbFilterVisitorObjectTests - : SchemaCache - , IClassFixture + private static readonly Bar[] _barEntities = { - private static readonly Bar[] _barEntities = - { new Bar { Foo = new Foo @@ -57,8 +57,8 @@ public class MongoDbFilterVisitorObjectTests } }; - private static readonly BarNullable[] _barNullableEntities = - { + private static readonly BarNullable[] _barNullableEntities = + { new BarNullable { Foo = new FooNullable @@ -114,568 +114,567 @@ public class MongoDbFilterVisitorObjectTests } }; - public MongoDbFilterVisitorObjectTests(MongoResource resource) - { - Init(resource); - } - - [Fact] - public async Task Create_ObjectShortEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { eq: 12}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res1.MatchDocumentSnapshot("12"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { eq: 13}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res2.MatchDocumentSnapshot("13"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { eq: null}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ObjectShortIn_Expression() - { - IRequestExecutor tester = CreateSchema(_barEntities); - - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { in: [ 12, 13 ]}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res1.MatchDocumentSnapshot("12and13"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { in: [ null, 14 ]}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res2.MatchDocumentSnapshot("13and14"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { in: [ null, 14 ]}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res3.MatchDocumentSnapshot("nullAnd14"); - } - - [Fact] - public async Task Create_ObjectNullableShortEqual_Expression() - { - // arrange - IRequestExecutor tester = - CreateSchema(_barNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { eq: 12}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res1.MatchDocumentSnapshot("12"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { eq: 13}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res2.MatchDocumentSnapshot("13"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { eq: null}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ObjectNullableShortIn_Expression() - { - IRequestExecutor tester = - CreateSchema(_barNullableEntities); - - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { in: [ 12, 13 ]}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res1.MatchDocumentSnapshot("12and13"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { in: [ 13, 14 ]}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res2.MatchDocumentSnapshot("13and14"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barShort: { in: [ 13, null ]}}}) " + - "{ foo{ barShort}}}") - .Create()); - - res3.MatchDocumentSnapshot("13andNull"); - } - - [Fact] - public async Task Create_ObjectBooleanEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barBool: { eq: true}}}) " + - "{ foo{ barBool}}}") - .Create()); - - res1.MatchDocumentSnapshot("true"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barBool: { eq: false}}}) " + - "{ foo{ barBool}}}") - .Create()); - - res2.MatchDocumentSnapshot("false"); - } - - [Fact] - public async Task Create_ObjectNullableBooleanEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _barNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barBool: { eq: true}}}) " + - "{ foo{ barBool}}}") - .Create()); - - res1.MatchDocumentSnapshot("true"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barBool: { eq: false}}}) " + - "{ foo{ barBool}}}") - .Create()); - - res2.MatchDocumentSnapshot("false"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barBool: { eq: null}}}) " + - "{ foo{ barBool}}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ObjectEnumEqual_Expression() - { - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { eq: BAR}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res1.MatchDocumentSnapshot("BAR"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { eq: FOO}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { eq: null}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ObjectEnumIn_Expression() - { - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { in: [ BAR FOO ]}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res1.MatchDocumentSnapshot("BarAndFoo"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { in: [ FOO ]}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { in: [ null FOO ]}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res3.MatchDocumentSnapshot("nullAndFoo"); - } - - [Fact] - public async Task Create_ObjectNullableEnumEqual_Expression() - { - IRequestExecutor tester = CreateSchema( - _barNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { eq: BAR}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res1.MatchDocumentSnapshot("BAR"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { eq: FOO}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { eq: null}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ObjectNullableEnumIn_Expression() - { - IRequestExecutor tester = CreateSchema( - _barNullableEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { in: [ BAR FOO ]}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res1.MatchDocumentSnapshot("BarAndFoo"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { in: [ FOO ]}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res2.MatchDocumentSnapshot("FOO"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barEnum: { in: [ null FOO ]}}}) " + - "{ foo{ barEnum}}}") - .Create()); - - res3.MatchDocumentSnapshot("nullAndFoo"); - } - - [Fact] - public async Task Create_ObjectStringEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barString: { eq: \"testatest\"}}}) " + - "{ foo{ barString}}}") - .Create()); - - res1.MatchDocumentSnapshot("testatest"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barString: { eq: \"testbtest\"}}}) " + - "{ foo{ barString}}}") - .Create()); - - res2.MatchDocumentSnapshot("testbtest"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barString: { eq: null}}}){ foo{ barString}}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ObjectStringIn_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barString: { in: " + - "[ \"testatest\" \"testbtest\" ]}}}) " + - "{ foo{ barString}}}") - .Create()); - - res1.MatchDocumentSnapshot("testatestAndtestb"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barString: { in: [\"testbtest\" null]}}}) " + - "{ foo{ barString}}}") - .Create()); - - res2.MatchDocumentSnapshot("testbtestAndNull"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { barString: { in: [ \"testatest\" ]}}}) " + - "{ foo{ barString}}}") - .Create()); - - res3.MatchDocumentSnapshot("testatest"); - } - - [Fact] - public async Task Create_ArrayObjectNestedArraySomeStringEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo:{ objectArray: { " + - "some: { foo: { barString: { eq: \"a\"}}}}}}) " + - "{ foo { objectArray { foo { barString}}}}}") - .Create()); - - res1.MatchDocumentSnapshot("a"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo:{ objectArray: { " + - "some: { foo: { barString: { eq: \"d\"}}}}}}) " + - "{ foo { objectArray { foo { barString}}}}}") - .Create()); - - res2.MatchDocumentSnapshot("d"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo:{ objectArray: { " + - "some: { foo: { barString: { eq: null}}}}}}) " + - "{ foo { objectArray { foo {barString}}}}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - [Fact] - public async Task Create_ArrayObjectNestedArrayAnyStringEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { objectArray: { any: false}}}) " + - "{ foo { objectArray { foo { barString }}}}}") - .Create()); - - res1.MatchDocumentSnapshot("false"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { objectArray: { any: true}}}) " + - "{ foo { objectArray { foo { barString }}}}}") - .Create()); - - res2.MatchDocumentSnapshot("true"); - - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { foo: { objectArray: { any: null}}}) " + - "{ foo { objectArray { foo { barString }}}}}") - .Create()); - - res3.MatchDocumentSnapshot("null"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public short BarShort { get; set; } - - public string BarString { get; set; } = string.Empty; - - public BarEnum BarEnum { get; set; } - - public bool BarBool { get; set; } - - public List? ObjectArray { get; set; } = null!; - } - - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public short? BarShort { get; set; } - - public string? BarString { get; set; } - - public BarEnum? BarEnum { get; set; } - - public bool? BarBool { get; set; } - - public List? ObjectArray { get; set; } - } - - public class Bar - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public Foo Foo { get; set; } = null!; - } + public MongoDbFilterVisitorObjectTests(MongoResource resource) + { + Init(resource); + } + + [Fact] + public async Task Create_ObjectShortEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { eq: 12}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res1.MatchDocumentSnapshot("12"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { eq: 13}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res2.MatchDocumentSnapshot("13"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { eq: null}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ObjectShortIn_Expression() + { + IRequestExecutor tester = CreateSchema(_barEntities); + + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { in: [ 12, 13 ]}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res1.MatchDocumentSnapshot("12and13"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { in: [ null, 14 ]}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res2.MatchDocumentSnapshot("13and14"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { in: [ null, 14 ]}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res3.MatchDocumentSnapshot("nullAnd14"); + } + + [Fact] + public async Task Create_ObjectNullableShortEqual_Expression() + { + // arrange + IRequestExecutor tester = + CreateSchema(_barNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { eq: 12}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res1.MatchDocumentSnapshot("12"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { eq: 13}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res2.MatchDocumentSnapshot("13"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { eq: null}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ObjectNullableShortIn_Expression() + { + IRequestExecutor tester = + CreateSchema(_barNullableEntities); + + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { in: [ 12, 13 ]}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res1.MatchDocumentSnapshot("12and13"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { in: [ 13, 14 ]}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res2.MatchDocumentSnapshot("13and14"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barShort: { in: [ 13, null ]}}}) " + + "{ foo{ barShort}}}") + .Create()); + + res3.MatchDocumentSnapshot("13andNull"); + } + + [Fact] + public async Task Create_ObjectBooleanEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barBool: { eq: true}}}) " + + "{ foo{ barBool}}}") + .Create()); + + res1.MatchDocumentSnapshot("true"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barBool: { eq: false}}}) " + + "{ foo{ barBool}}}") + .Create()); + + res2.MatchDocumentSnapshot("false"); + } + + [Fact] + public async Task Create_ObjectNullableBooleanEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _barNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barBool: { eq: true}}}) " + + "{ foo{ barBool}}}") + .Create()); + + res1.MatchDocumentSnapshot("true"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barBool: { eq: false}}}) " + + "{ foo{ barBool}}}") + .Create()); + + res2.MatchDocumentSnapshot("false"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barBool: { eq: null}}}) " + + "{ foo{ barBool}}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ObjectEnumEqual_Expression() + { + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { eq: BAR}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res1.MatchDocumentSnapshot("BAR"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { eq: FOO}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { eq: null}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ObjectEnumIn_Expression() + { + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { in: [ BAR FOO ]}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res1.MatchDocumentSnapshot("BarAndFoo"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { in: [ FOO ]}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { in: [ null FOO ]}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res3.MatchDocumentSnapshot("nullAndFoo"); + } + + [Fact] + public async Task Create_ObjectNullableEnumEqual_Expression() + { + IRequestExecutor tester = CreateSchema( + _barNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { eq: BAR}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res1.MatchDocumentSnapshot("BAR"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { eq: FOO}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { eq: null}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ObjectNullableEnumIn_Expression() + { + IRequestExecutor tester = CreateSchema( + _barNullableEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { in: [ BAR FOO ]}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res1.MatchDocumentSnapshot("BarAndFoo"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { in: [ FOO ]}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res2.MatchDocumentSnapshot("FOO"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barEnum: { in: [ null FOO ]}}}) " + + "{ foo{ barEnum}}}") + .Create()); + + res3.MatchDocumentSnapshot("nullAndFoo"); + } + + [Fact] + public async Task Create_ObjectStringEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barString: { eq: \"testatest\"}}}) " + + "{ foo{ barString}}}") + .Create()); + + res1.MatchDocumentSnapshot("testatest"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barString: { eq: \"testbtest\"}}}) " + + "{ foo{ barString}}}") + .Create()); + + res2.MatchDocumentSnapshot("testbtest"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barString: { eq: null}}}){ foo{ barString}}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ObjectStringIn_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barString: { in: " + + "[ \"testatest\" \"testbtest\" ]}}}) " + + "{ foo{ barString}}}") + .Create()); + + res1.MatchDocumentSnapshot("testatestAndtestb"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barString: { in: [\"testbtest\" null]}}}) " + + "{ foo{ barString}}}") + .Create()); + + res2.MatchDocumentSnapshot("testbtestAndNull"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { barString: { in: [ \"testatest\" ]}}}) " + + "{ foo{ barString}}}") + .Create()); + + res3.MatchDocumentSnapshot("testatest"); + } + + [Fact] + public async Task Create_ArrayObjectNestedArraySomeStringEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo:{ objectArray: { " + + "some: { foo: { barString: { eq: \"a\"}}}}}}) " + + "{ foo { objectArray { foo { barString}}}}}") + .Create()); + + res1.MatchDocumentSnapshot("a"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo:{ objectArray: { " + + "some: { foo: { barString: { eq: \"d\"}}}}}}) " + + "{ foo { objectArray { foo { barString}}}}}") + .Create()); + + res2.MatchDocumentSnapshot("d"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo:{ objectArray: { " + + "some: { foo: { barString: { eq: null}}}}}}) " + + "{ foo { objectArray { foo {barString}}}}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + [Fact] + public async Task Create_ArrayObjectNestedArrayAnyStringEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { objectArray: { any: false}}}) " + + "{ foo { objectArray { foo { barString }}}}}") + .Create()); + + res1.MatchDocumentSnapshot("false"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { objectArray: { any: true}}}) " + + "{ foo { objectArray { foo { barString }}}}}") + .Create()); + + res2.MatchDocumentSnapshot("true"); + + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { foo: { objectArray: { any: null}}}) " + + "{ foo { objectArray { foo { barString }}}}}") + .Create()); + + res3.MatchDocumentSnapshot("null"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public short BarShort { get; set; } + + public string BarString { get; set; } = string.Empty; + + public BarEnum BarEnum { get; set; } + + public bool BarBool { get; set; } + + public List? ObjectArray { get; set; } = null!; + } + + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public class BarNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public FooNullable? Foo { get; set; } - } + public short? BarShort { get; set; } - public class BarFilterType - : FilterInputType - { - } + public string? BarString { get; set; } - public class BarNullableFilterType - : FilterInputType - { - } + public BarEnum? BarEnum { get; set; } - public enum BarEnum - { - FOO, - BAR, - BAZ, - QUX - } + public bool? BarBool { get; set; } + + public List? ObjectArray { get; set; } + } + + public class Bar + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public Foo Foo { get; set; } = null!; + } + + public class BarNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public FooNullable? Foo { get; set; } + } + + public class BarFilterType + : FilterInputType + { + } + + public class BarNullableFilterType + : FilterInputType + { + } + + public enum BarEnum + { + FOO, + BAR, + BAZ, + QUX } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorStringTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorStringTests.cs index bd84412c4fc..dfd822697de 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorStringTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorStringTests.cs @@ -6,678 +6,677 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbFilterVisitorStringTests + : SchemaCache + , IClassFixture { - public class MongoDbFilterVisitorStringTests - : SchemaCache - , IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = "testatest" }, new Foo { Bar = "testbtest" } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new FooNullable { Bar = "testatest" }, new FooNullable { Bar = "testbtest" }, new FooNullable { Bar = null } }; - public MongoDbFilterVisitorStringTests(MongoResource resource) - { - Init(resource); - } + public MongoDbFilterVisitorStringTests(MongoResource resource) + { + Init(resource); + } - [Fact] - public async Task Create_StringEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_StringEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"testatest\"}}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"testatest\"}}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testatest"); + res1.MatchDocumentSnapshot("testatest"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"testbtest\"}}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"testbtest\"}}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testbtest"); + res2.MatchDocumentSnapshot("testbtest"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: null}}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: null}}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_StringNotEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_StringNotEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"testatest\"}}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"testatest\"}}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testatest"); + res1.MatchDocumentSnapshot("testatest"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"testbtest\"}}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"testbtest\"}}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testbtest"); + res2.MatchDocumentSnapshot("testbtest"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: null}}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: null}}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_StringIn_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_StringIn_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { in: [ \"testatest\" \"testbtest\" ]}}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { in: [ \"testatest\" \"testbtest\" ]}}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testatestAndtestb"); + res1.MatchDocumentSnapshot("testatestAndtestb"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { in: [\"testbtest\" null]}}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { in: [\"testbtest\" null]}}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testbtestAndNull"); + res2.MatchDocumentSnapshot("testbtestAndNull"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { in: [ \"testatest\" ]}}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { in: [ \"testatest\" ]}}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("testatest"); - } + res3.MatchDocumentSnapshot("testatest"); + } - [Fact] - public async Task Create_StringNotIn_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_StringNotIn_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { nin: [ \"testatest\" \"testbtest\" ]}}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { nin: [ \"testatest\" \"testbtest\" ]}}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testatestAndtestb"); + res1.MatchDocumentSnapshot("testatestAndtestb"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nin: [\"testbtest\" null]}}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nin: [\"testbtest\" null]}}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testbtestAndNull"); + res2.MatchDocumentSnapshot("testbtestAndNull"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nin: [ \"testatest\" ]}}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nin: [ \"testatest\" ]}}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("testatest"); - } + res3.MatchDocumentSnapshot("testatest"); + } - [Fact] - public async Task Create_StringContains_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_StringContains_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { contains: \"a\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { contains: \"a\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("a"); + res1.MatchDocumentSnapshot("a"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { contains: \"b\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { contains: \"b\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("b"); + res2.MatchDocumentSnapshot("b"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { contains: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { contains: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_StringNoContains_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_StringNoContains_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { ncontains: \"a\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { ncontains: \"a\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("a"); + res1.MatchDocumentSnapshot("a"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { ncontains: \"b\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { ncontains: \"b\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("b"); + res2.MatchDocumentSnapshot("b"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { ncontains: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { ncontains: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_StringStartsWith_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_StringStartsWith_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { startsWith: \"testa\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { startsWith: \"testa\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testa"); + res1.MatchDocumentSnapshot("testa"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { startsWith: \"testb\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { startsWith: \"testb\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testb"); + res2.MatchDocumentSnapshot("testb"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { startsWith: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { startsWith: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_StringNotStartsWith_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_StringNotStartsWith_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nstartsWith: \"testa\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nstartsWith: \"testa\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testa"); + res1.MatchDocumentSnapshot("testa"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nstartsWith: \"testb\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nstartsWith: \"testb\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testb"); + res2.MatchDocumentSnapshot("testb"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nstartsWith: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nstartsWith: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_StringEndsWith_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_StringEndsWith_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { endsWith: \"atest\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { endsWith: \"atest\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("atest"); + res1.MatchDocumentSnapshot("atest"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { endsWith: \"btest\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { endsWith: \"btest\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("btest"); + res2.MatchDocumentSnapshot("btest"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { endsWith: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { endsWith: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_StringNotEndsWith_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_StringNotEndsWith_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nendsWith: \"atest\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nendsWith: \"atest\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("atest"); + res1.MatchDocumentSnapshot("atest"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nendsWith: \"btest\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nendsWith: \"btest\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("btest"); + res2.MatchDocumentSnapshot("btest"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nendsWith: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nendsWith: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_NullableStringEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableStringEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"testatest\"}}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"testatest\"}}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testatest"); + res1.MatchDocumentSnapshot("testatest"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"testbtest\"}}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"testbtest\"}}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testbtest"); + res2.MatchDocumentSnapshot("testbtest"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: null}}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: null}}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_NullableStringNotEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableStringNotEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"testatest\"}}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"testatest\"}}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testatest"); + res1.MatchDocumentSnapshot("testatest"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"testbtest\"}}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"testbtest\"}}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testbtest"); + res2.MatchDocumentSnapshot("testbtest"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: null}}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: null}}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_NullableStringIn_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableStringIn_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { in: [ \"testatest\" \"testbtest\" ]}}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { in: [ \"testatest\" \"testbtest\" ]}}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testatestAndtestb"); + res1.MatchDocumentSnapshot("testatestAndtestb"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { in: [\"testbtest\" null]}}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { in: [\"testbtest\" null]}}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testbtestAndNull"); + res2.MatchDocumentSnapshot("testbtestAndNull"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { in: [ \"testatest\" ]}}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { in: [ \"testatest\" ]}}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("testatest"); - } + res3.MatchDocumentSnapshot("testatest"); + } - [Fact] - public async Task Create_NullableStringNotIn_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableStringNotIn_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(where: { bar: { nin: [ \"testatest\" \"testbtest\" ]}}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(where: { bar: { nin: [ \"testatest\" \"testbtest\" ]}}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testatestAndtestb"); + res1.MatchDocumentSnapshot("testatestAndtestb"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nin: [\"testbtest\" null]}}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nin: [\"testbtest\" null]}}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testbtestAndNull"); + res2.MatchDocumentSnapshot("testbtestAndNull"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nin: [ \"testatest\" ]}}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nin: [ \"testatest\" ]}}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("testatest"); - } + res3.MatchDocumentSnapshot("testatest"); + } - [Fact] - public async Task Create_NullableStringContains_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableStringContains_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { contains: \"a\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { contains: \"a\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("a"); + res1.MatchDocumentSnapshot("a"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { contains: \"b\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { contains: \"b\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("b"); + res2.MatchDocumentSnapshot("b"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { contains: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { contains: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_NullableStringNoContains_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableStringNoContains_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { ncontains: \"a\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { ncontains: \"a\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("a"); + res1.MatchDocumentSnapshot("a"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { ncontains: \"b\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { ncontains: \"b\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("b"); + res2.MatchDocumentSnapshot("b"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { ncontains: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { ncontains: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_NullableStringStartsWith_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableStringStartsWith_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { startsWith: \"testa\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { startsWith: \"testa\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testa"); + res1.MatchDocumentSnapshot("testa"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { startsWith: \"testb\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { startsWith: \"testb\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testb"); + res2.MatchDocumentSnapshot("testb"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { startsWith: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { startsWith: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_NullableStringNotStartsWith_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableStringNotStartsWith_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nstartsWith: \"testa\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nstartsWith: \"testa\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("testa"); + res1.MatchDocumentSnapshot("testa"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nstartsWith: \"testb\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nstartsWith: \"testb\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("testb"); + res2.MatchDocumentSnapshot("testb"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nstartsWith: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nstartsWith: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_NullableStringEndsWith_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableStringEndsWith_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { endsWith: \"atest\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { endsWith: \"atest\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("atest"); + res1.MatchDocumentSnapshot("atest"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { endsWith: \"btest\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { endsWith: \"btest\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("btest"); + res2.MatchDocumentSnapshot("btest"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { endsWith: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { endsWith: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_NullableStringNotEndsWith_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableStringNotEndsWith_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nendsWith: \"atest\" }}){ bar}}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nendsWith: \"atest\" }}){ bar}}") + .Create()); - res1.MatchDocumentSnapshot("atest"); + res1.MatchDocumentSnapshot("atest"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nendsWith: \"btest\" }}){ bar}}") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nendsWith: \"btest\" }}){ bar}}") + .Create()); - res2.MatchDocumentSnapshot("btest"); + res2.MatchDocumentSnapshot("btest"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { nendsWith: null }}){ bar}}") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { nendsWith: null }}){ bar}}") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public string Bar { get; set; } = null!; - } + public string Bar { get; set; } = null!; + } - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public string? Bar { get; set; } - } + public string? Bar { get; set; } + } - public class FooFilterType - : FilterInputType + public class FooFilterType + : FilterInputType + { + protected override void Configure( + IFilterInputTypeDescriptor descriptor) { - protected override void Configure( - IFilterInputTypeDescriptor descriptor) - { - descriptor.Field(t => t.Bar); - } + descriptor.Field(t => t.Bar); } + } - public class FooNullableFilterType - : FilterInputType + public class FooNullableFilterType + : FilterInputType + { + protected override void Configure( + IFilterInputTypeDescriptor descriptor) { - protected override void Configure( - IFilterInputTypeDescriptor descriptor) - { - descriptor.Field(t => t.Bar); - } + descriptor.Field(t => t.Bar); } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorTimeOnlyTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorTimeOnlyTests.cs index b7762be3561..fd4bd4cd4ed 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorTimeOnlyTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterVisitorTimeOnlyTests.cs @@ -6,201 +6,200 @@ using MongoDB.Bson.Serialization; using MongoDB.Bson.Serialization.Attributes; using MongoDB.Bson.Serialization.Serializers; -using Xunit; using Squadron; +using Xunit; + +namespace HotChocolate.Data.MongoDb.Filters; -namespace HotChocolate.Data.MongoDb.Filters +public class MongoDbFilterVisitorTimeOnlyTests + : SchemaCache + , IClassFixture { - public class MongoDbFilterVisitorTimeOnlyTests - : SchemaCache - , IClassFixture - { #if NET6_0_OR_GREATER - private static readonly Foo[] _fooEntities = - { + private static readonly Foo[] _fooEntities = + { new Foo { Bar = new TimeOnly(06, 30) }, new Foo { Bar = new TimeOnly(16, 00) } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new FooNullable { Bar = new TimeOnly(06, 30) }, new FooNullable { Bar = null }, new FooNullable { Bar = new TimeOnly(16, 00) } }; - public MongoDbFilterVisitorTimeOnlyTests(MongoResource resource) - { - Init(resource); + public MongoDbFilterVisitorTimeOnlyTests(MongoResource resource) + { + Init(resource); - // NOTE: At the time of coding, MongoDB C# Driver doesn't natively support TimeOnly - BsonSerializer.RegisterSerializationProvider(new LocalTimeOnlySerializationProvider()); - } + // NOTE: At the time of coding, MongoDB C# Driver doesn't natively support TimeOnly + BsonSerializer.RegisterSerializationProvider(new LocalTimeOnlySerializationProvider()); + } - [Fact] - public async Task Create_TimeOnlyEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_TimeOnlyEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"06:30:00\" } }){ bar } }") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"06:30:00\" } }){ bar } }") + .Create()); - res1.MatchDocumentSnapshot("0630"); + res1.MatchDocumentSnapshot("0630"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"16:00:00\" } }){ bar } }") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"16:00:00\" } }){ bar } }") + .Create()); - res2.MatchDocumentSnapshot("1600"); - } + res2.MatchDocumentSnapshot("1600"); + } - [Fact] - public async Task Create_TimeOnlyNotEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); + [Fact] + public async Task Create_TimeOnlyNotEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"06:30:00\" } }){ bar } }") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"06:30:00\" } }){ bar } }") + .Create()); - res1.MatchDocumentSnapshot("0630"); + res1.MatchDocumentSnapshot("0630"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"16:00:00\" } }){ bar } }") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"16:00:00\" } }){ bar } }") + .Create()); - res2.MatchDocumentSnapshot("1600"); - } + res2.MatchDocumentSnapshot("1600"); + } - [Fact] - public async Task Create_NullableTimeOnlyEqual_Expression() - { - // arrange - IRequestExecutor? tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableTimeOnlyEqual_Expression() + { + // arrange + IRequestExecutor? tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"06:30:00\" } }){ bar } }") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"06:30:00\" } }){ bar } }") + .Create()); - res1.MatchDocumentSnapshot("0630"); + res1.MatchDocumentSnapshot("0630"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"16:00:00\" } }){ bar } }") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"16:00:00\" } }){ bar } }") + .Create()); - res2.MatchDocumentSnapshot("1600"); + res2.MatchDocumentSnapshot("1600"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: null } }){ bar } }") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: null } }){ bar } }") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - [Fact] - public async Task Create_NullableTimeOnlyNotEqual_Expression() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); + [Fact] + public async Task Create_NullableTimeOnlyNotEqual_Expression() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"06:30:00\" } }){ bar } }") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"06:30:00\" } }){ bar } }") + .Create()); - res1.MatchDocumentSnapshot("0630"); + res1.MatchDocumentSnapshot("0630"); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: \"16:00:00\" } }){ bar } }") - .Create()); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: \"16:00:00\" } }){ bar } }") + .Create()); - res2.MatchDocumentSnapshot("1600"); + res2.MatchDocumentSnapshot("1600"); - IExecutionResult res3 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { neq: null } }){ bar } }") - .Create()); + IExecutionResult res3 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { neq: null } }){ bar } }") + .Create()); - res3.MatchDocumentSnapshot("null"); - } + res3.MatchDocumentSnapshot("null"); + } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public TimeOnly Bar { get; set; } - } + public TimeOnly Bar { get; set; } + } - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public TimeOnly? Bar { get; set; } - } + public TimeOnly? Bar { get; set; } + } - public class FooFilterType - : FilterInputType - { - } + public class FooFilterType + : FilterInputType + { + } + + public class FooNullableFilterType + : FilterInputType + { + } - public class FooNullableFilterType - : FilterInputType + internal class LocalTimeOnlySerializationProvider : IBsonSerializationProvider + { + public IBsonSerializer? GetSerializer(Type type) { + return type == typeof(TimeOnly) ? new TimeOnlySerializer() : null; } + } - internal class LocalTimeOnlySerializationProvider : IBsonSerializationProvider + internal class TimeOnlySerializer : StructSerializerBase + { + public override void Serialize( + BsonSerializationContext context, + BsonSerializationArgs args, + TimeOnly value) { - public IBsonSerializer? GetSerializer(Type type) - { - return type == typeof(TimeOnly) ? new TimeOnlySerializer() : null; - } + DateTime dateTime = default(DateTime).Add(value.ToTimeSpan()); + dateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Utc); + var ticks = BsonUtils.ToMillisecondsSinceEpoch(dateTime); + context.Writer.WriteDateTime(ticks); } - internal class TimeOnlySerializer : StructSerializerBase + public override TimeOnly Deserialize( + BsonDeserializationContext context, + BsonDeserializationArgs args) { - public override void Serialize( - BsonSerializationContext context, - BsonSerializationArgs args, - TimeOnly value) - { - DateTime dateTime = default(DateTime).Add(value.ToTimeSpan()); - dateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Utc); - var ticks = BsonUtils.ToMillisecondsSinceEpoch(dateTime); - context.Writer.WriteDateTime(ticks); - } - - public override TimeOnly Deserialize( - BsonDeserializationContext context, - BsonDeserializationArgs args) - { - long ticks = context.Reader.ReadDateTime(); - DateTime dateTime = BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(ticks); - return new TimeOnly(dateTime.Hour, dateTime.Minute, dateTime.Second); - } + long ticks = context.Reader.ReadDateTime(); + DateTime dateTime = BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(ticks); + return new TimeOnly(dateTime.Hour, dateTime.Minute, dateTime.Second); } -#endif } +#endif } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFindFluentTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFindFluentTests.cs index 93f14562cfe..9cf9e8f87ae 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFindFluentTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFindFluentTests.cs @@ -1,3 +1,5 @@ +using System; +using System.Threading.Tasks; using HotChocolate.Data.Filters; using HotChocolate.Execution; using HotChocolate.Types; @@ -7,208 +9,205 @@ using MongoDB.Bson.Serialization.Attributes; using MongoDB.Bson.Serialization.Serializers; using MongoDB.Driver; -using System; -using System.Threading.Tasks; using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class MongoDbFindFluentTests : IClassFixture { - public class MongoDbFindFluentTests : IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = true }, new Foo { Bar = false } }; - private static readonly Bar[] _barEntities = - { + private static readonly Bar[] _barEntities = + { new Bar { Baz = new DateTimeOffset(2020, 1, 12, 0, 0, 0, TimeSpan.Zero) }, new Bar { Baz = new DateTimeOffset(2020, 1, 11, 0, 0, 0, TimeSpan.Zero) } }; - private static readonly Baz[] _bazEntities = - { + private static readonly Baz[] _bazEntities = + { new Baz { Bar = new DateTimeOffset(2020, 1, 12, 0, 0, 0, TimeSpan.Zero) }, new Baz { Bar = new DateTimeOffset(2020, 1, 11, 0, 0, 0, TimeSpan.Zero) }, new Baz { Bar = new DateTimeOffset(1996, 1, 11, 0, 0, 0, TimeSpan.Zero) } }; - private readonly MongoResource _resource; + private readonly MongoResource _resource; + + public MongoDbFindFluentTests(MongoResource resource) + { + _resource = resource; + } - public MongoDbFindFluentTests(MongoResource resource) - { - _resource = resource; - } + [Fact] + public async Task BsonElement_Rename() + { + // arrange + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - [Fact] - public async Task BsonElement_Rename() - { - // arrange - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_fooEntities); - - return collection.Find(FilterDefinition.Empty).AsExecutable(); - }); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: true}}){ bar}}") - .Create()); - - res1.MatchDocumentSnapshot("true"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: false}}){ bar}}") - .Create()); - - res2.MatchDocumentSnapshot("false"); - } - - [Fact] - public async Task FindFluent_Serializer() - { - // arrange - BsonClassMap.RegisterClassMap( - x => x.MapField(y => y.Baz) - .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) - .SetElementName("testName")); - - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + collection.InsertMany(_fooEntities); - collection.InsertMany(_barEntities); + return collection.Find(FilterDefinition.Empty).AsExecutable(); + }); - return collection.Find(FilterDefinition.Empty).AsExecutable(); - }); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: true}}){ bar}}") + .Create()); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { baz: { eq: \"2020-01-11T00:00:00Z\"}}){ baz}}") - .Create()); + res1.MatchDocumentSnapshot("true"); - res1.MatchDocumentSnapshot("2020-01-11"); + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: false}}){ bar}}") + .Create()); - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { baz: { eq: \"2020-01-12T00:00:00Z\"}}){ baz}}") - .Create()); + res2.MatchDocumentSnapshot("false"); + } - res2.MatchDocumentSnapshot("2020-01-12"); - } + [Fact] + public async Task FindFluent_Serializer() + { + // arrange + BsonClassMap.RegisterClassMap( + x => x.MapField(y => y.Baz) + .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) + .SetElementName("testName")); + + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_barEntities); + + return collection.Find(FilterDefinition.Empty).AsExecutable(); + }); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { baz: { eq: \"2020-01-11T00:00:00Z\"}}){ baz}}") + .Create()); + + res1.MatchDocumentSnapshot("2020-01-11"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { baz: { eq: \"2020-01-12T00:00:00Z\"}}){ baz}}") + .Create()); + + res2.MatchDocumentSnapshot("2020-01-12"); + } - [Fact] - public async Task FindFluent_CombineQuery() - { - // arrange - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_bazEntities); - - return collection - .Find(x => x.Bar > new DateTimeOffset(2000, 1, 1, 0, 0, 0, TimeSpan.Zero)) - .AsExecutable(); - }); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"2020-01-11T00:00:00Z\"}}){ bar}}") - .Create()); - - res1.MatchDocumentSnapshot("2020-01-11"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(where: { bar: { eq: \"2020-01-12T00:00:00Z\"}}){ bar}}") - .Create()); - - res2.MatchDocumentSnapshot("2020-01-12"); - } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - [BsonElement("renameTest")] - public bool Bar { get; set; } - } - - public class Bar - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public DateTimeOffset Baz { get; set; } - } - - public class Baz - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public DateTimeOffset Bar { get; set; } - } - - private static IRequestExecutor CreateSchema( - Func> resolver) - where TEntity : class - => new ServiceCollection() - .AddGraphQL() - .AddFiltering(x => x.AddMongoDbDefaults()) - .AddQueryType( - c => c - .Name("Query") - .Field("root") - .Type>>() - .Resolve(async _ => await new ValueTask>(resolver())) - .Use(next => async context => - { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseFiltering>()) - .UseRequest( - next => async context => + [Fact] + public async Task FindFluent_CombineQuery() + { + // arrange + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_bazEntities); + + return collection + .Find(x => x.Bar > new DateTimeOffset(2000, 1, 1, 0, 0, 0, TimeSpan.Zero)) + .AsExecutable(); + }); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"2020-01-11T00:00:00Z\"}}){ bar}}") + .Create()); + + res1.MatchDocumentSnapshot("2020-01-11"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(where: { bar: { eq: \"2020-01-12T00:00:00Z\"}}){ bar}}") + .Create()); + + res2.MatchDocumentSnapshot("2020-01-12"); + } + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + [BsonElement("renameTest")] + public bool Bar { get; set; } + } + + public class Bar + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public DateTimeOffset Baz { get; set; } + } + + public class Baz + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public DateTimeOffset Bar { get; set; } + } + + private static IRequestExecutor CreateSchema( + Func> resolver) + where TEntity : class + => new ServiceCollection() + .AddGraphQL() + .AddFiltering(x => x.AddMongoDbDefaults()) + .AddQueryType( + c => c + .Name("Query") + .Field("root") + .Type>>() + .Resolve(async _ => await new ValueTask>(resolver())) + .Use(next => async context => { await next(context); - if (context.ContextData.TryGetValue("query", out object? queryString)) + if (context.Result is IExecutable executable) { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); + context.ContextData["query"] = executable.Print(); } }) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync() - .GetAwaiter() - .GetResult(); - } + .UseFiltering>()) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out object? queryString)) + { + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync() + .GetAwaiter() + .GetResult(); } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/SchemaCache.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/SchemaCache.cs index 6d4db739faf..63cd2b42fc2 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/SchemaCache.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/SchemaCache.cs @@ -4,34 +4,33 @@ using HotChocolate.Execution; using Squadron; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class SchemaCache + : FilterVisitorTestBase + , IDisposable { - public class SchemaCache - : FilterVisitorTestBase - , IDisposable - { - private MongoResource _resource = null!; + private MongoResource _resource = null!; - protected void Init(MongoResource resource) - { - _resource = resource; - } + protected void Init(MongoResource resource) + { + _resource = resource; + } - private readonly ConcurrentDictionary<(Type, Type, object), IRequestExecutor> _cache = - new ConcurrentDictionary<(Type, Type, object), IRequestExecutor>(); + private readonly ConcurrentDictionary<(Type, Type, object), IRequestExecutor> _cache = + new ConcurrentDictionary<(Type, Type, object), IRequestExecutor>(); - public IRequestExecutor CreateSchema(T[] entities, bool withPaging = false) - where T : class - where TType : FilterInputType - { - (Type, Type, T[] entites) key = (typeof(T), typeof(TType), entities); - return _cache.GetOrAdd( - key, - k => base.CreateSchema(entities, _resource, withPaging: withPaging)); - } + public IRequestExecutor CreateSchema(T[] entities, bool withPaging = false) + where T : class + where TType : FilterInputType + { + (Type, Type, T[] entites) key = (typeof(T), typeof(TType), entities); + return _cache.GetOrAdd( + key, + k => base.CreateSchema(entities, _resource, withPaging: withPaging)); + } - public void Dispose() - { - } + public void Dispose() + { } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/Extensions/TestExtensions.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/Extensions/TestExtensions.cs index 1111fc8fcd7..bc028544637 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/Extensions/TestExtensions.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/Extensions/TestExtensions.cs @@ -2,24 +2,23 @@ using Snapshooter; using Snapshooter.Xunit; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +public static class TestExtensions { - public static class TestExtensions + public static void MatchDocumentSnapshot( + this IExecutionResult result, + string snapshotName = "") { - public static void MatchDocumentSnapshot( - this IExecutionResult result, - string snapshotName = "") + if (result is { }) { - if (result is { }) + result.ToJson().MatchSnapshot(new SnapshotNameExtension(snapshotName)); + if (result.ContextData is { } && + result.ContextData.TryGetValue("query", out object? queryResult) && + queryResult is string queryString && + !string.IsNullOrWhiteSpace(queryString)) { - result.ToJson().MatchSnapshot(new SnapshotNameExtension(snapshotName)); - if (result.ContextData is { } && - result.ContextData.TryGetValue("query", out object? queryResult) && - queryResult is string queryString && - !string.IsNullOrWhiteSpace(queryString)) - { - queryString.MatchSnapshot(new SnapshotNameExtension(snapshotName + "_query")); - } + queryString.MatchSnapshot(new SnapshotNameExtension(snapshotName + "_query")); } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingAggregateFluentTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingAggregateFluentTests.cs index 33aa457558c..d9204262c06 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingAggregateFluentTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingAggregateFluentTests.cs @@ -1,8 +1,8 @@ using System; using System.Collections.Generic; using System.Threading.Tasks; -using HotChocolate.Execution; using HotChocolate.Data.MongoDb.Filters; +using HotChocolate.Execution; using HotChocolate.Resolvers; using HotChocolate.Types; using HotChocolate.Types.Pagination; @@ -13,35 +13,35 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +public class MongoDbCursorPagingAggregateFluentTests : IClassFixture { - public class MongoDbCursorPagingAggregateFluentTests : IClassFixture + private readonly List foos = new() { - private readonly List foos = new() - { - new Foo { Bar = "a" }, - new Foo { Bar = "b" }, - new Foo { Bar = "d" }, - new Foo { Bar = "e" }, - new Foo { Bar = "f" } - }; + new Foo { Bar = "a" }, + new Foo { Bar = "b" }, + new Foo { Bar = "d" }, + new Foo { Bar = "e" }, + new Foo { Bar = "f" } + }; - private readonly MongoResource _resource; + private readonly MongoResource _resource; - public MongoDbCursorPagingAggregateFluentTests(MongoResource resource) - { - _resource = resource; - } + public MongoDbCursorPagingAggregateFluentTests(MongoResource resource) + { + _resource = resource; + } - [Fact] - public async Task Simple_StringList_Default_Items() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Default_Items() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos { edges { @@ -61,18 +61,18 @@ public async Task Simple_StringList_Default_Items() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_First_2() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_First_2() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos(first: 2) { edges { @@ -92,18 +92,18 @@ public async Task Simple_StringList_First_2() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_First_2_After() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_First_2_After() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos(first: 2 after: ""MQ=="") { edges { @@ -123,19 +123,19 @@ public async Task Simple_StringList_First_2_After() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_Global_DefaultItem_2() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Global_DefaultItem_2() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos { edges { @@ -155,110 +155,109 @@ public async Task Simple_StringList_Global_DefaultItem_2() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task JustTotalCount() - { - Snapshot.FullName(); + [Fact] + public async Task JustTotalCount() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos { totalCount } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task TotalCount_AndFirst() - { - Snapshot.FullName(); + [Fact] + public async Task TotalCount_AndFirst() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos(first:1) { totalCount } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public string Bar { get; set; } = default!; - } + public string Bar { get; set; } = default!; + } - private Func> - BuildResolver( - MongoResource mongoResource, - IEnumerable results) - where TResult : class - { - IMongoCollection collection = - mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + private Func> + BuildResolver( + MongoResource mongoResource, + IEnumerable results) + where TResult : class + { + IMongoCollection collection = + mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - collection.InsertMany(results); + collection.InsertMany(results); - return ctx => collection.Aggregate().AsExecutable(); - } + return ctx => collection.Aggregate().AsExecutable(); + } - private ValueTask CreateSchemaAsync() - { - return new ServiceCollection() - .AddGraphQL() - .AddMongoDbPagingProviders() - .AddFiltering(x => x.AddMongoDbDefaults()) - .AddQueryType( - descriptor => - { - descriptor - .Field("foos") - .Resolve(BuildResolver(_resource, foos)) - .Type>>() - .Use( - next => async context => + private ValueTask CreateSchemaAsync() + { + return new ServiceCollection() + .AddGraphQL() + .AddMongoDbPagingProviders() + .AddFiltering(x => x.AddMongoDbDefaults()) + .AddQueryType( + descriptor => + { + descriptor + .Field("foos") + .Resolve(BuildResolver(_resource, foos)) + .Type>>() + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UsePaging>( - options: new PagingOptions { IncludeTotalCount = true }); - }) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UsePaging>( + options: new PagingOptions { IncludeTotalCount = true }); + }) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .ModifyRequestOptions(x => x.IncludeExceptionDetails = true) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .ModifyRequestOptions(x => x.IncludeExceptionDetails = true) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync(); } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingFindFluentTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingFindFluentTests.cs index cc4ec71c5be..0d1df25c5f2 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingFindFluentTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingFindFluentTests.cs @@ -1,8 +1,8 @@ using System; using System.Collections.Generic; using System.Threading.Tasks; -using HotChocolate.Execution; using HotChocolate.Data.MongoDb.Filters; +using HotChocolate.Execution; using HotChocolate.Resolvers; using HotChocolate.Types; using HotChocolate.Types.Pagination; @@ -13,11 +13,11 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +public class MongoDbCursorPagingFindFluentTests : IClassFixture { - public class MongoDbCursorPagingFindFluentTests : IClassFixture - { - private readonly List foos = new List + private readonly List foos = new List { new Foo { Bar = "a" }, new Foo { Bar = "b" }, @@ -26,22 +26,22 @@ public class MongoDbCursorPagingFindFluentTests : IClassFixture new Foo { Bar = "f" } }; - private readonly MongoResource _resource; + private readonly MongoResource _resource; - public MongoDbCursorPagingFindFluentTests(MongoResource resource) - { - _resource = resource; - } + public MongoDbCursorPagingFindFluentTests(MongoResource resource) + { + _resource = resource; + } - [Fact] - public async Task Simple_StringList_Default_Items() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Default_Items() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos { edges { @@ -61,18 +61,18 @@ public async Task Simple_StringList_Default_Items() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_First_2() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_First_2() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos(first: 2) { edges { @@ -92,18 +92,18 @@ public async Task Simple_StringList_First_2() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_First_2_After() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_First_2_After() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos(first: 2 after: ""MQ=="") { edges { @@ -123,18 +123,18 @@ public async Task Simple_StringList_First_2_After() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_Last_1_Before() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Last_1_Before() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos(last: 1 before: ""NA=="") { edges { @@ -154,19 +154,19 @@ public async Task Simple_StringList_Last_1_Before() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_Global_DefaultItem_2() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Global_DefaultItem_2() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos { edges { @@ -186,109 +186,108 @@ public async Task Simple_StringList_Global_DefaultItem_2() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task JustTotalCount() - { - Snapshot.FullName(); + [Fact] + public async Task JustTotalCount() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos { totalCount } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task TotalCount_AndFirst() - { - Snapshot.FullName(); + [Fact] + public async Task TotalCount_AndFirst() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foos(first:1) { totalCount } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public string Bar { get; set; } = default!; - } + public string Bar { get; set; } = default!; + } - private Func> BuildResolver( - MongoResource mongoResource, - IEnumerable results) - where TResult : class - { - IMongoCollection collection = - mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + private Func> BuildResolver( + MongoResource mongoResource, + IEnumerable results) + where TResult : class + { + IMongoCollection collection = + mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - collection.InsertMany(results); + collection.InsertMany(results); - return ctx => collection.AsExecutable(); - } + return ctx => collection.AsExecutable(); + } - private ValueTask CreateSchemaAsync() - { - return new ServiceCollection() - .AddGraphQL() - .AddMongoDbPagingProviders() - .AddFiltering(x => x.AddMongoDbDefaults()) - .AddQueryType( - descriptor => - { - descriptor - .Field("foos") - .Resolve(BuildResolver(_resource, foos)) - .Type>>() - .Use( - next => async context => + private ValueTask CreateSchemaAsync() + { + return new ServiceCollection() + .AddGraphQL() + .AddMongoDbPagingProviders() + .AddFiltering(x => x.AddMongoDbDefaults()) + .AddQueryType( + descriptor => + { + descriptor + .Field("foos") + .Resolve(BuildResolver(_resource, foos)) + .Type>>() + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UsePaging>( - options: new PagingOptions { IncludeTotalCount = true }); - }) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UsePaging>( + options: new PagingOptions { IncludeTotalCount = true }); + }) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .ModifyRequestOptions(x => x.IncludeExceptionDetails = true) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .ModifyRequestOptions(x => x.IncludeExceptionDetails = true) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync(); } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingProviderTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingProviderTests.cs index e55f23576f8..cc39a90821a 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingProviderTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbCursorPagingProviderTests.cs @@ -8,51 +8,50 @@ using MongoDB.Driver; using Xunit; -namespace HotChocolate.Data +namespace HotChocolate.Data; + +public class MongoDbCursorPagingProviderTests { - public class MongoDbCursorPagingProviderTests + [Theory] + [InlineData(nameof(AggregateFluent), true)] + [InlineData(nameof(FindFluent), true)] + [InlineData(nameof(MongoCollection), true)] + [InlineData(nameof(IMongoDbExecutable), true)] + [InlineData(nameof(IExecutable), false)] + [InlineData(nameof(IQueryable), false)] + public void CanHandle_MethodReturnType_MatchesResult(string methodName, bool expected) + { + // arrange + var provider = new MongoDbCursorPagingProvider(); + MethodInfo member = typeof(MongoDbCursorPagingProviderTests).GetMethod(methodName)!; + IExtendedType type = new DefaultTypeInspector().GetReturnType(member); + + // act + var result = provider.CanHandle(type); + + // assert + Assert.Equal(expected, result); + } + + public IAggregateFluent AggregateFluent() => + throw new InvalidOperationException(); + + public IFindFluent FindFluent() => + throw new InvalidOperationException(); + + public IMongoCollection MongoCollection() => + throw new InvalidOperationException(); + + public IMongoDbExecutable IMongoDbExecutable() => + throw new InvalidOperationException(); + + public IExecutable IExecutable() => + throw new InvalidOperationException(); + + public IQueryable IQueryable() => + throw new InvalidOperationException(); + + public class Foo { - [Theory] - [InlineData(nameof(AggregateFluent), true)] - [InlineData(nameof(FindFluent), true)] - [InlineData(nameof(MongoCollection), true)] - [InlineData(nameof(IMongoDbExecutable), true)] - [InlineData(nameof(IExecutable), false)] - [InlineData(nameof(IQueryable), false)] - public void CanHandle_MethodReturnType_MatchesResult(string methodName, bool expected) - { - // arrange - var provider = new MongoDbCursorPagingProvider(); - MethodInfo member = typeof(MongoDbCursorPagingProviderTests).GetMethod(methodName)!; - IExtendedType type = new DefaultTypeInspector().GetReturnType(member); - - // act - var result = provider.CanHandle(type); - - // assert - Assert.Equal(expected, result); - } - - public IAggregateFluent AggregateFluent() => - throw new InvalidOperationException(); - - public IFindFluent FindFluent() => - throw new InvalidOperationException(); - - public IMongoCollection MongoCollection() => - throw new InvalidOperationException(); - - public IMongoDbExecutable IMongoDbExecutable() => - throw new InvalidOperationException(); - - public IExecutable IExecutable() => - throw new InvalidOperationException(); - - public IQueryable IQueryable() => - throw new InvalidOperationException(); - - public class Foo - { - } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingAggregateTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingAggregateTests.cs index c4e28b41847..07f10b11c56 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingAggregateTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingAggregateTests.cs @@ -1,8 +1,8 @@ using System; using System.Collections.Generic; using System.Threading.Tasks; -using HotChocolate.Execution; using HotChocolate.Data.MongoDb.Filters; +using HotChocolate.Execution; using HotChocolate.Resolvers; using HotChocolate.Types; using HotChocolate.Types.Pagination; @@ -13,36 +13,36 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +public class MongoDbOffsetPagingAggregateTests : IClassFixture { - public class MongoDbOffsetPagingAggregateTests : IClassFixture + private readonly List _foos = new() + { + new Foo { Bar = "a" }, + new Foo { Bar = "b" }, + new Foo { Bar = "d" }, + new Foo { Bar = "e" }, + new Foo { Bar = "f" } + }; + + private readonly MongoResource _resource; + + public MongoDbOffsetPagingAggregateTests(MongoResource resource) + { + _resource = resource; + } + + [Fact] + public async Task Simple_StringList_Default_Items() { - private readonly List _foos = new() - { - new Foo { Bar = "a" }, - new Foo { Bar = "b" }, - new Foo { Bar = "d" }, - new Foo { Bar = "e" }, - new Foo { Bar = "f" } - }; - - private readonly MongoResource _resource; - - public MongoDbOffsetPagingAggregateTests(MongoResource resource) - { - _resource = resource; - } - - [Fact] - public async Task Simple_StringList_Default_Items() - { - Snapshot.FullName(); - - IRequestExecutor executor = await CreateSchemaAsync(); - - IExecutionResult result = await executor - .ExecuteAsync( - @"{ + Snapshot.FullName(); + + IRequestExecutor executor = await CreateSchemaAsync(); + + IExecutionResult result = await executor + .ExecuteAsync( + @"{ foos { items { bar @@ -54,19 +54,19 @@ public async Task Simple_StringList_Default_Items() totalCount } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_Take_2() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Take_2() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync( - @" + IExecutionResult result = await executor + .ExecuteAsync( + @" { foos(take: 2) { items { @@ -78,19 +78,19 @@ public async Task Simple_StringList_Take_2() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_Take_2_After() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Take_2_After() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync( - @" + IExecutionResult result = await executor + .ExecuteAsync( + @" { foos(take: 2 skip: 2) { items { @@ -102,20 +102,20 @@ public async Task Simple_StringList_Take_2_After() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_Global_DefaultItem_2() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Global_DefaultItem_2() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync( - @" + IExecutionResult result = await executor + .ExecuteAsync( + @" { foos { items { @@ -127,94 +127,93 @@ public async Task Simple_StringList_Global_DefaultItem_2() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task JustTotalCount() - { - Snapshot.FullName(); + [Fact] + public async Task JustTotalCount() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync( - @" + IExecutionResult result = await executor + .ExecuteAsync( + @" { foos { totalCount } }"); - result.MatchDocumentSnapshot(); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public string Bar { get; set; } = default!; - } - - private Func> - BuildResolver( - MongoResource mongoResource, - IEnumerable results) - where TResult : class - { - IMongoCollection collection = - mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(results); - - return _ => collection.Aggregate().AsExecutable(); - } - - private ValueTask CreateSchemaAsync() - { - return new ServiceCollection() - .AddGraphQL() - .AddMongoDbPagingProviders() - .AddFiltering(x => x.AddMongoDbDefaults()) - .AddQueryType( - descriptor => - { - descriptor - .Field("foos") - .Resolve(BuildResolver(_resource, _foos)) - .Type>>() - .Use( - next => async context => + result.MatchDocumentSnapshot(); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public string Bar { get; set; } = default!; + } + + private Func> + BuildResolver( + MongoResource mongoResource, + IEnumerable results) + where TResult : class + { + IMongoCollection collection = + mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(results); + + return _ => collection.Aggregate().AsExecutable(); + } + + private ValueTask CreateSchemaAsync() + { + return new ServiceCollection() + .AddGraphQL() + .AddMongoDbPagingProviders() + .AddFiltering(x => x.AddMongoDbDefaults()) + .AddQueryType( + descriptor => + { + descriptor + .Field("foos") + .Resolve(BuildResolver(_resource, _foos)) + .Type>>() + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseOffsetPaging>( - options: new PagingOptions { IncludeTotalCount = true }); - }) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UseOffsetPaging>( + options: new PagingOptions { IncludeTotalCount = true }); + }) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .ModifyRequestOptions(x => x.IncludeExceptionDetails = true) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .ModifyRequestOptions(x => x.IncludeExceptionDetails = true) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync(); } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingFindFluentTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingFindFluentTests.cs index 23cb2517fc0..3dc0c554670 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingFindFluentTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingFindFluentTests.cs @@ -1,5 +1,8 @@ -using HotChocolate.Execution; +using System; +using System.Collections.Generic; +using System.Threading.Tasks; using HotChocolate.Data.MongoDb.Filters; +using HotChocolate.Execution; using HotChocolate.Resolvers; using HotChocolate.Types; using HotChocolate.Types.Pagination; @@ -7,17 +10,14 @@ using MongoDB.Bson.Serialization.Attributes; using MongoDB.Driver; using Snapshooter.Xunit; -using System; -using System.Collections.Generic; -using System.Threading.Tasks; using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +public class MongoDbOffsetPagingFindFluentTests : IClassFixture { - public class MongoDbOffsetPagingFindFluentTests : IClassFixture - { - private readonly List foos = new List + private readonly List foos = new List { new Foo { Bar = "a" }, new Foo { Bar = "b" }, @@ -26,23 +26,23 @@ public class MongoDbOffsetPagingFindFluentTests : IClassFixture new Foo { Bar = "f" } }; - private readonly MongoResource _resource; + private readonly MongoResource _resource; - public MongoDbOffsetPagingFindFluentTests(MongoResource resource) - { - _resource = resource; - } + public MongoDbOffsetPagingFindFluentTests(MongoResource resource) + { + _resource = resource; + } - [Fact] - public async Task Simple_StringList_Default_Items() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Default_Items() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync( - @" + IExecutionResult result = await executor + .ExecuteAsync( + @" { foos { items { @@ -55,19 +55,19 @@ public async Task Simple_StringList_Default_Items() totalCount } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_Take_2() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Take_2() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync( - @" + IExecutionResult result = await executor + .ExecuteAsync( + @" { foos(take: 2) { items { @@ -79,19 +79,19 @@ public async Task Simple_StringList_Take_2() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_Take_2_After() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Take_2_After() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync( - @" + IExecutionResult result = await executor + .ExecuteAsync( + @" { foos(take: 2 skip: 2) { items { @@ -103,20 +103,20 @@ public async Task Simple_StringList_Take_2_After() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task Simple_StringList_Global_DefaultItem_2() - { - Snapshot.FullName(); + [Fact] + public async Task Simple_StringList_Global_DefaultItem_2() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync( - @" + IExecutionResult result = await executor + .ExecuteAsync( + @" { foos { items { @@ -128,93 +128,92 @@ public async Task Simple_StringList_Global_DefaultItem_2() } } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - [Fact] - public async Task JustTotalCount() - { - Snapshot.FullName(); + [Fact] + public async Task JustTotalCount() + { + Snapshot.FullName(); - IRequestExecutor executor = await CreateSchemaAsync(); + IRequestExecutor executor = await CreateSchemaAsync(); - IExecutionResult result = await executor - .ExecuteAsync( - @" + IExecutionResult result = await executor + .ExecuteAsync( + @" { foos { totalCount } }"); - result.MatchDocumentSnapshot(); - } + result.MatchDocumentSnapshot(); + } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public string Bar { get; set; } = default!; - } + public string Bar { get; set; } = default!; + } - private Func> BuildResolver( - MongoResource mongoResource, - IEnumerable results) - where TResult : class - { - IMongoCollection collection = - mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + private Func> BuildResolver( + MongoResource mongoResource, + IEnumerable results) + where TResult : class + { + IMongoCollection collection = + mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - collection.InsertMany(results); + collection.InsertMany(results); - return ctx => collection.AsExecutable(); - } + return ctx => collection.AsExecutable(); + } - private ValueTask CreateSchemaAsync() - { - return new ServiceCollection() - .AddGraphQL() - .AddMongoDbPagingProviders() - .AddFiltering(x => x.AddMongoDbDefaults()) - .AddQueryType( - descriptor => - { - descriptor - .Field("foos") - .Resolve(BuildResolver(_resource, foos)) - .Type>>() - .Use( - next => async context => + private ValueTask CreateSchemaAsync() + { + return new ServiceCollection() + .AddGraphQL() + .AddMongoDbPagingProviders() + .AddFiltering(x => x.AddMongoDbDefaults()) + .AddQueryType( + descriptor => + { + descriptor + .Field("foos") + .Resolve(BuildResolver(_resource, foos)) + .Type>>() + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseOffsetPaging>( - options: new PagingOptions { IncludeTotalCount = true }); - }) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UseOffsetPaging>( + options: new PagingOptions { IncludeTotalCount = true }); + }) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .ModifyRequestOptions(x => x.IncludeExceptionDetails = true) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .ModifyRequestOptions(x => x.IncludeExceptionDetails = true) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync(); } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingProviderTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingProviderTests.cs index e639c0b96ac..29190259691 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingProviderTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbOffsetPagingProviderTests.cs @@ -8,51 +8,50 @@ using MongoDB.Driver; using Xunit; -namespace HotChocolate.Data +namespace HotChocolate.Data; + +public class MongoDbOffsetPagingProviderTests { - public class MongoDbOffsetPagingProviderTests + [Theory] + [InlineData(nameof(AggregateFluent), true)] + [InlineData(nameof(FindFluent), true)] + [InlineData(nameof(MongoCollection), true)] + [InlineData(nameof(IMongoDbExecutable), true)] + [InlineData(nameof(IExecutable), false)] + [InlineData(nameof(IQueryable), false)] + public void CanHandle_MethodReturnType_MatchesResult(string methodName, bool expected) + { + // arrange + var provider = new MongoDbOffsetPagingProvider(); + MethodInfo member = typeof(MongoDbOffsetPagingProviderTests).GetMethod(methodName)!; + IExtendedType type = new DefaultTypeInspector().GetReturnType(member); + + // act + var result = provider.CanHandle(type); + + // assert + Assert.Equal(expected, result); + } + + public IAggregateFluent AggregateFluent() => + throw new InvalidOperationException(); + + public IFindFluent FindFluent() => + throw new InvalidOperationException(); + + public IMongoCollection MongoCollection() => + throw new InvalidOperationException(); + + public IMongoDbExecutable IMongoDbExecutable() => + throw new InvalidOperationException(); + + public IExecutable IExecutable() => + throw new InvalidOperationException(); + + public IQueryable IQueryable() => + throw new InvalidOperationException(); + + public class Foo { - [Theory] - [InlineData(nameof(AggregateFluent), true)] - [InlineData(nameof(FindFluent), true)] - [InlineData(nameof(MongoCollection), true)] - [InlineData(nameof(IMongoDbExecutable), true)] - [InlineData(nameof(IExecutable), false)] - [InlineData(nameof(IQueryable), false)] - public void CanHandle_MethodReturnType_MatchesResult(string methodName, bool expected) - { - // arrange - var provider = new MongoDbOffsetPagingProvider(); - MethodInfo member = typeof(MongoDbOffsetPagingProviderTests).GetMethod(methodName)!; - IExtendedType type = new DefaultTypeInspector().GetReturnType(member); - - // act - var result = provider.CanHandle(type); - - // assert - Assert.Equal(expected, result); - } - - public IAggregateFluent AggregateFluent() => - throw new InvalidOperationException(); - - public IFindFluent FindFluent() => - throw new InvalidOperationException(); - - public IMongoCollection MongoCollection() => - throw new InvalidOperationException(); - - public IMongoDbExecutable IMongoDbExecutable() => - throw new InvalidOperationException(); - - public IExecutable IExecutable() => - throw new InvalidOperationException(); - - public IQueryable IQueryable() => - throw new InvalidOperationException(); - - public class Foo - { - } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbRelayTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbRelayTests.cs index 15d1e49602b..2685bc27376 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbRelayTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/MongoDbRelayTests.cs @@ -1,91 +1,90 @@ -using HotChocolate.Execution; +using System.Threading.Tasks; using HotChocolate.Data.MongoDb.Filters; +using HotChocolate.Execution; using HotChocolate.Types; using HotChocolate.Types.Pagination; using Microsoft.Extensions.DependencyInjection; +using MongoDB.Bson; using MongoDB.Bson.Serialization.Attributes; using Snapshooter.Xunit; -using System.Threading.Tasks; -using MongoDB.Bson; using Xunit; -namespace HotChocolate.Data.MongoDb.Paging +namespace HotChocolate.Data.MongoDb.Paging; + +public class MongoDbRelayTests { - public class MongoDbRelayTests + [Fact] + public async Task Return_BsonId() { - [Fact] - public async Task Return_BsonId() - { - Snapshot.FullName(); + Snapshot.FullName(); - IRequestExecutor executor = await new ServiceCollection() - .AddTransient() - .AddGraphQL() - .AddQueryType() - .AddType() - #pragma warning disable CS8622 + IRequestExecutor executor = await new ServiceCollection() + .AddTransient() + .AddGraphQL() + .AddQueryType() + .AddType() +#pragma warning disable CS8622 .AddTypeConverter(x => x.ToString()) - #pragma warning restore CS8622 +#pragma warning restore CS8622 .BuildRequestExecutorAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { foo { id } }"); - result.ToJson().MatchSnapshot(); - } + result.ToJson().MatchSnapshot(); + } - [Fact] - public async Task Return_Node() - { - Snapshot.FullName(); + [Fact] + public async Task Return_Node() + { + Snapshot.FullName(); - IRequestExecutor executor = await new ServiceCollection() - .AddTransient() - .AddGraphQL() - .AddQueryType() - .AddType() - #pragma warning disable CS8622 + IRequestExecutor executor = await new ServiceCollection() + .AddTransient() + .AddGraphQL() + .AddQueryType() + .AddType() +#pragma warning disable CS8622 .AddTypeConverter(x => x.ToString()) - .AddTypeConverter(x => ObjectId.Parse(x.ToString())) - #pragma warning restore CS8622 + .AddTypeConverter(x => ObjectId.Parse(x.ToString())) +#pragma warning restore CS8622 .AddGlobalObjectIdentification() - .BuildRequestExecutorAsync(); + .BuildRequestExecutorAsync(); - IExecutionResult result = await executor - .ExecuteAsync(@" + IExecutionResult result = await executor + .ExecuteAsync(@" { node(id:""Rm9vCmQ2MGRmMTYyZWQwNzY2ZTE1Y2NlNmIxMGU="") { id } }"); - result.ToJson().MatchSnapshot(); - } + result.ToJson().MatchSnapshot(); + } - public class Query - { - public Foo GetFoo() => new Foo { Id = ObjectId.Parse("507f191e810c19729de860ea") }; - } + public class Query + { + public Foo GetFoo() => new Foo { Id = ObjectId.Parse("507f191e810c19729de860ea") }; + } - public class FooType : ObjectType + public class FooType : ObjectType + { + protected override void Configure(IObjectTypeDescriptor descriptor) { - protected override void Configure(IObjectTypeDescriptor descriptor) - { - descriptor.ImplementsNode() - .IdField(x => x.Id) - .ResolveNode((_, objectId) => Task.FromResult(new Foo { Id = objectId })); - } + descriptor.ImplementsNode() + .IdField(x => x.Id) + .ResolveNode((_, objectId) => Task.FromResult(new Foo { Id = objectId })); } + } - public class Foo - { - [BsonId] - public ObjectId Id { get; set; } - } + public class Foo + { + [BsonId] + public ObjectId Id { get; set; } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/SchemaCache.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/SchemaCache.cs index 6d4db739faf..63cd2b42fc2 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/SchemaCache.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/SchemaCache.cs @@ -4,34 +4,33 @@ using HotChocolate.Execution; using Squadron; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class SchemaCache + : FilterVisitorTestBase + , IDisposable { - public class SchemaCache - : FilterVisitorTestBase - , IDisposable - { - private MongoResource _resource = null!; + private MongoResource _resource = null!; - protected void Init(MongoResource resource) - { - _resource = resource; - } + protected void Init(MongoResource resource) + { + _resource = resource; + } - private readonly ConcurrentDictionary<(Type, Type, object), IRequestExecutor> _cache = - new ConcurrentDictionary<(Type, Type, object), IRequestExecutor>(); + private readonly ConcurrentDictionary<(Type, Type, object), IRequestExecutor> _cache = + new ConcurrentDictionary<(Type, Type, object), IRequestExecutor>(); - public IRequestExecutor CreateSchema(T[] entities, bool withPaging = false) - where T : class - where TType : FilterInputType - { - (Type, Type, T[] entites) key = (typeof(T), typeof(TType), entities); - return _cache.GetOrAdd( - key, - k => base.CreateSchema(entities, _resource, withPaging: withPaging)); - } + public IRequestExecutor CreateSchema(T[] entities, bool withPaging = false) + where T : class + where TType : FilterInputType + { + (Type, Type, T[] entites) key = (typeof(T), typeof(TType), entities); + return _cache.GetOrAdd( + key, + k => base.CreateSchema(entities, _resource, withPaging: withPaging)); + } - public void Dispose() - { - } + public void Dispose() + { } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/VisitorTestBase.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/VisitorTestBase.cs index 84bb1129c22..1c270aaf2e9 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/VisitorTestBase.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Paging.Tests/VisitorTestBase.cs @@ -7,79 +7,78 @@ using MongoDB.Driver; using Squadron; -namespace HotChocolate.Data.MongoDb.Filters +namespace HotChocolate.Data.MongoDb.Filters; + +public class FilterVisitorTestBase { - public class FilterVisitorTestBase - { - protected string? FileName { get; set; } = Guid.NewGuid().ToString("N") + ".db"; + protected string? FileName { get; set; } = Guid.NewGuid().ToString("N") + ".db"; - private Func> BuildResolver( - MongoResource mongoResource, - params TResult[] results) - where TResult : class + private Func> BuildResolver( + MongoResource mongoResource, + params TResult[] results) + where TResult : class + { + if (FileName is null) { - if (FileName is null) - { - throw new InvalidOperationException(); - } + throw new InvalidOperationException(); + } - IMongoCollection collection = - mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + IMongoCollection collection = + mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - collection.InsertMany(results); + collection.InsertMany(results); - return ctx => collection.AsExecutable(); - } + return ctx => collection.AsExecutable(); + } - protected IRequestExecutor CreateSchema( - TEntity[] entities, - MongoResource mongoResource, - bool withPaging = false) - where TEntity : class - where T : FilterInputType - { - Func> resolver = BuildResolver( - mongoResource, - entities); + protected IRequestExecutor CreateSchema( + TEntity[] entities, + MongoResource mongoResource, + bool withPaging = false) + where TEntity : class + where T : FilterInputType + { + Func> resolver = BuildResolver( + mongoResource, + entities); - return new ServiceCollection() - .AddGraphQL() - .AddFiltering(x => x.BindRuntimeType().AddMongoDbDefaults()) - .AddQueryType( - c => c - .Name("Query") - .Field("root") - .Resolve(resolver) - .Use( - next => async context => + return new ServiceCollection() + .AddGraphQL() + .AddFiltering(x => x.BindRuntimeType().AddMongoDbDefaults()) + .AddQueryType( + c => c + .Name("Query") + .Field("root") + .Resolve(resolver) + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseFiltering()) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UseFiltering()) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync() - .GetAwaiter() - .GetResult(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync() + .GetAwaiter() + .GetResult(); } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/Extensions/TestExtensions.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/Extensions/TestExtensions.cs index 6c6cbe0d14d..7a482da550f 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/Extensions/TestExtensions.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/Extensions/TestExtensions.cs @@ -2,22 +2,21 @@ using Snapshooter; using Snapshooter.Xunit; -namespace HotChocolate.Data.MongoDb.Projections +namespace HotChocolate.Data.MongoDb.Projections; + +public static class TestExtensions { - public static class TestExtensions + public static void MatchDocumentSnapshot( + this IExecutionResult? result, + string snapshotName = "") { - public static void MatchDocumentSnapshot( - this IExecutionResult? result, - string snapshotName = "") + if (result is { }) { - if (result is { }) + result.ToJson().MatchSnapshot(snapshotName); + if (result.ContextData is { } && + result.ContextData.TryGetValue("query", out object? queryResult)) { - result.ToJson().MatchSnapshot(snapshotName); - if (result.ContextData is { } && - result.ContextData.TryGetValue("query", out object? queryResult)) - { - queryResult.MatchSnapshot(new SnapshotNameExtension(snapshotName + "_query")); - } + queryResult.MatchSnapshot(new SnapshotNameExtension(snapshotName + "_query")); } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionObjectsTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionObjectsTests.cs index 93f5b336651..4aa8d4ecf1b 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionObjectsTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionObjectsTests.cs @@ -6,13 +6,13 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Projections +namespace HotChocolate.Data.MongoDb.Projections; + +public class MongoDbProjectionObjectTests + : IClassFixture { - public class MongoDbProjectionObjectTests - : IClassFixture + private static readonly BarNullable[] _barWithoutRelation = { - private static readonly BarNullable[] _barWithoutRelation = - { new BarNullable { Number = 2, @@ -33,25 +33,25 @@ public class MongoDbProjectionObjectTests new BarNullable { Number = 2 } }; - private readonly SchemaCache _cache; - - public MongoDbProjectionObjectTests(MongoResource resource) - { - _cache = new SchemaCache(resource); - } - - [Fact] - public async Task Should_NotInitializeObject_When_ResultOfLeftJoinIsNull() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_barWithoutRelation); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - @" + private readonly SchemaCache _cache; + + public MongoDbProjectionObjectTests(MongoResource resource) + { + _cache = new SchemaCache(resource); + } + + [Fact] + public async Task Should_NotInitializeObject_When_ResultOfLeftJoinIsNull() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_barWithoutRelation); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + @" { root { number @@ -60,23 +60,23 @@ public async Task Should_NotInitializeObject_When_ResultOfLeftJoinIsNull() } } }") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task Should_NotInitializeObject_When_ResultOfLeftJoinIsNull_TwoFields() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_barWithoutRelation); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - @" + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task Should_NotInitializeObject_When_ResultOfLeftJoinIsNull_TwoFields() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_barWithoutRelation); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + @" { root { number @@ -85,23 +85,23 @@ public async Task Should_NotInitializeObject_When_ResultOfLeftJoinIsNull_TwoFiel } } }") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task Should_NotInitializeObject_When_ResultOfLeftJoinIsNull_Deep() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_barWithoutRelation); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - @" + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task Should_NotInitializeObject_When_ResultOfLeftJoinIsNull_Deep() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_barWithoutRelation); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + @" { root { number @@ -115,101 +115,100 @@ public async Task Should_NotInitializeObject_When_ResultOfLeftJoinIsNull_Deep() } } }") - .Create()); + .Create()); - res1.MatchDocumentSnapshot(); - } + res1.MatchDocumentSnapshot(); + } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public short BarShort { get; set; } + public short BarShort { get; set; } - public string BarString { get; set; } = string.Empty; + public string BarString { get; set; } = string.Empty; - public BarEnum BarEnum { get; set; } + public BarEnum BarEnum { get; set; } - public bool BarBool { get; set; } + public bool BarBool { get; set; } - public List ObjectArray { get; set; } = default!; + public List ObjectArray { get; set; } = default!; - public BarDeep NestedObject { get; set; } = default!; - } + public BarDeep NestedObject { get; set; } = default!; + } - public class FooDeep - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class FooDeep + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public short BarShort { get; set; } + public short BarShort { get; set; } - public string BarString { get; set; } = string.Empty; - } + public string BarString { get; set; } = string.Empty; + } - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public short? BarShort { get; set; } + public short? BarShort { get; set; } - public string? BarString { get; set; } + public string? BarString { get; set; } - public BarEnum? BarEnum { get; set; } + public BarEnum? BarEnum { get; set; } - public bool? BarBool { get; set; } + public bool? BarBool { get; set; } - public List? ObjectArray { get; set; } + public List? ObjectArray { get; set; } - public BarNullableDeep? NestedObject { get; set; } - } + public BarNullableDeep? NestedObject { get; set; } + } - public class Bar - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Bar + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public Foo Foo { get; set; } = default!; + public Foo Foo { get; set; } = default!; - public int Number { get; set; } - } + public int Number { get; set; } + } - public class BarDeep - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class BarDeep + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public FooDeep Foo { get; set; } = default!; - } + public FooDeep Foo { get; set; } = default!; + } - public class BarNullableDeep - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class BarNullableDeep + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public FooDeep? Foo { get; set; } + public FooDeep? Foo { get; set; } - public int Number { get; set; } - } + public int Number { get; set; } + } - public class BarNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class BarNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public FooNullable? Foo { get; set; } + public FooNullable? Foo { get; set; } - public int Number { get; set; } - } + public int Number { get; set; } + } - public enum BarEnum - { - FOO, - BAR, - BAZ, - QUX - } + public enum BarEnum + { + FOO, + BAR, + BAZ, + QUX } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorIsProjectedTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorIsProjectedTests.cs index 785037fc2d2..cf6700b03c1 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorIsProjectedTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorIsProjectedTests.cs @@ -6,116 +6,115 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Projections +namespace HotChocolate.Data.MongoDb.Projections; + +public class MongoDbProjectionVisitorIsProjectedTests + : IClassFixture { - public class MongoDbProjectionVisitorIsProjectedTests - : IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { IsProjectedTrue = true, IsProjectedFalse = false }, new Foo { IsProjectedTrue = true, IsProjectedFalse = false } }; - private static readonly Bar[] _barEntities = - { + private static readonly Bar[] _barEntities = + { new Bar { IsProjectedFalse = false }, new Bar { IsProjectedFalse = false } }; - private readonly SchemaCache _cache; - - public MongoDbProjectionVisitorIsProjectedTests(MongoResource resource) - { - _cache = new SchemaCache(resource); - } - - [Fact] - public async Task IsProjected_Should_NotBeProjectedWhenSelected_When_FalseWithOneProps() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root { isProjectedFalse }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task IsProjected_Should_NotBeProjectedWhenSelected_When_FalseWithTwoProps() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root { isProjectedFalse isProjectedTrue }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task IsProjected_Should_AlwaysBeProjectedWhenSelected_When_True() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root { isProjectedFalse }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task IsProjected_Should_NotFailWhenSelectionSetSkippedCompletely() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_barEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root { isProjectedFalse }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - [IsProjected(true)] - public bool? IsProjectedTrue { get; set; } - - [IsProjected(false)] - public bool? IsProjectedFalse { get; set; } - - public bool? ShouldNeverBeProjected { get; set; } - } - - public class Bar - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - [IsProjected(false)] - public bool? IsProjectedFalse { get; set; } - - public bool? ShouldNeverBeProjected { get; set; } - } + private readonly SchemaCache _cache; + + public MongoDbProjectionVisitorIsProjectedTests(MongoResource resource) + { + _cache = new SchemaCache(resource); + } + + [Fact] + public async Task IsProjected_Should_NotBeProjectedWhenSelected_When_FalseWithOneProps() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root { isProjectedFalse }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task IsProjected_Should_NotBeProjectedWhenSelected_When_FalseWithTwoProps() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root { isProjectedFalse isProjectedTrue }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task IsProjected_Should_AlwaysBeProjectedWhenSelected_When_True() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root { isProjectedFalse }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task IsProjected_Should_NotFailWhenSelectionSetSkippedCompletely() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_barEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root { isProjectedFalse }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + [IsProjected(true)] + public bool? IsProjectedTrue { get; set; } + + [IsProjected(false)] + public bool? IsProjectedFalse { get; set; } + + public bool? ShouldNeverBeProjected { get; set; } + } + + public class Bar + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + [IsProjected(false)] + public bool? IsProjectedFalse { get; set; } + + public bool? ShouldNeverBeProjected { get; set; } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorPagingTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorPagingTests.cs index 4ce1cf7152d..6c84709f2b9 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorPagingTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorPagingTests.cs @@ -7,391 +7,390 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Projections +namespace HotChocolate.Data.MongoDb.Projections; + +public class MongoDbProjectionVisitorPagingTests + : IClassFixture { - public class MongoDbProjectionVisitorPagingTests - : IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = true, Baz = "a" }, new Foo { Bar = false, Baz = "b" } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new FooNullable { Bar = true, Baz = "a" }, new FooNullable { Bar = null, Baz = null }, new FooNullable { Bar = false, Baz = "c" } }; - private readonly SchemaCache _cache; - - public MongoDbProjectionVisitorPagingTests(MongoResource resource) - { - _cache = new SchemaCache(resource); - } - - [Fact] - public async Task Create_ProjectsTwoProperties_Nodes() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ nodes { bar baz } }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task Create_ProjectsOneProperty_Nodes() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ nodes { baz } }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task Create_ProjectsTwoProperties_Edges() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ edges { node { bar baz }} }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task Create_ProjectsOneProperty_Edges() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ edges { node { baz }} }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task Create_ProjectsTwoProperties_EdgesAndNodes() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ nodes{ baz } edges { node { bar }} }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task Create_ProjectsOneProperty_EdgesAndNodesOverlap() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ nodes{ baz } edges { node { baz }} }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateNullable_ProjectsTwoProperties_Nodes() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ nodes { bar baz } }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateNullable_ProjectsOneProperty_Nodes() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ nodes { baz } }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateNullable_ProjectsTwoProperties_Edges() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ edges { node { bar baz }} }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateNullable_ProjectsOneProperty_Edges() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ edges { node { baz }} }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateNullable_ProjectsTwoProperties_EdgesAndNodes() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ nodes{ baz } edges { node { bar }} }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateNullable_ProjectsOneProperty_EdgesAndNodesOverlap() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ nodes{ baz } edges { node { baz }} }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task Create_Projection_Should_Stop_When_UseProjectionEncountered() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ nodes{ bar list { barBaz } } }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateOffsetPaging_ProjectsTwoProperties_Items_WithArgs() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, useOffsetPaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(take:10, skip:1) { items { bar baz } } }") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateOffsetPaging_ProjectsTwoProperties_Items() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, useOffsetPaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ items { bar baz } }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateOffsetPaging_ProjectsOneProperty_Items() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, useOffsetPaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ items { baz } }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - - [Fact] - public async Task CreateOffsetPagingNullable_ProjectsTwoProperties_Items() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema( - _fooNullableEntities, - useOffsetPaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ items { bar baz } }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateOffsetPagingNullable_ProjectsOneProperty_Items() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema( - _fooNullableEntities, - useOffsetPaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ items { baz } }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateOffsetPaging_Projection_Should_Stop_When_UseProjectionEncountered() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, useOffsetPaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ items{ bar list { barBaz } } }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task CreateOffsetPaging_Projection_Should_Stop_When_UsePagingEncountered() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities, useOffsetPaging: true); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ items{ bar paging { nodes {barBaz }} } }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public bool Bar { get; set; } - - public string Baz { get; set; } = default!; - - public string? Qux { get; set; } - - public List? List { get; set; } - - [UsePaging] - public List? Paging { get; set; } - } - - public class Bar - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public string? BarBaz { get; set; } - - public string? BarQux { get; set; } - } - - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public bool? Bar { get; set; } - - public string? Baz { get; set; } - } + private readonly SchemaCache _cache; + + public MongoDbProjectionVisitorPagingTests(MongoResource resource) + { + _cache = new SchemaCache(resource); + } + + [Fact] + public async Task Create_ProjectsTwoProperties_Nodes() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ nodes { bar baz } }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task Create_ProjectsOneProperty_Nodes() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ nodes { baz } }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task Create_ProjectsTwoProperties_Edges() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ edges { node { bar baz }} }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task Create_ProjectsOneProperty_Edges() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ edges { node { baz }} }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task Create_ProjectsTwoProperties_EdgesAndNodes() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ nodes{ baz } edges { node { bar }} }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task Create_ProjectsOneProperty_EdgesAndNodesOverlap() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ nodes{ baz } edges { node { baz }} }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateNullable_ProjectsTwoProperties_Nodes() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ nodes { bar baz } }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateNullable_ProjectsOneProperty_Nodes() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ nodes { baz } }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateNullable_ProjectsTwoProperties_Edges() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ edges { node { bar baz }} }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateNullable_ProjectsOneProperty_Edges() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ edges { node { baz }} }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateNullable_ProjectsTwoProperties_EdgesAndNodes() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ nodes{ baz } edges { node { bar }} }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateNullable_ProjectsOneProperty_EdgesAndNodesOverlap() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooNullableEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ nodes{ baz } edges { node { baz }} }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task Create_Projection_Should_Stop_When_UseProjectionEncountered() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, usePaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ nodes{ bar list { barBaz } } }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateOffsetPaging_ProjectsTwoProperties_Items_WithArgs() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, useOffsetPaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(take:10, skip:1) { items { bar baz } } }") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateOffsetPaging_ProjectsTwoProperties_Items() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, useOffsetPaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ items { bar baz } }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateOffsetPaging_ProjectsOneProperty_Items() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, useOffsetPaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ items { baz } }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + + [Fact] + public async Task CreateOffsetPagingNullable_ProjectsTwoProperties_Items() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema( + _fooNullableEntities, + useOffsetPaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ items { bar baz } }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateOffsetPagingNullable_ProjectsOneProperty_Items() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema( + _fooNullableEntities, + useOffsetPaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ items { baz } }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateOffsetPaging_Projection_Should_Stop_When_UseProjectionEncountered() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, useOffsetPaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ items{ bar list { barBaz } } }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task CreateOffsetPaging_Projection_Should_Stop_When_UsePagingEncountered() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities, useOffsetPaging: true); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ items{ bar paging { nodes {barBaz }} } }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public bool Bar { get; set; } + + public string Baz { get; set; } = default!; + + public string? Qux { get; set; } + + public List? List { get; set; } + + [UsePaging] + public List? Paging { get; set; } + } + + public class Bar + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public string? BarBaz { get; set; } + + public string? BarQux { get; set; } + } + + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public bool? Bar { get; set; } + + public string? Baz { get; set; } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorScalarTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorScalarTests.cs index 0dad027a832..d610d169b2e 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorScalarTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/MongoDbProjectionVisitorScalarTests.cs @@ -6,90 +6,89 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Projections +namespace HotChocolate.Data.MongoDb.Projections; + +public class MongoDbProjectionVisitorScalarTests + : IClassFixture { - public class MongoDbProjectionVisitorScalarTests - : IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = true, Baz = "a" }, new Foo { Bar = false, Baz = "b" } }; - private readonly SchemaCache _cache; - - public MongoDbProjectionVisitorScalarTests(MongoResource resource) - { - _cache = new SchemaCache(resource); - } - - [Fact] - public async Task Create_ProjectsTwoProperties_Expression() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ bar baz }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task Create_ProjectsOneProperty_Expression() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema(_fooEntities); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ baz }}") - .Create()); - - res1.MatchDocumentSnapshot(); - } - - [Fact] - public async Task Create_ProjectsOneProperty_WithResolver() - { - // arrange - IRequestExecutor tester = _cache.CreateSchema( - _fooEntities, - objectType: new ObjectType( - x => x - .Field("foo") - .Resolve( - new[] - { + private readonly SchemaCache _cache; + + public MongoDbProjectionVisitorScalarTests(MongoResource resource) + { + _cache = new SchemaCache(resource); + } + + [Fact] + public async Task Create_ProjectsTwoProperties_Expression() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ bar baz }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task Create_ProjectsOneProperty_Expression() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema(_fooEntities); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ baz }}") + .Create()); + + res1.MatchDocumentSnapshot(); + } + + [Fact] + public async Task Create_ProjectsOneProperty_WithResolver() + { + // arrange + IRequestExecutor tester = _cache.CreateSchema( + _fooEntities, + objectType: new ObjectType( + x => x + .Field("foo") + .Resolve( + new[] + { "foo" - }) - .Type>())); + }) + .Type>())); - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root{ baz foo }}") - .Create()); + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root{ baz foo }}") + .Create()); - res1.MatchDocumentSnapshot(); - } + res1.MatchDocumentSnapshot(); + } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public bool Bar { get; set; } + public bool Bar { get; set; } - public string Baz { get; set; } = default!; - } + public string Baz { get; set; } = default!; } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/ProjectionVisitorTestBase.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/ProjectionVisitorTestBase.cs index 407650b9cac..2d4114d7e54 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/ProjectionVisitorTestBase.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/ProjectionVisitorTestBase.cs @@ -6,115 +6,114 @@ using MongoDB.Driver; using Squadron; -namespace HotChocolate.Data.MongoDb.Projections +namespace HotChocolate.Data.MongoDb.Projections; + +public class ProjectionVisitorTestBase { - public class ProjectionVisitorTestBase + private Func> BuildResolver( + MongoResource mongoResource, + params TResult[] results) + where TResult : class { - private Func> BuildResolver( - MongoResource mongoResource, - params TResult[] results) - where TResult : class - { - IMongoCollection collection = - mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + IMongoCollection collection = + mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - collection.InsertMany(results); + collection.InsertMany(results); - return ctx => collection.AsExecutable(); - } + return ctx => collection.AsExecutable(); + } - protected T[] CreateEntity(params T[] entities) => entities; + protected T[] CreateEntity(params T[] entities) => entities; - public IRequestExecutor CreateSchema( - TEntity[] entities, - MongoResource mongoResource, - bool usePaging = false, - bool useOffsetPaging = false, - ObjectType? objectType = null) - where TEntity : class - { - Func> resolver = BuildResolver( - mongoResource, - entities); + public IRequestExecutor CreateSchema( + TEntity[] entities, + MongoResource mongoResource, + bool usePaging = false, + bool useOffsetPaging = false, + ObjectType? objectType = null) + where TEntity : class + { + Func> resolver = BuildResolver( + mongoResource, + entities); - var builder = new ServiceCollection().AddGraphQL(); + var builder = new ServiceCollection().AddGraphQL(); - if (objectType is {}) - { - builder.AddType(objectType); - } + if (objectType is { }) + { + builder.AddType(objectType); + } - return builder - .AddMongoDbProjections() - .AddObjectIdConverters() - .AddMongoDbFiltering() - .AddMongoDbSorting() - .AddMongoDbPagingProviders() - .AddQueryType( - new ObjectType>( - c => - { - c.Name("Query"); - ApplyConfigurationToFieldDescriptor( - c.Field(x => x.Root).Resolve(resolver), - usePaging, - useOffsetPaging); - })) - .UseRequest( - next => async context => + return builder + .AddMongoDbProjections() + .AddObjectIdConverters() + .AddMongoDbFiltering() + .AddMongoDbSorting() + .AddMongoDbPagingProviders() + .AddQueryType( + new ObjectType>( + c => { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .ModifyRequestOptions(x => x.IncludeExceptionDetails = true) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync() - .Result; - } + c.Name("Query"); + ApplyConfigurationToFieldDescriptor( + c.Field(x => x.Root).Resolve(resolver), + usePaging, + useOffsetPaging); + })) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) + { + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .ModifyRequestOptions(x => x.IncludeExceptionDetails = true) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync() + .Result; + } - private static void ApplyConfigurationToFieldDescriptor( - IObjectFieldDescriptor descriptor, - bool usePaging = false, - bool useOffsetPaging = false) + private static void ApplyConfigurationToFieldDescriptor( + IObjectFieldDescriptor descriptor, + bool usePaging = false, + bool useOffsetPaging = false) + { + if (usePaging) { - if (usePaging) - { - descriptor.UsePaging>(); - } - - if (useOffsetPaging) - { - descriptor.UseOffsetPaging>(); - } - - descriptor - .Use( - next => async context => - { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseProjection() - .UseFiltering() - .UseSorting(); + descriptor.UsePaging>(); } - public class StubObject + if (useOffsetPaging) { - public T Root { get; set; } = default!; + descriptor.UseOffsetPaging>(); } + + descriptor + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) + { + context.ContextData["query"] = executable.Print(); + } + }) + .UseProjection() + .UseFiltering() + .UseSorting(); + } + + public class StubObject + { + public T Root { get; set; } = default!; } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/SchemaCache.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/SchemaCache.cs index a468d725675..82988dc4b50 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/SchemaCache.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Projections.Tests/SchemaCache.cs @@ -4,41 +4,40 @@ using HotChocolate.Types; using Squadron; -namespace HotChocolate.Data.MongoDb.Projections +namespace HotChocolate.Data.MongoDb.Projections; + +public class SchemaCache + : ProjectionVisitorTestBase + , IDisposable { - public class SchemaCache - : ProjectionVisitorTestBase - , IDisposable - { - private readonly ConcurrentDictionary<(Type, object), IRequestExecutor> _cache = new(); + private readonly ConcurrentDictionary<(Type, object), IRequestExecutor> _cache = new(); - private readonly MongoResource _resource; + private readonly MongoResource _resource; - public SchemaCache(MongoResource resource) - { - _resource = resource; - } + public SchemaCache(MongoResource resource) + { + _resource = resource; + } - public IRequestExecutor CreateSchema( - T[] entities, - bool usePaging = false, - bool useOffsetPaging = false, - ObjectType? objectType = null) - where T : class - { - (Type, T[] entites) key = (typeof(T), entities); - return _cache.GetOrAdd( - key, - _ => base.CreateSchema( - entities, - usePaging: usePaging, - useOffsetPaging: useOffsetPaging, - mongoResource: _resource, - objectType: objectType)); - } + public IRequestExecutor CreateSchema( + T[] entities, + bool usePaging = false, + bool useOffsetPaging = false, + ObjectType? objectType = null) + where T : class + { + (Type, T[] entites) key = (typeof(T), entities); + return _cache.GetOrAdd( + key, + _ => base.CreateSchema( + entities, + usePaging: usePaging, + useOffsetPaging: useOffsetPaging, + mongoResource: _resource, + objectType: objectType)); + } - public void Dispose() - { - } + public void Dispose() + { } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/Extensions/TestExtensions.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/Extensions/TestExtensions.cs index 1abbbf76aa1..69993d48d70 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/Extensions/TestExtensions.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/Extensions/TestExtensions.cs @@ -2,24 +2,23 @@ using Snapshooter; using Snapshooter.Xunit; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public static class TestExtensions { - public static class TestExtensions + public static void MatchDocumentSnapshot( + this IExecutionResult? result, + string snapshotName) { - public static void MatchDocumentSnapshot( - this IExecutionResult? result, - string snapshotName) + if (result is { }) { - if (result is { }) + if (result.ContextData is { } && + result.ContextData.TryGetValue("query", out object? queryResult)) { - if (result.ContextData is { } && - result.ContextData.TryGetValue("query", out object? queryResult)) - { - queryResult.MatchSnapshot(new SnapshotNameExtension(snapshotName + "_query")); - } - - result.ToJson().MatchSnapshot(new SnapshotNameExtension(snapshotName)); + queryResult.MatchSnapshot(new SnapshotNameExtension(snapshotName + "_query")); } + + result.ToJson().MatchSnapshot(new SnapshotNameExtension(snapshotName)); } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbAggregateFluentTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbAggregateFluentTests.cs index 458fe1a5553..4e697ba0476 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbAggregateFluentTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbAggregateFluentTests.cs @@ -12,154 +12,153 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbAggregateFluentTests : IClassFixture { - public class MongoDbAggregateFluentTests : IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = true }, new Foo { Bar = false } }; - private static readonly Bar[] _barEntities = - { + private static readonly Bar[] _barEntities = + { new Bar { Baz = new DateTimeOffset(2020, 1, 12, 0, 0, 0, TimeSpan.Zero) }, new Bar { Baz = new DateTimeOffset(2020, 1, 11, 0, 0, 0, TimeSpan.Zero) } }; - private readonly MongoResource _resource; + private readonly MongoResource _resource; - public MongoDbAggregateFluentTests(MongoResource resource) - { - _resource = resource; - } + public MongoDbAggregateFluentTests(MongoResource resource) + { + _resource = resource; + } - [Fact] - public async Task BsonElement_Rename() - { - // arrange - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_fooEntities); - return collection.Aggregate().AsExecutable(); - }); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: ASC}){ bar}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: DESC}){ bar}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - [Fact] - public async Task Collection_Configuration() - { - // arrange - BsonClassMap.RegisterClassMap( - x => x.MapField(y => y.Baz) - .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) - .SetElementName("testName")); - - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_barEntities); - return collection.Aggregate().AsExecutable(); - }); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { baz: ASC}){ baz}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { baz: DESC}){ baz}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - [BsonElement("renameTest")] - public bool Bar { get; set; } - } - - public class Bar - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public DateTimeOffset Baz { get; set; } - } - - private static IRequestExecutor CreateSchema( - Func> resolver) - where TEntity : class - { - return new ServiceCollection() - .AddGraphQL() - .AddSorting(x => x.AddMongoDbDefaults()) - .AddQueryType( - c => c - .Name("Query") - .Field("root") - .Type>>() - .Resolve( - async ctx => await new ValueTask>(resolver())) - .Use( - next => async context => + [Fact] + public async Task BsonElement_Rename() + { + // arrange + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_fooEntities); + return collection.Aggregate().AsExecutable(); + }); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: ASC}){ bar}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: DESC}){ bar}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + [Fact] + public async Task Collection_Configuration() + { + // arrange + BsonClassMap.RegisterClassMap( + x => x.MapField(y => y.Baz) + .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) + .SetElementName("testName")); + + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_barEntities); + return collection.Aggregate().AsExecutable(); + }); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { baz: ASC}){ baz}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { baz: DESC}){ baz}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + [BsonElement("renameTest")] + public bool Bar { get; set; } + } + + public class Bar + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public DateTimeOffset Baz { get; set; } + } + + private static IRequestExecutor CreateSchema( + Func> resolver) + where TEntity : class + { + return new ServiceCollection() + .AddGraphQL() + .AddSorting(x => x.AddMongoDbDefaults()) + .AddQueryType( + c => c + .Name("Query") + .Field("root") + .Type>>() + .Resolve( + async ctx => await new ValueTask>(resolver())) + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseSorting>()) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UseSorting>()) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out object? queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out object? queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync() - .GetAwaiter() - .GetResult(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync() + .GetAwaiter() + .GetResult(); } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbCollectionTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbCollectionTests.cs index 042f21dd7d0..7b237848c0b 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbCollectionTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbCollectionTests.cs @@ -12,154 +12,153 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbSortCollectionTests : IClassFixture { - public class MongoDbSortCollectionTests : IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = true }, new Foo { Bar = false } }; - private static readonly Bar[] _barEntities = - { + private static readonly Bar[] _barEntities = + { new Bar { Baz = new DateTimeOffset(2020, 1, 12, 0, 0, 0, TimeSpan.Zero) }, new Bar { Baz = new DateTimeOffset(2020, 1, 11, 0, 0, 0, TimeSpan.Zero) } }; - private readonly MongoResource _resource; + private readonly MongoResource _resource; - public MongoDbSortCollectionTests(MongoResource resource) - { - _resource = resource; - } + public MongoDbSortCollectionTests(MongoResource resource) + { + _resource = resource; + } - [Fact] - public async Task BsonElement_Rename() - { - // arrange - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_fooEntities); - return collection.AsExecutable(); - }); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: ASC}){ bar}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: DESC}){ bar}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - [Fact] - public async Task Collection_Configuration() - { - // arrange - BsonClassMap.RegisterClassMap( - x => x.MapField(y => y.Baz) - .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) - .SetElementName("testName")); - - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_barEntities); - return collection.AsExecutable(); - }); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { baz: ASC}){ baz}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { baz: DESC}){ baz}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - [BsonElement("renameTest")] - public bool Bar { get; set; } - } - - public class Bar - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public DateTimeOffset Baz { get; set; } - } - - private static IRequestExecutor CreateSchema( - Func> resolver) - where TEntity : class - { - return new ServiceCollection() - .AddGraphQL() - .AddSorting(x => x.AddMongoDbDefaults()) - .AddQueryType( - c => c - .Name("Query") - .Field("root") - .Type>>() - .Resolve( - async ctx => await new ValueTask>(resolver())) - .Use( - next => async context => + [Fact] + public async Task BsonElement_Rename() + { + // arrange + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_fooEntities); + return collection.AsExecutable(); + }); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: ASC}){ bar}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: DESC}){ bar}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + [Fact] + public async Task Collection_Configuration() + { + // arrange + BsonClassMap.RegisterClassMap( + x => x.MapField(y => y.Baz) + .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) + .SetElementName("testName")); + + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_barEntities); + return collection.AsExecutable(); + }); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { baz: ASC}){ baz}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { baz: DESC}){ baz}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + [BsonElement("renameTest")] + public bool Bar { get; set; } + } + + public class Bar + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public DateTimeOffset Baz { get; set; } + } + + private static IRequestExecutor CreateSchema( + Func> resolver) + where TEntity : class + { + return new ServiceCollection() + .AddGraphQL() + .AddSorting(x => x.AddMongoDbDefaults()) + .AddQueryType( + c => c + .Name("Query") + .Field("root") + .Type>>() + .Resolve( + async ctx => await new ValueTask>(resolver())) + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseSorting>()) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UseSorting>()) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync() - .GetAwaiter() - .GetResult(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync() + .GetAwaiter() + .GetResult(); } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbFindFluentTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbFindFluentTests.cs index 033c5816dca..99a97bdd88a 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbFindFluentTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbFindFluentTests.cs @@ -12,206 +12,205 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbFindFluentTests : IClassFixture { - public class MongoDbFindFluentTests : IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = true }, new Foo { Bar = false } }; - private static readonly Bar[] _barEntities = - { + private static readonly Bar[] _barEntities = + { new Bar { Baz = new DateTimeOffset(2020, 1, 12, 0, 0, 0, TimeSpan.Zero) }, new Bar { Baz = new DateTimeOffset(2020, 1, 11, 0, 0, 0, TimeSpan.Zero) } }; - private static readonly Baz[] _bazEntities = - { + private static readonly Baz[] _bazEntities = + { new Baz { Bar = new DateTimeOffset(2020, 1, 12, 0, 0, 0, TimeSpan.Zero), Qux = 1 }, new Baz { Bar = new DateTimeOffset(2020, 1, 11, 0, 0, 0, TimeSpan.Zero), Qux = 0 }, new Baz { Bar = new DateTimeOffset(1996, 1, 11, 0, 0, 0, TimeSpan.Zero), Qux = -1 } }; - private readonly MongoResource _resource; + private readonly MongoResource _resource; - public MongoDbFindFluentTests(MongoResource resource) - { - _resource = resource; - } + public MongoDbFindFluentTests(MongoResource resource) + { + _resource = resource; + } - [Fact] - public async Task BsonElement_Rename() - { - // arrange - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_fooEntities); - return collection.Find(FilterDefinition.Empty).AsExecutable(); - }); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: ASC}){ bar}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: DESC}){ bar}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - [Fact] - public async Task Collection_Configuration() - { - // arrange - BsonClassMap.RegisterClassMap( - x => x.MapField(y => y.Baz) - .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) - .SetElementName("testName")); - - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_barEntities); - return collection.Find(FilterDefinition.Empty).AsExecutable(); - }); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { baz: ASC}){ baz}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { baz: DESC}){ baz}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - [Fact] - public async Task FindFluent_CombineQuery() - { - // arrange - IRequestExecutor tester = CreateSchema( - () => - { - IMongoCollection collection = - _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - - collection.InsertMany(_bazEntities); - - return collection - .Find(x => x.Bar > new DateTimeOffset(2000, 1, 1, 0, 0, 0, TimeSpan.Zero)) - .Sort(Builders.Sort.Ascending(x => x.Qux)) - .AsExecutable(); - }); - - // act - // assert - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: ASC}){ bar}}") - .Create()); - - res1.MatchDocumentSnapshot("ASC"); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: DESC}){ bar}}") - .Create()); - - res2.MatchDocumentSnapshot("DESC"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - [BsonElement("renameTest")] - public bool Bar { get; set; } - } - - public class Bar - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public DateTimeOffset Baz { get; set; } - } - - public class Baz - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public DateTimeOffset Bar { get; set; } - - public int Qux { get; set; } - } - - private static IRequestExecutor CreateSchema( - Func> resolver) - where TEntity : class - { - return new ServiceCollection() - .AddGraphQL() - .AddSorting(x => x.AddMongoDbDefaults()) - .AddQueryType( - c => c - .Name("Query") - .Field("root") - .Type>>() - .Resolve( - async ctx => await new ValueTask>(resolver())) - .Use( - next => async context => + [Fact] + public async Task BsonElement_Rename() + { + // arrange + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_fooEntities); + return collection.Find(FilterDefinition.Empty).AsExecutable(); + }); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: ASC}){ bar}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: DESC}){ bar}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + [Fact] + public async Task Collection_Configuration() + { + // arrange + BsonClassMap.RegisterClassMap( + x => x.MapField(y => y.Baz) + .SetSerializer(new DateTimeOffsetSerializer(BsonType.String)) + .SetElementName("testName")); + + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_barEntities); + return collection.Find(FilterDefinition.Empty).AsExecutable(); + }); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { baz: ASC}){ baz}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { baz: DESC}){ baz}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + [Fact] + public async Task FindFluent_CombineQuery() + { + // arrange + IRequestExecutor tester = CreateSchema( + () => + { + IMongoCollection collection = + _resource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + + collection.InsertMany(_bazEntities); + + return collection + .Find(x => x.Bar > new DateTimeOffset(2000, 1, 1, 0, 0, 0, TimeSpan.Zero)) + .Sort(Builders.Sort.Ascending(x => x.Qux)) + .AsExecutable(); + }); + + // act + // assert + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: ASC}){ bar}}") + .Create()); + + res1.MatchDocumentSnapshot("ASC"); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: DESC}){ bar}}") + .Create()); + + res2.MatchDocumentSnapshot("DESC"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + [BsonElement("renameTest")] + public bool Bar { get; set; } + } + + public class Bar + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public DateTimeOffset Baz { get; set; } + } + + public class Baz + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public DateTimeOffset Bar { get; set; } + + public int Qux { get; set; } + } + + private static IRequestExecutor CreateSchema( + Func> resolver) + where TEntity : class + { + return new ServiceCollection() + .AddGraphQL() + .AddSorting(x => x.AddMongoDbDefaults()) + .AddQueryType( + c => c + .Name("Query") + .Field("root") + .Type>>() + .Resolve( + async ctx => await new ValueTask>(resolver())) + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseSorting>()) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UseSorting>()) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync() - .GetAwaiter() - .GetResult(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync() + .GetAwaiter() + .GetResult(); } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorBooleanTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorBooleanTests.cs index cf27b845d6f..be67021ef52 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorBooleanTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorBooleanTests.cs @@ -6,98 +6,97 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbSortVisitorBooleanTests + : SchemaCache, + IClassFixture { - public class MongoDbSortVisitorBooleanTests - : SchemaCache, - IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = true }, new Foo { Bar = false } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new FooNullable { Bar = true }, new FooNullable { Bar = null }, new FooNullable { Bar = false } }; - public MongoDbSortVisitorBooleanTests(MongoResource resource) - { - Init(resource); - } - - [Fact] - public async Task Create_Boolean_OrderBy() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: ASC}){ bar}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: DESC}){ bar}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - [Fact] - public async Task Create_Boolean_OrderBy_Nullable() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: ASC}){ bar}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: DESC}){ bar}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public bool Bar { get; set; } - } - - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public bool? Bar { get; set; } - } - - public class FooSortType - : SortInputType - { - } - - public class FooNullableSortType - : SortInputType - { - } + public MongoDbSortVisitorBooleanTests(MongoResource resource) + { + Init(resource); + } + + [Fact] + public async Task Create_Boolean_OrderBy() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: ASC}){ bar}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: DESC}){ bar}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + [Fact] + public async Task Create_Boolean_OrderBy_Nullable() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: ASC}){ bar}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: DESC}){ bar}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public bool Bar { get; set; } + } + + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public bool? Bar { get; set; } + } + + public class FooSortType + : SortInputType + { + } + + public class FooNullableSortType + : SortInputType + { } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorComparableTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorComparableTests.cs index 8a68bc62304..16febcaf2cc 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorComparableTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorComparableTests.cs @@ -6,110 +6,109 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbSortVisitorComparableTests + : SchemaCache, + IClassFixture { - public class MongoDbSortVisitorComparableTests - : SchemaCache, - IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { BarShort = 12 }, new Foo { BarShort = 14 }, new Foo { BarShort = 13 } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new FooNullable { BarShort = 12 }, new FooNullable { BarShort = null }, new FooNullable { BarShort = 14 }, new FooNullable { BarShort = 13 } }; - public MongoDbSortVisitorComparableTests(MongoResource resource) - { - Init(resource); - } - - [Fact] - public async Task Create_Short_OrderBy() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { barShort: ASC}){ barShort}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { barShort: DESC}){ barShort}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - [Fact] - public async Task Create_Short_OrderBy_Nullable() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { barShort: ASC}){ barShort}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { barShort: DESC}){ barShort}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public short BarShort { get; set; } - - public int BarInt { get; set; } - - public long BarLong { get; set; } - - public float BarFloat { get; set; } - - public double BarDouble { get; set; } - - public decimal BarDecimal { get; set; } - } - - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - public short? BarShort { get; set; } - } - - public class FooSortType - : SortInputType - { - } - - public class FooNullableSortType - : SortInputType - { - } + public MongoDbSortVisitorComparableTests(MongoResource resource) + { + Init(resource); + } + + [Fact] + public async Task Create_Short_OrderBy() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { barShort: ASC}){ barShort}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { barShort: DESC}){ barShort}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + [Fact] + public async Task Create_Short_OrderBy_Nullable() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { barShort: ASC}){ barShort}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { barShort: DESC}){ barShort}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public short BarShort { get; set; } + + public int BarInt { get; set; } + + public long BarLong { get; set; } + + public float BarFloat { get; set; } + + public double BarDouble { get; set; } + + public decimal BarDecimal { get; set; } + } + + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + public short? BarShort { get; set; } + } + + public class FooSortType + : SortInputType + { + } + + public class FooNullableSortType + : SortInputType + { } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorEnumTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorEnumTests.cs index e5be57ca953..e2c02147361 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorEnumTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorEnumTests.cs @@ -6,22 +6,22 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbSortVisitorEnumTests + : SchemaCache, + IClassFixture { - public class MongoDbSortVisitorEnumTests - : SchemaCache, - IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { BarEnum = FooEnum.BAR }, new Foo { BarEnum = FooEnum.BAZ }, new Foo { BarEnum = FooEnum.FOO }, new Foo { BarEnum = FooEnum.QUX } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new FooNullable { BarEnum = FooEnum.BAR }, new FooNullable { BarEnum = FooEnum.BAZ }, new FooNullable { BarEnum = FooEnum.FOO }, @@ -29,89 +29,88 @@ public class MongoDbSortVisitorEnumTests new FooNullable { BarEnum = FooEnum.QUX } }; - public MongoDbSortVisitorEnumTests( - MongoResource resource) - { - Init(resource); - } - - [Fact] - public async Task Create_Enum_OrderBy() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { barEnum: ASC}){ barEnum}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { barEnum: DESC}){ barEnum}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - [Fact] - public async Task Create_Enum_OrderBy_Nullable() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { barEnum: ASC}){ barEnum}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { barEnum: DESC}){ barEnum}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public FooEnum BarEnum { get; set; } - } - - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public FooEnum? BarEnum { get; set; } - } - - public enum FooEnum - { - FOO, - BAR, - BAZ, - QUX - } - - public class FooSortType - : SortInputType - { - } - - public class FooNullableSortType - : SortInputType - { - } + public MongoDbSortVisitorEnumTests( + MongoResource resource) + { + Init(resource); + } + + [Fact] + public async Task Create_Enum_OrderBy() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { barEnum: ASC}){ barEnum}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { barEnum: DESC}){ barEnum}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + [Fact] + public async Task Create_Enum_OrderBy_Nullable() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { barEnum: ASC}){ barEnum}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { barEnum: DESC}){ barEnum}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public FooEnum BarEnum { get; set; } + } + + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public FooEnum? BarEnum { get; set; } + } + + public enum FooEnum + { + FOO, + BAR, + BAZ, + QUX + } + + public class FooSortType + : SortInputType + { + } + + public class FooNullableSortType + : SortInputType + { } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorObjectTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorObjectTests.cs index 115bd4cf5f8..f7e7ded49af 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorObjectTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorObjectTests.cs @@ -7,14 +7,14 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbSortVisitorObjectTests + : SchemaCache, + IClassFixture { - public class MongoDbSortVisitorObjectTests - : SchemaCache, - IClassFixture + private static readonly Bar[] _barEntities = { - private static readonly Bar[] _barEntities = - { new Bar { Foo = new Foo @@ -56,8 +56,8 @@ public class MongoDbSortVisitorObjectTests } }; - private static readonly BarNullable?[] _barNullableEntities = - { + private static readonly BarNullable?[] _barNullableEntities = + { new BarNullable { Foo = new FooNullable @@ -114,293 +114,292 @@ public class MongoDbSortVisitorObjectTests new BarNullable { Foo = null } }; - public MongoDbSortVisitorObjectTests(MongoResource resource) - { - Init(resource); - } - - [Fact] - public async Task Create_ObjectShort_OrderBy() - { - // arrange - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barShort: ASC}}) " + - "{ foo{ barShort}}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barShort: DESC}}) " + - "{ foo{ barShort}}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - [Fact] - public async Task Create_ObjectNullableShort_OrderBy() - { - // arrange - IRequestExecutor? tester = - CreateSchema(_barNullableEntities!); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barShort: ASC}}) " + - "{ foo{ barShort}}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barShort: DESC}}) " + - "{ foo{ barShort}}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("13"); - } - - [Fact] - public async Task Create_ObjectEnum_OrderBy() - { - // arrange - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barEnum: ASC}}) " + - "{ foo{ barEnum}}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barEnum: DESC}}) " + - "{ foo{ barEnum}}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - [Fact] - public async Task Create_ObjectNullableEnum_OrderBy() - { - // arrange - IRequestExecutor tester = - CreateSchema(_barNullableEntities!); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barEnum: ASC}}) " + - "{ foo{ barEnum}}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barEnum: DESC}}) " + - "{ foo{ barEnum}}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("13"); - } - - [Fact] - public async Task Create_ObjectString_OrderBy() - { - // arrange - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barString: ASC}}) " + - "{ foo{ barString}}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barString: DESC}}) " + - "{ foo{ barString}}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - [Fact] - public async Task Create_ObjectNullableString_OrderBy() - { - // arrange - IRequestExecutor tester = - CreateSchema(_barNullableEntities!); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barString: ASC}}) " + - "{ foo{ barString}}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barString: DESC}}) " + - "{ foo{ barString}}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("13"); - } - - [Fact] - public async Task Create_ObjectBool_OrderBy() - { - // arrange - IRequestExecutor tester = CreateSchema(_barEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barBool: ASC}}) " + - "{ foo{ barBool}}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barBool: DESC}}) " + - "{ foo{ barBool}}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } - - [Fact] - public async Task Create_ObjectNullableBool_OrderBy() - { - // arrange - IRequestExecutor tester = - CreateSchema(_barNullableEntities!); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barBool: ASC}}) " + - "{ foo{ barBool}}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery( - "{ root(order: { foo: { barBool: DESC}}) " + - "{ foo{ barBool}}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("13"); - } - - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public short BarShort { get; set; } - - public string BarString { get; set; } = ""; - - public BarEnum BarEnum { get; set; } - - public bool BarBool { get; set; } - - //Not supported in SQL - //public string[] ScalarArray { get; set; } - - public List ObjectArray { get; set; } = new List(); - } - - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public short? BarShort { get; set; } - - public string? BarString { get; set; } - - public BarEnum? BarEnum { get; set; } - - public bool? BarBool { get; set; } - - //Not supported in SQL - //public string?[] ScalarArray { get; set; } - - public List? ObjectArray { get; set; } - } - - public class Bar - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public Foo Foo { get; set; } = null!; - } - - public class BarNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); - - public FooNullable? Foo { get; set; } - } - - public class BarSortType - : SortInputType - { - } - - public class BarNullableSortType - : SortInputType - { - } - - public enum BarEnum - { - FOO, - BAR, - BAZ, - QUX - } + public MongoDbSortVisitorObjectTests(MongoResource resource) + { + Init(resource); + } + + [Fact] + public async Task Create_ObjectShort_OrderBy() + { + // arrange + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barShort: ASC}}) " + + "{ foo{ barShort}}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barShort: DESC}}) " + + "{ foo{ barShort}}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + [Fact] + public async Task Create_ObjectNullableShort_OrderBy() + { + // arrange + IRequestExecutor? tester = + CreateSchema(_barNullableEntities!); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barShort: ASC}}) " + + "{ foo{ barShort}}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barShort: DESC}}) " + + "{ foo{ barShort}}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("13"); + } + + [Fact] + public async Task Create_ObjectEnum_OrderBy() + { + // arrange + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barEnum: ASC}}) " + + "{ foo{ barEnum}}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barEnum: DESC}}) " + + "{ foo{ barEnum}}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + [Fact] + public async Task Create_ObjectNullableEnum_OrderBy() + { + // arrange + IRequestExecutor tester = + CreateSchema(_barNullableEntities!); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barEnum: ASC}}) " + + "{ foo{ barEnum}}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barEnum: DESC}}) " + + "{ foo{ barEnum}}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("13"); + } + + [Fact] + public async Task Create_ObjectString_OrderBy() + { + // arrange + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barString: ASC}}) " + + "{ foo{ barString}}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barString: DESC}}) " + + "{ foo{ barString}}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + [Fact] + public async Task Create_ObjectNullableString_OrderBy() + { + // arrange + IRequestExecutor tester = + CreateSchema(_barNullableEntities!); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barString: ASC}}) " + + "{ foo{ barString}}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barString: DESC}}) " + + "{ foo{ barString}}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("13"); + } + + [Fact] + public async Task Create_ObjectBool_OrderBy() + { + // arrange + IRequestExecutor tester = CreateSchema(_barEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barBool: ASC}}) " + + "{ foo{ barBool}}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barBool: DESC}}) " + + "{ foo{ barBool}}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } + + [Fact] + public async Task Create_ObjectNullableBool_OrderBy() + { + // arrange + IRequestExecutor tester = + CreateSchema(_barNullableEntities!); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barBool: ASC}}) " + + "{ foo{ barBool}}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery( + "{ root(order: { foo: { barBool: DESC}}) " + + "{ foo{ barBool}}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("13"); + } + + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public short BarShort { get; set; } + + public string BarString { get; set; } = ""; + + public BarEnum BarEnum { get; set; } + + public bool BarBool { get; set; } + + //Not supported in SQL + //public string[] ScalarArray { get; set; } + + public List ObjectArray { get; set; } = new List(); + } + + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public short? BarShort { get; set; } + + public string? BarString { get; set; } + + public BarEnum? BarEnum { get; set; } + + public bool? BarBool { get; set; } + + //Not supported in SQL + //public string?[] ScalarArray { get; set; } + + public List? ObjectArray { get; set; } + } + + public class Bar + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public Foo Foo { get; set; } = null!; + } + + public class BarNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); + + public FooNullable? Foo { get; set; } + } + + public class BarSortType + : SortInputType + { + } + + public class BarNullableSortType + : SortInputType + { + } + + public enum BarEnum + { + FOO, + BAR, + BAZ, + QUX } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorStringTests.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorStringTests.cs index eb79c4ef2e3..eaa7b57d210 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorStringTests.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/MongoDbSortVisitorStringTests.cs @@ -6,109 +6,108 @@ using Squadron; using Xunit; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class MongoDbSortVisitorStringTests + : SchemaCache, + IClassFixture { - public class MongoDbSortVisitorStringTests - : SchemaCache, - IClassFixture + private static readonly Foo[] _fooEntities = { - private static readonly Foo[] _fooEntities = - { new Foo { Bar = "testatest" }, new Foo { Bar = "testbtest" } }; - private static readonly FooNullable[] _fooNullableEntities = - { + private static readonly FooNullable[] _fooNullableEntities = + { new FooNullable { Bar = "testatest" }, new FooNullable { Bar = "testbtest" }, new FooNullable { Bar = null } }; - public MongoDbSortVisitorStringTests(MongoResource resource) - { - Init(resource); - } + public MongoDbSortVisitorStringTests(MongoResource resource) + { + Init(resource); + } - [Fact] - public async Task Create_String_OrderBy() - { - // arrange - IRequestExecutor tester = CreateSchema(_fooEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: ASC}){ bar}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: DESC}){ bar}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } + [Fact] + public async Task Create_String_OrderBy() + { + // arrange + IRequestExecutor tester = CreateSchema(_fooEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: ASC}){ bar}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: DESC}){ bar}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } - [Fact] - public async Task Create_String_OrderBy_Nullable() - { - // arrange - IRequestExecutor tester = CreateSchema( - _fooNullableEntities); - - // act - IExecutionResult res1 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: ASC}){ bar}}") - .Create()); - - IExecutionResult res2 = await tester.ExecuteAsync( - QueryRequestBuilder.New() - .SetQuery("{ root(order: { bar: DESC}){ bar}}") - .Create()); - - // assert - res1.MatchDocumentSnapshot("ASC"); - res2.MatchDocumentSnapshot("DESC"); - } + [Fact] + public async Task Create_String_OrderBy_Nullable() + { + // arrange + IRequestExecutor tester = CreateSchema( + _fooNullableEntities); + + // act + IExecutionResult res1 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: ASC}){ bar}}") + .Create()); + + IExecutionResult res2 = await tester.ExecuteAsync( + QueryRequestBuilder.New() + .SetQuery("{ root(order: { bar: DESC}){ bar}}") + .Create()); + + // assert + res1.MatchDocumentSnapshot("ASC"); + res2.MatchDocumentSnapshot("DESC"); + } - public class Foo - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class Foo + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public string Bar { get; set; } = null!; - } + public string Bar { get; set; } = null!; + } - public class FooNullable - { - [BsonId] - public Guid Id { get; set; } = Guid.NewGuid(); + public class FooNullable + { + [BsonId] + public Guid Id { get; set; } = Guid.NewGuid(); - public string? Bar { get; set; } - } + public string? Bar { get; set; } + } - public class FooSortType - : SortInputType + public class FooSortType + : SortInputType + { + protected override void Configure( + ISortInputTypeDescriptor descriptor) { - protected override void Configure( - ISortInputTypeDescriptor descriptor) - { - descriptor.Field(t => t.Bar); - } + descriptor.Field(t => t.Bar); } + } - public class FooNullableSortType - : SortInputType + public class FooNullableSortType + : SortInputType + { + protected override void Configure( + ISortInputTypeDescriptor descriptor) { - protected override void Configure( - ISortInputTypeDescriptor descriptor) - { - descriptor.Field(t => t.Bar); - } + descriptor.Field(t => t.Bar); } } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/SchemaCache.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/SchemaCache.cs index ab817d071c9..991d3075528 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/SchemaCache.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/SchemaCache.cs @@ -4,34 +4,33 @@ using HotChocolate.Execution; using Squadron; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class SchemaCache + : SortVisitorTestBase + , IDisposable { - public class SchemaCache - : SortVisitorTestBase - , IDisposable - { - private MongoResource _resource = null!; + private MongoResource _resource = null!; - protected void Init(MongoResource resource) - { - _resource = resource; - } + protected void Init(MongoResource resource) + { + _resource = resource; + } - private readonly ConcurrentDictionary<(Type, Type, object), IRequestExecutor> _cache = - new ConcurrentDictionary<(Type, Type, object), IRequestExecutor>(); + private readonly ConcurrentDictionary<(Type, Type, object), IRequestExecutor> _cache = + new ConcurrentDictionary<(Type, Type, object), IRequestExecutor>(); - public IRequestExecutor CreateSchema(T[] entities) - where T : class - where TType : SortInputType - { - (Type, Type, T?[] entites) key = (typeof(T), typeof(TType), entities); - return _cache.GetOrAdd( - key, - k => base.CreateSchema(entities, _resource)); - } + public IRequestExecutor CreateSchema(T[] entities) + where T : class + where TType : SortInputType + { + (Type, Type, T?[] entites) key = (typeof(T), typeof(TType), entities); + return _cache.GetOrAdd( + key, + k => base.CreateSchema(entities, _resource)); + } - public void Dispose() - { - } + public void Dispose() + { } } diff --git a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/SortVisitorTestBase.cs b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/SortVisitorTestBase.cs index 041cd71db35..42f7c30a243 100644 --- a/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/SortVisitorTestBase.cs +++ b/src/HotChocolate/MongoDb/test/Data.MongoDb.Sorting.Tests/SortVisitorTestBase.cs @@ -12,72 +12,71 @@ using MongoDB.Driver; using Squadron; -namespace HotChocolate.Data.MongoDb.Sorting +namespace HotChocolate.Data.MongoDb.Sorting; + +public class SortVisitorTestBase { - public class SortVisitorTestBase + private Func> BuildResolver( + MongoResource mongoResource, + params TResult[] results) + where TResult : class { - private Func> BuildResolver( - MongoResource mongoResource, - params TResult[] results) - where TResult : class - { - IMongoCollection collection = - mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); + IMongoCollection collection = + mongoResource.CreateCollection("data_" + Guid.NewGuid().ToString("N")); - collection.InsertMany(results); + collection.InsertMany(results); - return ctx => collection.AsExecutable(); - } + return ctx => collection.AsExecutable(); + } - protected IRequestExecutor CreateSchema( - TEntity[] entities, - MongoResource mongoResource, - bool withPaging = false) - where TEntity : class - where T : SortInputType - { - Func> resolver = BuildResolver( - mongoResource, - entities); + protected IRequestExecutor CreateSchema( + TEntity[] entities, + MongoResource mongoResource, + bool withPaging = false) + where TEntity : class + where T : SortInputType + { + Func> resolver = BuildResolver( + mongoResource, + entities); - return new ServiceCollection() - .AddGraphQL() - .AddSorting(x => x.BindRuntimeType().AddMongoDbDefaults()) - .AddQueryType( - c => c - .Name("Query") - .Field("root") - .Resolve(resolver) - .Use( - next => async context => + return new ServiceCollection() + .AddGraphQL() + .AddSorting(x => x.BindRuntimeType().AddMongoDbDefaults()) + .AddQueryType( + c => c + .Name("Query") + .Field("root") + .Resolve(resolver) + .Use( + next => async context => + { + await next(context); + if (context.Result is IExecutable executable) { - await next(context); - if (context.Result is IExecutable executable) - { - context.ContextData["query"] = executable.Print(); - } - }) - .UseSorting()) - .UseRequest( - next => async context => + context.ContextData["query"] = executable.Print(); + } + }) + .UseSorting()) + .UseRequest( + next => async context => + { + await next(context); + if (context.ContextData.TryGetValue("query", out var queryString)) { - await next(context); - if (context.ContextData.TryGetValue("query", out var queryString)) - { - context.Result = - QueryResultBuilder - .FromResult(context.Result!.ExpectQueryResult()) - .SetContextData("query", queryString) - .Create(); - } - }) - .UseDefaultPipeline() - .Services - .BuildServiceProvider() - .GetRequiredService() - .GetRequestExecutorAsync() - .GetAwaiter() - .GetResult(); - } + context.Result = + QueryResultBuilder + .FromResult(context.Result!.ExpectQueryResult()) + .SetContextData("query", queryString) + .Create(); + } + }) + .UseDefaultPipeline() + .Services + .BuildServiceProvider() + .GetRequiredService() + .GetRequestExecutorAsync() + .GetAwaiter() + .GetResult(); } } diff --git a/src/HotChocolate/MongoDb/test/Types.MongoDb/BsonTypeTests.cs b/src/HotChocolate/MongoDb/test/Types.MongoDb/BsonTypeTests.cs index b64a462f749..bf1c3dc14e4 100644 --- a/src/HotChocolate/MongoDb/test/Types.MongoDb/BsonTypeTests.cs +++ b/src/HotChocolate/MongoDb/test/Types.MongoDb/BsonTypeTests.cs @@ -322,7 +322,7 @@ public async Task Output_Return_List() .Name("Query") .Field("foo") .Type() - .Resolve(_ => new BsonArray(){ new BsonDocument() })) + .Resolve(_ => new BsonArray() { new BsonDocument() })) .Create(); IRequestExecutor executor = schema.MakeExecutable(); @@ -1255,7 +1255,8 @@ public class OutputQuery ["Null"] = BsonNull.Value, ["Nested"] = new BsonDocument() { - ["Int32"] = new BsonInt32(42), ["Int64"] = new BsonInt64(42), + ["Int32"] = new BsonInt32(42), + ["Int64"] = new BsonInt64(42), } }; } diff --git a/src/HotChocolate/MongoDb/test/Types.MongoDb/ObjectIdTypeTests.cs b/src/HotChocolate/MongoDb/test/Types.MongoDb/ObjectIdTypeTests.cs index e756928cba2..f4598304f31 100644 --- a/src/HotChocolate/MongoDb/test/Types.MongoDb/ObjectIdTypeTests.cs +++ b/src/HotChocolate/MongoDb/test/Types.MongoDb/ObjectIdTypeTests.cs @@ -7,29 +7,29 @@ using Snapshooter.Xunit; using Xunit; -namespace HotChocolate.Types +namespace HotChocolate.Types; + +public class ObjectIdTypeTests { - public class ObjectIdTypeTests + [Fact] + public async Task Should_MapObjectIdToScalar() { - [Fact] - public async Task Should_MapObjectIdToScalar() - { - // arrange - IRequestExecutor executor = await CreateSchema(); + // arrange + IRequestExecutor executor = await CreateSchema(); - // act - string schema = executor.Schema.Print(); + // act + string schema = executor.Schema.Print(); - // assert - schema.MatchSnapshot(); - } + // assert + schema.MatchSnapshot(); + } - [Fact] - public async Task Should_ReturnObjectIdOnQuery() - { - // arrange - IRequestExecutor executor = await CreateSchema(); - string query = @" + [Fact] + public async Task Should_ReturnObjectIdOnQuery() + { + // arrange + IRequestExecutor executor = await CreateSchema(); + string query = @" { foo { id @@ -37,49 +37,48 @@ public async Task Should_ReturnObjectIdOnQuery() } "; - // act - IReadOnlyQueryRequest request = QueryRequestBuilder.Create(query); - IExecutionResult result = await executor.ExecuteAsync(request, CancellationToken.None); + // act + IReadOnlyQueryRequest request = QueryRequestBuilder.Create(query); + IExecutionResult result = await executor.ExecuteAsync(request, CancellationToken.None); - // assert - result.ToJson().MatchSnapshot(); - } + // assert + result.ToJson().MatchSnapshot(); + } - [Fact] - public async Task Should_ReturnInputOnQuery() - { - // arrange - IRequestExecutor executor = await CreateSchema(); - string query = @" + [Fact] + public async Task Should_ReturnInputOnQuery() + { + // arrange + IRequestExecutor executor = await CreateSchema(); + string query = @" { loopback(objectId: ""6124e80f3f5fc839830c1f6b"") }"; - // act - IReadOnlyQueryRequest request = QueryRequestBuilder.Create(query); - IExecutionResult result = await executor.ExecuteAsync(request, CancellationToken.None); + // act + IReadOnlyQueryRequest request = QueryRequestBuilder.Create(query); + IExecutionResult result = await executor.ExecuteAsync(request, CancellationToken.None); - // assert - result.ToJson().MatchSnapshot(); - } + // assert + result.ToJson().MatchSnapshot(); + } - private ValueTask CreateSchema() => - new ServiceCollection() - .AddGraphQL() - .AddQueryType() - .AddType() - .BuildRequestExecutorAsync(); + private ValueTask CreateSchema() => + new ServiceCollection() + .AddGraphQL() + .AddQueryType() + .AddType() + .BuildRequestExecutorAsync(); - public class Query - { - public Foo GetFoo() => new() { Id = new ObjectId("6124e80f3f5fc839830c1f6b") }; + public class Query + { + public Foo GetFoo() => new() { Id = new ObjectId("6124e80f3f5fc839830c1f6b") }; - public ObjectId Loopback(ObjectId objectId) => objectId; - } + public ObjectId Loopback(ObjectId objectId) => objectId; + } - public class Foo - { - public ObjectId Id { get; set; } - } + public class Foo + { + public ObjectId Id { get; set; } } }