public void FailureToResolve_YieldErrorMessage()
{
var server = new TestServerBuilder()
.AddGraphType <InputController>()
.Build();
var parser = new GraphQLParser();
// set arg1 to int.max + 1; the int graph type will fail to resolve it
var syntaxTree = parser.ParseQueryDocument("query TestQuery{ input { fetchString(arg1: 2147483648 ) } }".AsMemory());
var docGenerator = new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema);
var document = docGenerator.CreateDocument(syntaxTree);
var queryInputCollection = document.Operations["TestQuery"].FieldSelectionSet[0].FieldSelectionSet[0].Arguments;
var argGenerator = new ArgumentGenerator(server.Schema, queryInputCollection);
var schemaType = server.Schema.KnownTypes.FindGraphType("Query_Input");
var graphFieldArguments = (schemaType as IGraphFieldContainer).Fields["fetchString"].Arguments;
var arg1 = graphFieldArguments["arg1"];
var result = argGenerator.CreateInputArgument(arg1);
Assert.IsNotNull(result);
Assert.IsFalse(result.IsValid);
Assert.IsNull(result.Argument as ResolvedInputArgumentValue);
Assert.IsNotNull(result.Message);
Assert.AreEqual(Constants.ErrorCodes.INVALID_ARGUMENT, result.Message.Code);
}
public void NotFoundArgument_GeneratesResultWithDefaultValue()
{
var server = new TestServerBuilder()
.AddGraphType <InputController>()
.Build();
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument("query TestQuery{ input { fetchString(arg1: 5) } }".AsMemory());
var docGenerator = new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema);
var document = docGenerator.CreateDocument(syntaxTree);
var queryInputCollection = document.Operations["TestQuery"].FieldSelectionSet[0].FieldSelectionSet[0].Arguments;
var argGenerator = new ArgumentGenerator(server.Schema, queryInputCollection);
var schemaType = server.Schema.KnownTypes.FindGraphType("Query_Input");
var graphFieldArguments = (schemaType as IGraphFieldContainer).Fields["fetchString"].Arguments;
var arg2 = graphFieldArguments["arg2"];
var result = argGenerator.CreateInputArgument(arg2);
Assert.IsNotNull(result);
Assert.IsTrue(result.IsValid);
Assert.IsNotNull(result.Argument as ResolvedInputArgumentValue);
Assert.IsNull(result.Message);
// default value on the parameter
var data = result.Argument.Resolve(ResolvedVariableCollection.Empty);
Assert.AreEqual(15, data);
}
public async Task SingleField_WithVariables_UsingDefaults_WithAcceptableArgumentsOnMethod_VariableValueIsAssigned()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(@"query($var1 : Long = 22)
{
simple {
simpleQueryMethod(arg1: ""bob"", arg2: $var1) {
property1
}
}
}".AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(1, plan.Operations.Count);
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
var child = queuedContext.ChildContexts[0];
// Ensur the variable $var1 used its default value and that arg2 is assigned that value
var arg2 = child.Arguments["arg2"];
Assert.IsNotNull(arg2);
}
public void ExpectedDeferredList_DoesDefer()
{
var server = new TestServerBuilder()
.AddGraphType <InputController>()
.Build();
var parser = new GraphQLParser();
// set arg1 to int.max + 1; the int graph type will fail to resolve it
var syntaxTree = parser.ParseQueryDocument("query TestQuery($var1: Int!){ input { fetchArrayTotal(arg3: [1, $var1, 3]) } }".AsMemory());
var docGenerator = new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema);
var document = docGenerator.CreateDocument(syntaxTree);
var queryInputCollection = document.Operations["TestQuery"].FieldSelectionSet[0].FieldSelectionSet[0].Arguments;
var argGenerator = new ArgumentGenerator(server.Schema, queryInputCollection);
var schemaType = server.Schema.KnownTypes.FindGraphType("Query_Input");
var graphFieldArguments = (schemaType as IGraphFieldContainer).Fields["fetchArrayTotal"].Arguments;
var arg3 = graphFieldArguments["arg3"];
var result = argGenerator.CreateInputArgument(arg3);
Assert.IsNotNull(result);
Assert.IsTrue(result.IsValid);
Assert.IsNotNull(result.Argument as DeferredInputArgumentValue);
Assert.IsNull(result.Message);
}
public async Task SingleField_WithAcceptableArgumentsOnMethod_ValidateFields()
{
var server = new TestServerBuilder()
.AddGraphType <SimplePlanGenerationController>()
.Build();
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument("query { simple { simpleQueryMethod(arg1: \"bob\", arg2: 15) { property1} } }".AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.AreEqual(1, plan.Operations.Count);
Assert.AreEqual(0, plan.Messages.Count);
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
var child = queuedContext.ChildContexts[0];
var arg1 = child.Arguments["arg1"];
var arg2 = child.Arguments["arg2"];
Assert.IsNotNull(arg1);
Assert.IsNotNull(arg2);
Assert.AreEqual("bob", arg1.Value.Resolve(ResolvedVariableCollection.Empty));
Assert.AreEqual(15L, arg2.Value.Resolve(ResolvedVariableCollection.Empty));
}
public async Task SingleField_NoExtras_ValidateFields()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument("query { simple { simpleQueryMethod { property1} } }".AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(1, plan.Operations.Count);
// the "simple" virtual field queued to be resolved when the plan
// is executed
var queuedContext = plan.Operations[string.Empty].FieldContexts[0];
Assert.IsNotNull(queuedContext);
Assert.AreEqual("simple", queuedContext.Name);
Assert.AreEqual("simple", queuedContext.Origin.Path.DotString());
// "simple" should contain 1 child field called "simpleQueryMethod"
Assert.AreEqual(0, queuedContext.Arguments.Count);
Assert.AreEqual(1, queuedContext.ChildContexts.Count);
Assert.IsTrue(queuedContext.Field?.Resolver is GraphRouteFieldResolver);
// simpleQueryMethod should contain 1 property to be resolved
var child = queuedContext.ChildContexts[0];
Assert.IsNotNull(child);
Assert.AreEqual("simpleQueryMethod", child.Name);
Assert.AreEqual("simple.simpleQueryMethod", child.Origin.Path.DotString());
Assert.AreEqual(1, child.ChildContexts.Count);
// the defaults defined on the method should have been assigned when none were supplied
// since both were optional.
Assert.AreEqual(2, child.Arguments.Count);
Assert.IsTrue(child.Field?.Resolver is GraphControllerActionResolver);
var arg1 = child.Arguments["arg1"];
var arg2 = child.Arguments["arg2"];
Assert.AreEqual("default string", arg1.Value.Resolve(ResolvedVariableCollection.Empty));
Assert.AreEqual(5, arg2.Value.Resolve(ResolvedVariableCollection.Empty));
// "property1"
var prop1 = child.ChildContexts[0];
Assert.IsNotNull(prop1);
Assert.AreEqual("property1", prop1.Name);
Assert.AreEqual("simple.simpleQueryMethod.property1", prop1.Origin.Path.DotString());
Assert.AreEqual(0, prop1.ChildContexts.Count);
Assert.AreEqual(0, prop1.Arguments.Count);
Assert.IsTrue(prop1.Field?.Resolver is GraphObjectPropertyResolver);
}
public void ParseDocument_KitchenSinkParses()
{
var qualifiedQuery = ResourceLoader.ReadAllLines("KitchenSink", "KitchenSink.graphql");
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(qualifiedQuery.AsMemory());
Assert.IsNotNull(syntaxTree);
}
public void ParseDocument_EmptyQueryParsesDefaultQuery()
{
var qualifiedQuery = "{}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(qualifiedQuery.AsMemory());
Assert.AreEqual(1, syntaxTree.Nodes.Count);
}
public void ParseDocument_InvalidDocumentThrowsException()
{
var text = "query someQuery{field1, field2";
Assert.Throws <GraphQLSyntaxException>(() =>
{
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(text.AsMemory());
});
}
public void ParseDocument_NonQueryThrowsException()
{
var qualifiedQuery = string.Empty;
Assert.Throws <GraphQLSyntaxException>(() =>
{
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(qualifiedQuery.AsMemory());
});
}
public async Task MultipleTypeRestrictedFragments_GeneratesCorrectFieldContexts_WithDuplciatedFieldNamesOnFragments()
{
var server = new TestServerBuilder()
.AddGraphType <FragmentProcessingController>()
.Build();
var query = @"
query {
fragTester {
makeHybridData {
...aData
...bData
}
}
}
fragment aData on FragmentDataA{
property1
}
fragment bData on FragmentDataB{
property1
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(1, plan.Operations.Count);
Assert.AreEqual(0, plan.Messages.Count);
var fragTester = plan.RetrieveOperation().FieldContexts[0];
Assert.IsNotNull(fragTester);
var makeHybridData = fragTester.ChildContexts[0];
Assert.IsNotNull(makeHybridData);
Assert.AreEqual(2, makeHybridData.ChildContexts.Count);
Assert.IsTrue(makeHybridData.ChildContexts.Any(x => x.ExpectedSourceType == typeof(FragmentDataA) && x.Field.Name == "property1"));
Assert.IsTrue(makeHybridData.ChildContexts.Any(x => x.ExpectedSourceType == typeof(FragmentDataB) && x.Field.Name == "property1"));
}
public async Task MultiOperationDocument_SelectsCorrectOperationInPlan()
{
var server = new TestServerBuilder()
.AddGraphType <SimplePlanGenerationController>()
.Build();
var str = @"
query Operation1{ simple { simpleQueryMethod { property1} } }
query Operation2{ simple { simpleQueryMethod { property2} } }
";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(str.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(2, plan.Operations.Count);
// the "simple" virtual field queued to be resolved when the plan
// is executed
var queuedContext = plan.RetrieveOperation("Operation1").FieldContexts[0];
Assert.IsNotNull(queuedContext);
Assert.AreEqual("simple", queuedContext.Name);
// simpleQueryMethod should contain 1 property to be resolved
var child = queuedContext.ChildContexts[0];
Assert.IsNotNull(child);
Assert.AreEqual("simpleQueryMethod", child.Name);
// "property1"
var prop1 = child.ChildContexts[0];
Assert.IsNotNull(prop1);
Assert.AreEqual("property1", prop1.Name);
}
public void ExpectedNonDeferredComplexObject_DoesNotDefer()
{
var server = new TestServerBuilder()
.AddGraphType <InputController>()
.Build();
var parser = new GraphQLParser();
// set arg1 to int.max + 1; the int graph type will fail to resolve it
var syntaxTree = parser.ParseQueryDocument(@"
query TestQuery{
input {
fetchComplexValue(arg4: {
property1: ""bob""
property2: 10
}
)
}
}".AsMemory());
var docGenerator = new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema);
var document = docGenerator.CreateDocument(syntaxTree);
var queryInputCollection = document.Operations["TestQuery"].FieldSelectionSet[0].FieldSelectionSet[0].Arguments;
var argGenerator = new ArgumentGenerator(server.Schema, queryInputCollection);
var schemaType = server.Schema.KnownTypes.FindGraphType("Query_Input");
var graphFieldArguments = (schemaType as IGraphFieldContainer).Fields["fetchComplexValue"].Arguments;
var arg3 = graphFieldArguments["arg4"];
var result = argGenerator.CreateInputArgument(arg3);
Assert.IsNotNull(result);
Assert.IsTrue(result.IsValid);
Assert.IsNotNull(result.Argument as ResolvedInputArgumentValue);
Assert.IsNull(result.Message);
var data = result.Argument.Resolve(ResolvedVariableCollection.Empty) as TwoPropertyObject;
Assert.IsNotNull(data);
Assert.AreEqual("bob", data.Property1);
Assert.AreEqual(10, data.Property2);
}
public async Task Union_WhenAnInterfaceIsSpreadInAUnion_ShouldReturnTheInterfaceFields_ForEachMemberOfTheUnionThatImplementsTheInterface()
{
var server = new TestServerBuilder()
.AddGraphType <SimplePlanGenerationController>()
.AddGraphType <ITwoPropertyObject>()
.Build();
// unionQuery returns a union graphtype of (TwoPropObject | TwoPropObjectV2)
// TwoPropObject implement the interface graphtype TwoPropertyInterface and property1 should
// be included in hte plan for that object graph type reference
// since TwoPropObjectV2 does not implement TwoPropertyInterface it should not be included
var query = @"
query {
simple {
unionQuery {
...RequestedProperties
}
}
}
fragment RequestedProperties on TwoPropertyInterface {
property1
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
// simple -> SimpleQueryMthod
var unionQueryField = plan.RetrieveOperation().FieldContexts[0].ChildContexts[0];
// prop1 for TwoPropObject
Assert.AreEqual(1, unionQueryField.ChildContexts.Count);
Assert.IsTrue(unionQueryField.ChildContexts.Any(x => x.Name == "property1" && x.ExpectedSourceType == typeof(TwoPropertyObject)));
}
public async Task Union_TypeName_AsAFieldSelectionDirectlyOnAUnion_ProducesTypeNameFieldForAllMembersOfTheUnion()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
// unionQuery returns a union graphtype of TwoPropObject and TwoPropObjectV2
// specific fields for V1 are requested but V2 should be included with __typename as well
var query = @"
query {
simple {
unionQuery {
...RequestedProperties
__typename
}
}
}
fragment RequestedProperties on TwoPropertyObject {
property1
property2
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
// simple -> SimpleQueryMthod
var unionQueryField = plan.RetrieveOperation().FieldContexts[0].ChildContexts[0];
// prop1 for TwoPropObject, prop2 fro TwoPropObject, __typename for TwoPropObject, __typename for TwoPropObjectV2
Assert.AreEqual(4, unionQueryField.ChildContexts.Count);
Assert.IsTrue(unionQueryField.ChildContexts.Any(x => x.Name == "property1" && x.ExpectedSourceType == typeof(TwoPropertyObject)));
Assert.IsTrue(unionQueryField.ChildContexts.Any(x => x.Name == "property2" && x.ExpectedSourceType == typeof(TwoPropertyObject)));
Assert.IsTrue(unionQueryField.ChildContexts.Any(x => x.Name == "__typename" && x.ExpectedSourceType == typeof(TwoPropertyObject)));
Assert.IsTrue(unionQueryField.ChildContexts.Any(x => x.Name == "__typename" && x.ExpectedSourceType == typeof(TwoPropertyObjectV2)));
}
public async Task WhenTheSameFieldIsReferencedMoreThanOnce_ForAGivenType_FieldsAreMerged_Correctly()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
// Property 1 is referenced in the query and in the fragment such that when spread prop1 would be included twice
// at the same level
//
// These two instnaces can be merged and Property 1 (for the TwoPropertyObject) should only end up in the plan once
var query = @"
query {
simple {
simpleQueryMethod {
property1
...methodProperties
}
}
}
fragment methodProperties on TwoPropertyObject {
property1
property2
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
// simple -> SimpleQueryMthod
var simpleQueryMethodField = plan.RetrieveOperation().FieldContexts[0].ChildContexts[0];
Assert.AreEqual(2, simpleQueryMethodField.ChildContexts.Count);
Assert.IsTrue(simpleQueryMethodField.ChildContexts.Any(x => x.Name == "property1"));
Assert.IsTrue(simpleQueryMethodField.ChildContexts.Any(x => x.Name == "property2"));
}
public async Task SingleField_WithVariables_UsingDefaultValues_NestedInInputObjects_YieldsCorrectInputObject()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
// arg1 represents a TWoPropertyObjectV2 with a prop1 type of float
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(@"query($var1 : Float! = 15.5)
{
simple {
complexQueryMethod(arg1: { property1: $var1, property2: 0} ) {
property1
}
}
}".AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(1, plan.Operations.Count);
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
Assert.AreEqual(1, queuedContext.ChildContexts.Count);
var child = queuedContext.ChildContexts[0];
// Ensure the variable $var1 is used as the value of property1
// using hte default value in the query
var arg1 = child.Arguments["arg1"];
Assert.IsNotNull(arg1);
}
public async Task SingleField_WithFragment_AndMultiLevelDirectives_ValidateDirectiveAssociations()
{
var server = new TestServerBuilder()
.AddGraphType <SimplePlanGenerationController>()
.AddGraphType <Sample1Directive>()
.AddGraphType <Sample2Directive>()
.AddGraphType <Sample3Directive>()
.Build();
var query = @"
query {
simple {
simpleQueryMethod {
...methodProperties @sample2
}
}
}
fragment methodProperties on TwoPropertyObject @sample1 {
property1 @sample3
property2
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(1, plan.Operations.Count);
Assert.AreEqual(0, plan.Messages.Count);
// the "simple" virtual field queued to be resolved when the plan
// is executed
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
Assert.IsNotNull(queuedContext);
Assert.AreEqual("simple", queuedContext.Name);
// simpleQueryMethod should contain 2 properties to be resolved (the two props on the fragment)
var child = queuedContext.ChildContexts[0];
Assert.IsNotNull(child);
Assert.AreEqual("simpleQueryMethod", child.Name);
Assert.AreEqual(2, child.ChildContexts.Count);
// "property1"
var prop1 = child.ChildContexts[0];
Assert.IsNotNull(prop1);
Assert.AreEqual(3, prop1.Directives.Count);
Assert.AreEqual("sample2", prop1.Directives[0].Directive.Name);
Assert.AreEqual("sample1", prop1.Directives[1].Directive.Name);
Assert.AreEqual("sample3", prop1.Directives[2].Directive.Name);
// "property2"
var prop2 = child.ChildContexts[1];
Assert.IsNotNull(prop2);
Assert.AreEqual(2, prop2.Directives.Count);
Assert.AreEqual("sample2", prop2.Directives[0].Directive.Name);
Assert.AreEqual("sample1", prop2.Directives[1].Directive.Name);
}
public async Task SingleField_WithFragment_ValidateFields()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
var query = @"
query {
simple {
simpleQueryMethod {
...methodProperties
}
}
}
fragment methodProperties on TwoPropertyObject {
property1
property2
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(1, plan.Operations.Count);
// the "simple" virtual field queued to be resolved when the plan
// is executed
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
Assert.IsNotNull(queuedContext);
Assert.AreEqual("simple", queuedContext.Name);
// "simple" should contain 1 child field called "simpleQueryMethod"
Assert.AreEqual(0, queuedContext.Arguments.Count);
Assert.AreEqual(1, queuedContext.ChildContexts.Count);
Assert.IsTrue(queuedContext.Field?.Resolver is GraphRouteFieldResolver);
// simpleQueryMethod should contain 2 properties to be resolved (the two props on the fragment)
var child = queuedContext.ChildContexts[0];
Assert.IsNotNull(child);
Assert.AreEqual("simpleQueryMethod", child.Name);
Assert.AreEqual(2, child.ChildContexts.Count);
// the defaults defined on the method should have been assigned when none were supplied
// but both were optional.
Assert.AreEqual(2, child.Arguments.Count);
Assert.IsTrue(child.Field?.Resolver is GraphControllerActionResolver);
// "property1"
var prop1 = child.ChildContexts[0];
Assert.IsNotNull(prop1);
Assert.AreEqual("property1", prop1.Name);
Assert.AreEqual(0, prop1.ChildContexts.Count);
Assert.AreEqual(0, prop1.Arguments.Count);
Assert.IsTrue(prop1.Field?.Resolver is GraphObjectPropertyResolver);
// "property2"
var prop2 = child.ChildContexts[1];
Assert.IsNotNull(prop2);
Assert.AreEqual("property2", prop2.Name);
Assert.AreEqual(0, prop2.ChildContexts.Count);
Assert.AreEqual(0, prop2.Arguments.Count);
Assert.IsTrue(prop2.Field?.Resolver is GraphObjectPropertyResolver);
}
