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);
}
