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