public void CreateValues_ListOfObject_ListOfString()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: [String]) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new List <object> {
"a", "b"
} }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
var list = coercedVariableValues.GetVariable <string[]>("test");
Assert.Collection(list,
t => Assert.Equal("a", t),
t => Assert.Equal("b", t));
}
public void InvalidFieldError()
{
// arrange
Schema schema = CreateSchema();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
a
x:c
xyz
}
");
var variables = new VariableValueCollection(
TypeConversion.Default,
new Dictionary <string, object>());
var fragments = new FragmentCollection(schema, query);
OperationDefinitionNode operation = query.Definitions
.OfType <OperationDefinitionNode>().First();
// act
var fieldResolver = new FieldCollector(
fragments,
(f, s) => null,
TypeConversion.Default);
Action action = () => fieldResolver
.CollectFields(schema.GetType <ObjectType>("Foo"),
operation.SelectionSet, null);
// assert
Assert.Throws <QueryException>(action);
}
public void FieldsAndFragmentDefinitionsInterfaceType()
{
// arrange
Schema schema = CreateSchema();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
a
... Test
}
fragment Test on IFoo {
x: a
}
");
var variables = new VariableValueCollection(
TypeConversion.Default,
new Dictionary <string, object>());
var fragments = new FragmentCollection(schema, query);
OperationDefinitionNode operation = query.Definitions
.OfType <OperationDefinitionNode>().First();
// act
var fieldResolver = new FieldCollector(
fragments,
(f, s) => null,
TypeConversion.Default,
Array.Empty <IArgumentCoercionHandler>());
IReadOnlyCollection <FieldSelection> fields_a = fieldResolver
.CollectFields(schema.GetType <ObjectType>("Foo"),
operation.SelectionSet, null);
IReadOnlyCollection <FieldSelection> fields_b = fieldResolver
.CollectFields(schema.GetType <ObjectType>("Fum"),
operation.SelectionSet, null);
// assert
Assert.Collection(fields_a,
f =>
{
Assert.Equal("a", f.ResponseName);
Assert.Equal("a", f.Field.Name);
Assert.Equal("String", f.Field.Type.TypeName());
},
f =>
{
Assert.Equal("x", f.ResponseName);
Assert.Equal("a", f.Field.Name);
Assert.Equal("String", f.Field.Type.TypeName());
});
Assert.Collection(fields_b,
f =>
{
Assert.Equal("a", f.ResponseName);
Assert.Equal("a", f.Field.Name);
Assert.Equal("String", f.Field.Type.TypeName());
});
}
public void Coerce_NonNullString_ToAbc()
{
// arrange
DocumentNode document =
Utf8GraphQLParser.Parse("{ bar (a: \"abc\") }");
OperationDefinitionNode operation = document.Definitions
.OfType <OperationDefinitionNode>().First();
ISchema schema = CreateSchema();
var fragments = new FragmentCollection(
schema,
document);
var variables = new VariableValueCollection(
TypeConversion.Default,
new Dictionary <string, object>());
var collector = new FieldCollector(
fragments,
(f, s) => null,
TypeConversion.Default);
IReadOnlyCollection <FieldSelection> selections =
collector.CollectFields(schema.QueryType,
operation.SelectionSet, Path.New("bar"));
FieldSelection selection = selections.First();
var path = Path.New("bar");
// act
IReadOnlyDictionary <NameString, ArgumentValue> arguments =
selection.CoerceArguments(variables, TypeConversion.Default);
// assert
MatchSnapshot(arguments);
}
public void CreateValues_ObjectAsDictionary_Object()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BarInput!) { a }");
var fooInput = new Dictionary <string, object>();
fooInput["b"] = "B";
var barInput = new Dictionary <string, object>();
barInput["f"] = fooInput;
var variableValues = new Dictionary <string, object>();
variableValues.Add("test", barInput);
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Bar bar = coercedVariableValues.GetVariable <Bar>("test");
Assert.NotNull(bar.F);
Assert.Equal(BarEnum.B, bar.F.B);
}
public void Coerce_InputObject_NonNullFieldIsNull()
{
// arrange
DocumentNode document =
Utf8GraphQLParser.Parse("{ foo(a: { a: { } }) }");
OperationDefinitionNode operation = document.Definitions
.OfType <OperationDefinitionNode>().First();
ISchema schema = CreateSchema();
var fragments = new FragmentCollection(
schema,
document);
var variables = new VariableValueCollection(
TypeConversion.Default,
new Dictionary <string, object>());
var collector = new FieldCollector(
fragments,
(f, s) => null,
TypeConversion.Default,
Array.Empty <IArgumentCoercionHandler>());
IReadOnlyCollection <FieldSelection> selections =
collector.CollectFields(schema.QueryType,
operation.SelectionSet, null);
FieldSelection selection = selections.First();
// act
Action action = () =>
selection.CoerceArguments(variables, TypeConversion.Default);
// assert
Assert.Throws <QueryException>(action).Errors.MatchSnapshot();
}
public void Variable_InputObjectAsClrType_NonNullListItemNull()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BazInput) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new Baz
{
Foo = "foo",
Quox = new string[] { null }
} }
};
// act
var resolver = new VariableValueBuilder(schema, operation);
VariableValueCollection variables = resolver.CreateValues(variableValues);
// assert
Baz baz = variables.GetVariable <Baz>("test");
Assert.Equal("foo", baz.Foo);
Assert.Collection(baz.Quox, t => Assert.Null(t));
}
public void Backing_Type_Can_Be_Used_As_Variable()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BarInput!) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new Bar {
F = new Foo {
B = BarEnum.A
}
} }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Bar bar = coercedVariableValues.GetVariable <Bar>("test");
Assert.NotNull(bar.F);
Assert.Equal(BarEnum.A, bar.F.B);
}
public void CoerceInputObjectWithEnumAsEnumValueNode()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BarInput!) { a }");
var fooInput = new ObjectValueNode(
new ObjectFieldNode("b",
new EnumValueNode("B")));
var barInput = new ObjectValueNode(
new ObjectFieldNode("f", fooInput));
var variableValues = new Dictionary <string, object>
{
{ "test", barInput }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Bar bar = coercedVariableValues.GetVariable <Bar>("test");
Assert.NotNull(bar.F);
Assert.Equal(BarEnum.B, bar.F.B);
}
public void TryGetVariable_Name_Is_Invalid(string name)
{
// arrange
var values = new Dictionary <string, VariableValue>();
var variables = new VariableValueCollection(TypeConversion.Default, values);
// act
Action action = () => variables.TryGetVariable <string>(name, out _);
// assert
Assert.Throws <ArgumentException>(action);
}
public void FieldsAndInlineFragments()
{
// arrange
Schema schema = CreateSchema();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
a
... on Foo {
z:a
}
... on Fa {
x:a
}
}
");
var variables = new VariableValueCollection(
TypeConversion.Default,
new Dictionary <string, VariableValue>());
var fragments = new FragmentCollection(schema, query);
OperationDefinitionNode operation = query.Definitions
.OfType <OperationDefinitionNode>().First();
// act
var fieldResolver = new FieldCollector(
fragments,
(f, s) => null,
TypeConversion.Default,
Array.Empty <IArgumentCoercionHandler>());
IReadOnlyCollection <FieldSelection> fields = fieldResolver
.CollectFields(schema.GetType <ObjectType>("Foo"),
operation.SelectionSet, null);
// assert
Assert.Collection(fields.Where(t => t.IsVisible(variables)),
f =>
{
Assert.Equal("a", f.ResponseName);
Assert.Equal("a", f.Field.Name);
Assert.Equal("String", f.Field.Type.TypeName());
},
f =>
{
Assert.Equal("z", f.ResponseName);
Assert.Equal("a", f.Field.Name);
Assert.Equal("String", f.Field.Type.TypeName());
});
}
public void MergeFieldsWithFragmentSpreads()
{
// arrange
DocumentNode query = Utf8GraphQLParser.Parse(
FileResource.Open("MergeQuery.graphql"));
OperationDefinitionNode operation =
query.Definitions.OfType <OperationDefinitionNode>().Single();
var schema = Schema.Create(
FileResource.Open("MergeSchema.graphql"),
c => c.Use(next => context => Task.CompletedTask));
var fragments = new FragmentCollection(schema, query);
var variables = new VariableValueCollection(
TypeConversion.Default,
new Dictionary <string, object>());
// act
var collector = new FieldCollector(
fragments,
(f, s) => null,
TypeConversion.Default,
Array.Empty <IArgumentCoercionHandler>());
IReadOnlyCollection <FieldSelection> selections =
collector.CollectFields(schema.QueryType,
operation.SelectionSet, Path.New("foo"));
// assert
Assert.Collection(selections,
selection =>
{
Assert.Collection(selection.Selection.SelectionSet.Selections,
selectionNode =>
{
FragmentSpreadNode fragment = Assert.IsType <FragmentSpreadNode>(
selectionNode);
Assert.Equal("app", fragment.Name.Value);
},
selectionNode =>
{
FragmentSpreadNode fragment = Assert.IsType <FragmentSpreadNode>(
selectionNode);
Assert.Equal("parts", fragment.Name.Value);
});
});
}
public void Fields()
{
// arrange
var errorRaised = false;
Schema schema = CreateSchema();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
a
x:c
}
");
var variables = new VariableValueCollection(
TypeConversion.Default,
new Dictionary <string, object>());
var fragments = new FragmentCollection(schema, query);
OperationDefinitionNode operation = query.Definitions
.OfType <OperationDefinitionNode>().First();
// act
var fieldResolver = new FieldCollector(
fragments,
(f, s) => null,
TypeConversion.Default);
IReadOnlyCollection <FieldSelection> fields = fieldResolver
.CollectFields(
schema.GetType <ObjectType>("Foo"),
operation.SelectionSet,
null);
// assert
Assert.Collection(fields.Where(t => t.IsVisible(variables)),
f =>
{
Assert.Equal("a", f.ResponseName);
Assert.Equal("a", f.Field.Name);
Assert.Equal("String", f.Field.Type.TypeName());
},
f =>
{
Assert.Equal("x", f.ResponseName);
Assert.Equal("c", f.Field.Name);
Assert.Equal("String", f.Field.Type.TypeName());
});
Assert.False(errorRaised);
}
public void GetVariable_Converted()
{
// arrange
var values = new Dictionary <string, VariableValue>
{
{ "abc", new VariableValue("abc", new StringType(), "123") }
};
var variables = new VariableValueCollection(TypeConversion.Default, values);
// act
int value = variables.GetVariable <int>("abc");
// assert
Assert.Equal(123, value);
}
public void GetVariable_StringValue_As_IValueNodeOfString()
{
// arrange
var values = new Dictionary <string, VariableValue>
{
{ "abc", new VariableValue("abc", new StringType(), new StringValueNode("def")) }
};
var variables = new VariableValueCollection(TypeConversion.Default, values);
// act
var value = variables.GetVariable <IValueNode <string> >("abc");
// assert
Assert.Equal("def", value.Value);
}
public void QueryWithNonNullVariableAndDefaultWhereValueIsNull()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: String! = \"foo\") { a }");
var variableValues = new Dictionary <string, object>();
// act
var resolver = new VariableValueBuilder(schema, operation);
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Assert.Equal("foo",
coercedVariableValues.GetVariable <string>("test"));
}
public void GetVariable_Variable_Does_Not_Exist()
{
// arrange
var values = new Dictionary <string, VariableValue>
{
{ "abc", new VariableValue("abc", new StringType(), "123") }
};
var variables = new VariableValueCollection(TypeConversion.Default, values);
// act
Action action = () => variables.GetVariable <int>("def");
// assert
Assert.Throws <QueryException>(action)
.Errors.MatchSnapshot();
}
public void TryGetVariable_Casted()
{
// arrange
var values = new Dictionary <string, VariableValue>
{
{ "abc", new VariableValue("abc", new StringType(), "def") }
};
var variables = new VariableValueCollection(TypeConversion.Default, values);
// act
bool success = variables.TryGetVariable <string>(
"abc", out var value);
// assert
Assert.True(success);
Assert.Equal("def", value);
}
public void TryGetVariable_Variable_Does_Not_Exist()
{
// arrange
var values = new Dictionary <string, VariableValue>
{
{ "abc", new VariableValue("abc", new StringType(), "123") }
};
var variables = new VariableValueCollection(TypeConversion.Default, values);
// act
bool success = variables.TryGetVariable <int>(
"def", out var value);
// assert
Assert.False(success);
Assert.Equal(default(int), value);
}
public void GetVariable_Casted()
{
// arrange
var values = new Dictionary <string, object>
{
{ "abc", "def" }
};
var variables = new VariableValueCollection(
TypeConversion.Default,
values);
// act
string value = variables.GetVariable <string>("abc");
// assert
Assert.Equal("def", value);
}
public void QueryWithNullableVarAndNoDefaultWhereNoValueWasProvided()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: String) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", NullValueNode.Default }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Assert.Null(coercedVariableValues.GetVariable <string>("test"));
}
public void TryGetVariable_Converted()
{
// arrange
var values = new Dictionary <string, object>
{
{ "abc", "123" }
};
var variables = new VariableValueCollection(
TypeConversion.Default,
values);
// act
bool success = variables.TryGetVariable <int>(
"abc", out var value);
// assert
Assert.True(success);
Assert.Equal(123, value);
}
public void MergeMerged()
{
// arrange
DocumentNode query = Utf8GraphQLParser.Parse(
FileResource.Open("MergeQuery.graphql"));
OperationDefinitionNode operation =
query.Definitions.OfType <OperationDefinitionNode>().Single();
var schema = Schema.Create(
FileResource.Open("MergeSchema.graphql"),
c => c.Use(next => context => Task.CompletedTask));
var fragments = new FragmentCollection(schema, query);
var variables = new VariableValueCollection(
TypeConversion.Default,
new Dictionary <string, object>());
var collector = new FieldCollector(
fragments,
(f, s) => null,
TypeConversion.Default,
Array.Empty <IArgumentCoercionHandler>());
IReadOnlyCollection <FieldSelection> selections =
collector.CollectFields(schema.QueryType,
operation.SelectionSet, Path.New("foo"));
// act
selections = collector.CollectFields(
schema.GetType <ObjectType>("Application"),
selections.Single().Selection.SelectionSet,
Path.New("bat"));
// assert
Assert.Collection(selections,
selection => Assert.Equal("id", selection.ResponseName),
selection => Assert.Equal("name", selection.ResponseName),
selection => Assert.Equal("parts", selection.ResponseName));
}
public void Variable_InputObjectAsClrType_NonNullFieldNull()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BazInput) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new Baz {
Bar = "bar"
} }
};
// act
var resolver = new VariableValueBuilder(schema, operation);
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Assert.Equal("bar", coercedVariableValues.GetVariable <Baz>("test").Bar);
}
public void Variable_List_NonNullListItemHasValue()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: [String!]) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new List <string> {
"abc"
} }
};
// act
var resolver = new VariableValueBuilder(schema, operation);
VariableValueCollection variables =
resolver.CreateValues(variableValues);
// assert
variables.GetVariable <List <string> >("test").MatchSnapshot();
}
public void CoerceEnumFromEnumValueNode()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BarEnum!) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new EnumValueNode("A") }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Assert.Equal(BarEnum.A,
coercedVariableValues.GetVariable <BarEnum>("test"));
}
public void CreateValues_SerializedDecimal_Decimal()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: Decimal) { a }");
var input = 1.000000E-004;
var variableValues = new Dictionary <string, object>();
variableValues.Add("test", input);
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
var result = coercedVariableValues.GetVariable <decimal>("test");
Assert.Equal(0.0001m, result);
}
public void CreateValues_IntValue_Int(int value)
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: Int) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", value }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
var result = coercedVariableValues.GetVariable <int>("test");
Assert.Equal(value, result);
}
public void Coerce_Variable_Value_Int_To_Float()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: Float!) { a }");
var variableValues = new Dictionary <string, object>
{
{
"test",
123
}
};
// act
var resolver = new VariableValueBuilder(schema, operation);
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Assert.Equal((float)123,
coercedVariableValues.GetVariable <float>("test"));
}
