public void Sort_ComparableAsc_ShouldSortByStringNullableAsc() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("bar", new ObjectValueNode( new ObjectFieldNode("baz", new EnumValueNode(SortOperationKind.Asc) ) ) )); FooSortType sortType = CreateType(new FooSortType()); IQueryable <Foo> a = new[] { new Foo { Bar = new Bar { Baz = "b" } }, new Foo { Bar = new Bar { Baz = null } }, new Foo { Bar = new Bar { Baz = "c" } } }.AsQueryable(); // act var filter = new QueryableSortVisitor( sortType, typeof(Foo)); value.Accept(filter); ICollection <Foo> aFiltered = filter.Sort(a).ToList(); // assert Assert.Collection(aFiltered, foo => Assert.Null(foo.Bar.Baz), foo => Assert.Equal("b", foo.Bar.Baz), foo => Assert.Equal("c", foo.Bar.Baz) ); }
public void Sort_ObjectMultiple_ShouldSortByStringAscThenByStringAsc() { // arrange var value = new ObjectValueNode(new ObjectFieldNode("foo", new ObjectValueNode( new ObjectFieldNode("baz", new EnumValueNode(SortOperationKind.Asc) ), new ObjectFieldNode("bar", new EnumValueNode(SortOperationKind.Asc) )))); FooNestedSortType sortType = CreateType(new FooNestedSortType()); IQueryable <FooNested> a = new[] { new FooNested { Foo = new Foo { Bar = "b", Baz = "b" } }, new FooNested { Foo = new Foo { Bar = "a", Baz = "b" } }, new FooNested { Foo = new Foo { Bar = "c", Baz = "a" } } }.AsQueryable(); // act var filter = new QueryableSortVisitor( sortType, typeof(FooNested)); value.Accept(filter); ICollection <FooNested> aFiltered = filter.Sort(a).ToList(); // assert Assert.Collection(aFiltered, foo => Assert.Equal("c", foo.Foo.Bar), foo => Assert.Equal("a", foo.Foo.Bar), foo => Assert.Equal("b", foo.Foo.Bar) ); }
public void Sort_ComparableDesc_ShouldSortByStringAsc() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("bar", new ObjectValueNode( new ObjectFieldNode("baz", new EnumValueNode(SortOperationKind.Desc) ) ) )); FooSortType sortType = CreateType(new FooSortType()); IQueryable <Foo> a = new[] { new Foo { Bar = new Bar { Baz = "b" } }, new Foo { Bar = new Bar { Baz = "a" } }, new Foo { Bar = new Bar { Baz = "c" } } }.AsQueryable(); // act var context = new QueryableSortVisitorContext( new(new DefaultTypeConverter()), sortType, typeof(Foo), false); QueryableSortVisitor.Default.Visit(value, context); ICollection <Foo> aFiltered = context.Sort(a).ToList(); // assert Assert.Collection(aFiltered, foo => Assert.Equal("c", foo.Bar.Baz), foo => Assert.Equal("b", foo.Bar.Baz), foo => Assert.Equal("a", foo.Bar.Baz) ); }
public void Create_ArrayAnyObjectStringEqual_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("fooNested_any", new BooleanValueNode(true) ) ); var fooType = CreateType(new FooFilterType()); // act var filter = new QueryableFilterVisitor( fooType, typeof(Foo), TypeConversion.Default, true); value.Accept(filter); Func <Foo, bool> func = filter.CreateFilter <Foo>().Compile(); // assert var a = new Foo { FooNested = new[] { new FooNested { Bar = "c" }, new FooNested { Bar = "d" }, new FooNested { Bar = "a" } } }; Assert.True(func(a)); var b = new Foo { FooNested = new FooNested[] { } }; Assert.False(func(b)); }
public void ParseLiteral_Should_Pass_When_NoCrs(string typeName) { // arrange INamedInputType type = CreateInputType(typeName); var typeField = new ObjectFieldNode(WellKnownFields.TypeFieldName, _geometryType); var coordField = new ObjectFieldNode( WellKnownFields.CoordinatesFieldName, _coordinatesSyntaxNode); var valueNode = new ObjectValueNode(typeField, coordField); // act object?parsedResult = type.ParseLiteral(valueNode); // assert AssertGeometry(parsedResult); }
public void Create_NullableShortNotLowerThanOrEquals_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode( "barShort_not_lte", new IntValueNode(12))); FooNullableFilterType fooNullableType = CreateType(new FooNullableFilterType()); // act var context = new QueryableFilterVisitorContext( fooNullableType, typeof(FooNullable), DefaultTypeConverter.Default, true, new(new DefaultTypeConverter())); QueryableFilterVisitor.Default.Visit(value, context); Func <FooNullable, bool> func = context.CreateFilter <FooNullable>().Compile(); // assert var a = new FooNullable { BarShort = 11 }; Assert.False(func(a)); var b = new FooNullable { BarShort = 12 }; Assert.False(func(b)); var c = new FooNullable { BarShort = 13 }; Assert.True(func(c)); var d = new FooNullable { BarShort = null }; Assert.True(func(d)); }
public void Override_StringNotIn_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("bar_not_in", new ListValueNode(new[] { new StringValueNode("a"), new StringValueNode("c") }))); AssertOperation <Foo>( value, FilterKind.String, FilterOperationKind.NotIn, StringOperationHandlers.NotIn); }
public async Task Empty_Object() { Snapshot.FullName(); IRequestExecutor executor = await CreateSchemaAsync(); var user = new ObjectValueNode(); IReadOnlyQueryRequest request = QueryRequestBuilder .New() .SetQuery("mutation($user: UserInput!) { addUser(user: $user) }") .SetVariableValue("user", user) .Create(); await executor.ExecuteAsync(request).MatchSnapshotAsync(); }
public void Point_IsCoordinateValid_Should_Fail_When_MultiArray(string typeName) { // arrange var inputParser = new InputParser(new DefaultTypeConverter()); INamedInputType type = CreateInputType(typeName); var coords = new ListValueNode( new ListValueNode( new IntValueNode(30), new IntValueNode(10))); var typeField = new ObjectFieldNode(WellKnownFields.TypeFieldName, _geometryType); var coordField = new ObjectFieldNode(WellKnownFields.CoordinatesFieldName, coords); var valueNode = new ObjectValueNode(typeField, coordField); // act // assert Assert.Throws <SerializationException>(() => inputParser.ParseLiteral(valueNode, type)); }
public void Create_ArraySomeStringEqualWithNull_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("bar_some", new ObjectValueNode( new ObjectFieldNode("element", new StringValueNode("a") ) ) ) ); FooSimpleFilterType fooType = CreateType(new FooSimpleFilterType()); // act var filter = new QueryableFilterVisitorContext( fooType, typeof(FooSimple), MockFilterConvention.Default.GetExpressionDefinition(), TypeConversion.Default, true); QueryableFilterVisitor.Default.Visit(value, filter); Func <FooSimple, bool> func = filter.CreateOrAssert <FooSimple>().Compile(); // assert var a = new FooSimple { Bar = new[] { "c", null, "a" } }; Assert.True(func(a)); var b = new FooSimple { Bar = new[] { "c", null, "b" } }; Assert.False(func(b)); var c = new FooSimple { Bar = null }; Assert.False(func(c)); }
public void Create_NullableShortNotGreaterThan_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("barShort_not_gt", new IntValueNode(12))); FooNullableFilterType fooNullableType = CreateType(new FooNullableFilterType()); // act var context = new QueryableFilterVisitorContext( fooNullableType, typeof(FooNullable), MockFilterConvention.Default.GetExpressionDefinition(), TypeConversion.Default, true); QueryableFilterVisitor.Default.Visit(value, context); Func <FooNullable, bool> func = context.CreateOrAssert <FooNullable>().Compile(); // assert var a = new FooNullable { BarShort = 11 }; Assert.True(func(a)); var b = new FooNullable { BarShort = 12 }; Assert.True(func(b)); var c = new FooNullable { BarShort = 13 }; Assert.False(func(c)); var d = new FooNullable { BarShort = null }; Assert.True(func(d)); }
protected sealed override ISyntaxVisitorAction Enter( ISyntaxNode node, ISyntaxVisitorContext context) { return(node switch { DocumentNode n => Enter(n, context), OperationDefinitionNode n => Enter(n, context), VariableDefinitionNode n => Enter(n, context), VariableNode n => Enter(n, context), SelectionSetNode n => Enter(n, context), FieldNode n => Enter(n, context), ArgumentNode n => Enter(n, context), FragmentSpreadNode n => Enter(n, context), InlineFragmentNode n => Enter(n, context), FragmentDefinitionNode n => Enter(n, context), DirectiveNode n => Enter(n, context), NamedTypeNode n => Enter(n, context), ListTypeNode n => Enter(n, context), NonNullTypeNode n => Enter(n, context), ListValueNode n => Enter(n, context), ObjectValueNode n => Enter(n, context), ObjectFieldNode n => Enter(n, context), IValueNode n => Enter(n, context), SchemaDefinitionNode n => Enter(n, context), OperationTypeDefinitionNode n => Enter(n, context), ScalarTypeDefinitionNode n => Enter(n, context), ObjectTypeDefinitionNode n => Enter(n, context), FieldDefinitionNode n => Enter(n, context), InputValueDefinitionNode n => Enter(n, context), InterfaceTypeDefinitionNode n => Enter(n, context), UnionTypeDefinitionNode n => Enter(n, context), EnumTypeDefinitionNode n => Enter(n, context), EnumValueDefinitionNode n => Enter(n, context), InputObjectTypeDefinitionNode n => Enter(n, context), DirectiveDefinitionNode n => Enter(n, context), SchemaExtensionNode n => Enter(n, context), ScalarTypeExtensionNode n => Enter(n, context), ObjectTypeExtensionNode n => Enter(n, context), InterfaceTypeExtensionNode n => Enter(n, context), UnionTypeExtensionNode n => Enter(n, context), EnumTypeExtensionNode n => Enter(n, context), InputObjectTypeExtensionNode n => Enter(n, context), _ => throw new NotSupportedException() });
public void Create_ObjectStringEqualRecursive_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("nested", new ObjectValueNode( new ObjectFieldNode("nested", new ObjectValueNode( new ObjectFieldNode("bar", new StringValueNode("a"))))))); FilterInputType <Recursive> fooType = CreateType(new FilterInputType <Recursive>()); // act var filterContext = new QueryableFilterVisitorContext( fooType, typeof(Recursive), DefaultTypeConverter.Default, true, new(new DefaultTypeConverter())); QueryableFilterVisitor.Default.Visit(value, filterContext); Func <Recursive, bool> func = filterContext.CreateFilter <Recursive>().Compile(); var a = new Recursive { Nested = new Recursive { Nested = new Recursive { Bar = "a" } } }; Assert.True(func(a)); var b = new Recursive { Nested = new Recursive { Nested = new Recursive { Bar = "b" } } }; Assert.False(func(b)); }
public void Create_ObjectStringEqualDeep_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("foo", new ObjectValueNode( new ObjectFieldNode("fooNested", new ObjectValueNode( new ObjectFieldNode("bar", new StringValueNode("a"))))))); EvenDeeperFilterType fooType = CreateType(new EvenDeeperFilterType()); // act var filterContext = new QueryableFilterVisitorContext( fooType, typeof(EvenDeeper), DefaultTypeConverter.Default, true, new(new DefaultTypeConverter())); QueryableFilterVisitor.Default.Visit(value, filterContext); Func <EvenDeeper, bool> func = filterContext.CreateFilter <EvenDeeper>().Compile(); // assert var a = new EvenDeeper { Foo = new Foo { FooNested = new FooNested { Bar = "a" } } }; Assert.True(func(a)); var b = new EvenDeeper { Foo = new Foo { FooNested = new FooNested { Bar = "b" } } }; Assert.False(func(b)); }
public override VisitorAction Leave( ObjectValueNode node, ISyntaxNode parent, IReadOnlyList <object> path, IReadOnlyList <ISyntaxNode> ancestors) { Queue <Expression> operations = Level.Pop(); if (TryCombineOperations( operations, (a, b) => Expression.AndAlso(a, b), out Expression combined)) { Level.Peek().Enqueue(combined); } return(VisitorAction.Continue); }
public static object ParseLiteral( InputObjectType inputObjectType, ObjectValueNode literal) { var fieldValues = literal.Fields .ToDictionary(t => t.Name.Value, t => t.Value); object obj = Activator.CreateInstance(inputObjectType.ClrType); foreach (InputField field in inputObjectType.Fields) { ValueDeserializer.SetProperty( field, fieldValues, obj, field.Property, l => field.Type.ParseLiteral(l)); } return(obj); }
public async Task Nullables_Are_Set_And_NonNullables_Not_Are_Set() { Snapshot.FullName(); IRequestExecutor executor = await CreateSchemaAsync(); var user = new ObjectValueNode( new ObjectFieldNode("surname", "Smith")); IReadOnlyQueryRequest request = QueryRequestBuilder .New() .SetQuery("mutation($user: UserInput!) { addUser(user: $user) }") .SetVariableValue("user", user) .Create(); await executor.ExecuteAsync(request).MatchSnapshotAsync(); }
public void Override_ShortIn_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("barShort_in", new ListValueNode(new[] { new IntValueNode(13), new IntValueNode(14) })) ); AssertOperation <Foo>( value, FilterKind.Comparable, FilterOperationKind.In, ComparableOperationHandlers.In); }
public void Convert_ObjectGraphWithScalars_DictionaryWithClrRepres() { // arrange var obj = new ObjectValueNode( new ObjectFieldNode("a", new StringValueNode("abc")), new ObjectFieldNode("b", new IntValueNode("123")), new ObjectFieldNode("c", new FloatValueNode("1.5")), new ObjectFieldNode("d", new BooleanValueNode(true)), new ObjectFieldNode("e", new EnumValueNode("DEF")), new ObjectFieldNode("f", NullValueNode.Default)); // act var converter = new ObjectValueToDictionaryConverter(); Dictionary <string, object> dict = converter.Convert(obj); // assert dict.MatchSnapshot(); }
protected override void VisitObjectValue( InputObjectType type, ObjectValueNode objectValue) { var visitedFields = new HashSet <string>(); if (_visited.Add(objectValue)) { foreach (ObjectFieldNode fieldValue in objectValue.Fields) { if (type.Fields.TryGetField(fieldValue.Name.Value, out InputField field)) { VisitInputField(visitedFields, field, fieldValue); } } } }
public void ParseLiteral_Should_Pass_When_CorrectGeometry(string typeName) { // arrange var inputParser = new InputParser(new DefaultTypeConverter()); INamedInputType type = CreateInputType(typeName); var typeField = new ObjectFieldNode(WellKnownFields.TypeFieldName, _geometryType); var coordField = new ObjectFieldNode( WellKnownFields.CoordinatesFieldName, _coordinatesSyntaxNode); var crsField = new ObjectFieldNode(WellKnownFields.CrsFieldName, 26912); var valueNode = new ObjectValueNode(typeField, coordField, crsField); // act var parsedResult = inputParser.ParseLiteral(valueNode, type); // assert AssertGeometry(parsedResult, 26912); }
public static (int typeIndex, int coordinateIndex, int crsIndex) GetFieldIndices( ObjectValueNode obj, string _typeFieldName, string _coordinatesFieldName, string _crsFieldName) { var coordinateIndex = -1; var typeIndex = -1; var crsIndex = -1; for (var i = 0; i < obj.Fields.Count; i++) { if (coordinateIndex > -1 && typeIndex > -1 && crsIndex > -1) { return(typeIndex, coordinateIndex, crsIndex); } ObjectFieldNode field = obj.Fields[i]; if (typeIndex < 0 && string.Equals(field.Name.Value, _typeFieldName, StringComparison.InvariantCultureIgnoreCase)) { typeIndex = i; continue; } if (coordinateIndex < 0 && string.Equals(field.Name.Value, _coordinatesFieldName, StringComparison.InvariantCultureIgnoreCase)) { coordinateIndex = i; continue; } if (crsIndex < 0 && string.Equals(field.Name.Value, _crsFieldName, StringComparison.InvariantCultureIgnoreCase)) { crsIndex = i; continue; } } return(typeIndex, coordinateIndex, crsIndex); }
protected (GeoJsonGeometryType type, object coordinates, int?crs) ParseFields( IType type, ObjectValueNode obj) { GeoJsonGeometryType?geometryType = null; object?coordinates = null; int? crs = null; foreach (var field in obj.Fields) { var fieldName = field.Name.Value; IValueNode syntaxNode = field.Value; if (TypeFieldName.EqualsInvariantIgnoreCase(fieldName)) { geometryType = GeoJsonTypeSerializer.Default.ParseLiteral(type, syntaxNode) as GeoJsonGeometryType?; } else if (CoordinatesFieldName.EqualsInvariantIgnoreCase(fieldName)) { coordinates = ParseCoordinates(type, syntaxNode); } else if (CrsFieldName.EqualsInvariantIgnoreCase(fieldName) && syntaxNode is IntValueNode node && !node.IsNull()) { crs = node.ToInt32(); } } if (geometryType is null) { throw Serializer_TypeIsMissing(type); } if (coordinates is null) { throw Serializer_CoordinatesIsMissing(type); } return(geometryType.Value, coordinates, crs); }
protected override void VisitObjectValue( ObjectValueNode node, ConverterContext context) { if (context.InputType.NamedType() is InputObjectType type) { Type clrType = type.RuntimeType == typeof(object) ? typeof(Dictionary <string, object>) : type.RuntimeType; context.Object = Activator.CreateInstance(clrType); context.InputFields = type.Fields; foreach (ObjectFieldNode field in node.Fields) { VisitObjectField(field, context); } } }
public static object ParseLiteral( InputObjectType type, ObjectValueNode value, InputObjectFactory factory, ITypeConverter converter) { Dictionary <string, object> dict = _dictionaryPool.Get(); try { Parse(type, value, dict, converter); SetDefaultValues(type, dict, converter); return(factory(dict, converter)); } finally { _dictionaryPool.Return(dict); } }
public void Create_ObjectStringEqual_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("fooNested", new ObjectValueNode( new ObjectFieldNode("bar", new StringValueNode("a") ) ) ) ); var fooType = CreateType(new FooFilterType()); // act var filter = new QueryableFilterVisitor( fooType, typeof(Foo), TypeConversion.Default, true); filter.Visit(value, null); Func <Foo, bool> func = filter.CreateFilter <Foo>().Compile(); // assert var a = new Foo { FooNested = new FooNested { Bar = "a" } }; Assert.True(func(a)); var b = new Foo { FooNested = new FooNested { Bar = "b" } }; Assert.False(func(b)); }
public async Task Invalid_Field_Provided() { Snapshot.FullName(); IRequestExecutor executor = await CreateSchemaAsync(); var user = new ObjectValueNode( new ObjectFieldNode("name", "Oliver"), new ObjectFieldNode("surname", "Smith"), new ObjectFieldNode("foo", "bar")); IReadOnlyQueryRequest request = QueryRequestBuilder .New() .SetQuery("mutation($user: UserInput!) { addUser(user: $user) }") .SetVariableValue("user", user) .Create(); await executor.ExecuteAsync(request).MatchSnapshotAsync(); }
public void Parse_InputObject_WithDefault_Values() { // arrange ISchema schema = SchemaBuilder.New() .AddInputObjectType <Test3Input>() .ModifyOptions(o => o.StrictValidation = false) .Create(); InputObjectType type = schema.GetType <InputObjectType>("Test3Input"); var fieldData = new ObjectValueNode( new ObjectFieldNode("field2", 123)); // act var parser = new InputParser(); var obj = parser.ParseLiteral(fieldData, type, Path.Root.Append("root")); // assert Assert.Equal("DefaultAbc", Assert.IsType <Test3Input>(obj).Field1); }
public ObjectValueNode Convert( InputObjectType type, object obj) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (obj == null) { throw new ArgumentNullException(nameof(obj)); } ObjectValueNode objectValueNode = null; Action <IValueNode> setValue = value => objectValueNode = (ObjectValueNode)value; VisitInputObject(type, obj, setValue, new HashSet <object>()); return(objectValueNode); }
private bool TryGetGeometryKind( ObjectValueNode valueSyntax, out GeoJsonGeometryType geometryType) { IReadOnlyList <ObjectFieldNode> fields = valueSyntax.Fields; for (var i = 0; i < fields.Count; i++) { if (fields[i].Name.Value == TypeFieldName && GeoJsonTypeSerializer.Default.ParseLiteral(fields[i].Value) is GeoJsonGeometryType type) { geometryType = type; return(true); } } geometryType = default; return(false); }