private ISchema CreateSchema()
{
var builder = new TestServerBuilder();
var defaultScalars = new DefaultScalarTypeProvider();
foreach (var scalarConcreteType in defaultScalars.ConcreteTypes)
{
builder.AddGraphType(scalarConcreteType);
}
builder.AddGraphType(typeof(TestEnum));
return(builder.Build().Schema);
}
public void Introspected_ListType_NotNullType_NotNullList_PropertyCheck()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <string>()
.Build();
var schema = new IntrospectedSchema(server.Schema);
schema.Rebuild();
var scalar = GraphQLProviders.ScalarProvider.RetrieveScalar(typeof(string));
var spected = schema.FindIntrospectedType(scalar);
var wrapped = Introspection.WrapBaseTypeWithModifiers(spected, GraphTypeExpression.RequiredListRequiredItem);
Assert.AreEqual(TypeKind.NON_NULL, wrapped.Kind);
var unwrappedList = wrapped.OfType;
Assert.AreEqual(TypeKind.LIST, unwrappedList.Kind);
var unwrappedItemType = unwrappedList.OfType;
Assert.AreEqual(TypeKind.NON_NULL, unwrappedItemType.Kind);
var itemType = unwrappedItemType.OfType;
Assert.AreEqual(spected, itemType);
}
public void Introspected_ListType_PropertyCheck()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <string>()
.Build();
var schema = new IntrospectedSchema(server.Schema);
schema.Rebuild();
var scalar = GraphQLProviders.ScalarProvider.RetrieveScalar(typeof(string));
var spected = schema.FindIntrospectedType(scalar);
var wrapped = Introspection.WrapBaseTypeWithModifiers(spected, MetaGraphTypes.IsList);
Assert.AreEqual(TypeKind.LIST, wrapped.Kind);
Assert.IsNull(wrapped.Fields);
Assert.IsNull(wrapped.Interfaces);
Assert.IsNull(wrapped.PossibleTypes);
Assert.IsNull(wrapped.EnumValues);
Assert.IsNull(wrapped.InputFields);
Assert.IsNull(wrapped.Name);
Assert.IsNull(wrapped.Description);
Assert.AreEqual(spected, wrapped.OfType);
}
public void IntrospectedUnion_PropertyCheck()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <SodaFountainController>()
.Build();
var proxy = new SodaTypeUnionProxy();
var schema = new IntrospectedSchema(server.Schema);
schema.Rebuild();
var spected = schema.FindIntrospectedType(proxy.Name);
spected.Initialize(schema);
Assert.AreEqual(proxy.Name, spected.Name);
Assert.AreEqual(proxy.Description, spected.Description);
Assert.AreEqual(TypeKind.UNION, spected.Kind);
Assert.AreEqual(2, spected.PossibleTypes.Count);
Assert.IsTrue(spected.PossibleTypes.Any(x => x.Name == "SodaTypeA"));
Assert.IsTrue(spected.PossibleTypes.Any(x => x.Name == "SodaTypeB"));
Assert.IsNull(spected.Fields);
Assert.IsNull(spected.Interfaces);
Assert.IsNull(spected.EnumValues);
Assert.IsNull(spected.InputFields);
Assert.IsNull(spected.OfType);
}
public void IntrospectedScalar_PropertyCheck()
{
var serverBuilder = new TestServerBuilder();
serverBuilder.AddGraphType <string>();
var server = serverBuilder.Build();
var schema = new IntrospectedSchema(server.Schema);
var scalar = GraphQLProviders.ScalarProvider.RetrieveScalar(typeof(string));
var spected = new IntrospectedType(scalar);
spected.Initialize(schema);
Assert.AreEqual(scalar.Name, spected.Name);
Assert.AreEqual(scalar.Description, spected.Description);
Assert.AreEqual(scalar.Kind, spected.Kind);
Assert.IsNull(spected.Fields);
Assert.IsNull(spected.Interfaces);
Assert.IsNull(spected.PossibleTypes);
Assert.IsNull(spected.EnumValues);
Assert.IsNull(spected.InputFields);
Assert.IsNull(spected.OfType);
}
public async Task Schema_QueryAndMutationTypeNames_ReturnsValidData()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <SodaCanController>()
.Build();
var builder = server.CreateQueryContextBuilder();
// need to resolve type field now
builder.AddQueryText(@"{
__schema
{
queryType { name }
mutationType { name }
}
}");
var response = await server.RenderResult(builder);
var output =
@"{
""data"": {
""__schema"" : {
""queryType"" : {""name"": ""Query""},
""mutationType"" : null
}
}
}";
CommonAssertions.AreEqualJsonStrings(output, response);
}
public async Task SingleType_ScalarType_ReturnsValidData()
{
var serverBuilder = new TestServerBuilder();
// contains an enum CapacityType on SodaCanBuildingData
var server = serverBuilder.AddGraphType <SodaCanBuildingController>().Build();
var builder = server.CreateQueryContextBuilder();
// need to resolve type field now
builder.AddQueryText(@"{
__type(name: ""Int"")
{
name kind
}
}");
var response = await server.RenderResult(builder);
var output = @"
{
""data"": {
""__type"": {
""name"": ""Int"",
""kind"" : ""SCALAR"",
}
}
}";
CommonAssertions.AreEqualJsonStrings(output, response);
}
private (IGraphQLHttpProcessor <GraphSchema> Processor, HttpContext Context) CreateQueryArtifacts(GraphQueryData data = null)
{
var builder = new TestServerBuilder(TestOptions.UseCodeDeclaredNames);
builder.AddGraphType <CandyController>();
var server = builder.Build();
return(server.CreateHttpQueryProcessor(), server.CreateHttpContext(data));
}
public async Task SingleType_EnumType_ReturnsValidData()
{
var serverBuilder = new TestServerBuilder();
// contains an enum CapacityType on SodaCanBuildingData
var server = serverBuilder.AddGraphType <SodaCanBuildingController>()
.AddSchemaBuilderAction(o =>
{
o.Options.ResponseOptions.ExposeExceptions = true;
})
.Build();
var builder = server.CreateQueryContextBuilder();
// need to resolve type field now
builder.AddQueryText(@"{
__type(name: ""CapacityType"")
{
name
kind
enumValues (includeDeprecated: true) {name description isDeprecated deprecationReason}
}
}");
var response = await server.RenderResult(builder);
var output = @"
{
""data"": {
""__type"": {
""name"": ""CapacityType"",
""kind"" : ""ENUM"",
""enumValues"": [
{
""name"": ""SMALL"",
""description"": ""A small room"",
""isDeprecated"": false,
""deprecationReason"" : null,
},
{
""name"": ""MEDIUM"",
""description"": null,
""isDeprecated"": false,
""deprecationReason"" : null,
},
{
""name"": ""LARGE"",
""description"": null,
""isDeprecated"": true,
""deprecationReason"" : ""Room too big"",
},
]}
}
}";
CommonAssertions.AreEqualJsonStrings(output, response);
}
public async Task StandardExcution_EnsureResultsMakeSense()
{
var serverBuilder = new TestServerBuilder(TestOptions.IncludeMetrics);
serverBuilder.AddGraphType <SimpleExecutionController>();
var server = serverBuilder.Build();
var builder = server.CreateQueryContextBuilder()
.AddQueryText("query Operation1{ simple { simpleQueryMethod { property1 } } }")
.AddOperationName("Operation1");
builder.AddMetrics(new ApolloTracingMetricsV1(server.Schema));
var context = builder.Build();
await server.ExecuteQuery(context);
var metrics = context.Metrics as ApolloTracingMetricsV1;
Assert.AreEqual(0, context.Messages.Count);
// parse, validation, execution
Assert.AreEqual(3, metrics.PhaseEntries.Count);
// simple, SimpleQueryMethod, Property1
Assert.AreEqual(3, metrics.ResolverEntries.Count);
// ensure phase ordering follows natural progression
var parsePhase = metrics.PhaseEntries[ApolloExecutionPhase.PARSING];
var validationPhase = metrics.PhaseEntries[ApolloExecutionPhase.VALIDATION];
var executionPhase = metrics.PhaseEntries[ApolloExecutionPhase.EXECUTION];
Assert.IsTrue(parsePhase.StartOffsetTicks < parsePhase.EndOffsetTicks);
Assert.IsTrue(parsePhase.EndOffsetTicks < validationPhase.StartOffsetTicks);
Assert.IsTrue(validationPhase.StartOffsetTicks < validationPhase.EndOffsetTicks);
Assert.IsTrue(validationPhase.EndOffsetTicks < executionPhase.StartOffsetTicks);
Assert.IsTrue(executionPhase.StartOffsetTicks < executionPhase.EndOffsetTicks);
Assert.IsTrue(executionPhase.EndOffsetTicks < metrics.TotalTicks);
// ensure resolver tree follows natural progresion
var simple = metrics.ResolverEntries.First(x => x.Key.Field.Name == "simple").Value;
var queryMethod = metrics.ResolverEntries.First(x => x.Key.Field.Name == "simpleQueryMethod").Value;
var property1 = metrics.ResolverEntries.First(x => x.Key.Field.Name == "property1").Value;
Assert.IsTrue(executionPhase.StartOffsetTicks < simple.StartOffsetTicks);
Assert.IsTrue(simple.StartOffsetTicks < simple.EndOffsetTicks);
Assert.IsTrue(simple.EndOffsetTicks < queryMethod.StartOffsetTicks);
Assert.IsTrue(queryMethod.StartOffsetTicks < queryMethod.EndOffsetTicks);
Assert.IsTrue(queryMethod.EndOffsetTicks < property1.StartOffsetTicks);
Assert.IsTrue(property1.StartOffsetTicks < property1.EndOffsetTicks);
Assert.IsTrue(property1.EndOffsetTicks < executionPhase.EndOffsetTicks);
}
public async Task SingleType_WrappedTypeOnField_ReturnsValidData()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <VendingMachineController>().Build();
var builder = server.CreateQueryContextBuilder();
// need to resolve type field now
builder.AddQueryText(@"{
__type(name: ""Query_Vending"")
{
name
fields{
name
type {
kind
ofType {
kind
ofType {name kind }
}
}
}
}
}");
var response = await server.RenderResult(builder);
var output = @"
{
""data"": {
""__type"": {
""name"": ""Query_Vending"",
""fields"": [
{
""name"": ""cansPerRow"",
""type"": {
""kind"": ""LIST"",
""ofType"": {
""kind"": ""NON_NULL"",
""ofType"": {
""name"": ""Int"",
""kind"": ""SCALAR""
}
}
}
}]
}
}
}";
CommonAssertions.AreEqualJsonStrings(output, response);
}
private TestServer <GraphSchema> CreateTestServer(out TestLogger logInstance)
{
// fake a logger with a single instance that will accept
// log entries from the run time so they can be validated in the test.
logInstance = new TestLogger();
var builder = new TestServerBuilder();
builder.AddGraphType <LogTestController>();
builder.AddGraphQLLocalQueryCache();
builder.Logging.AddLoggerProvider(new TestLoggingProvider(logInstance));
builder.Logging.SetMinimumLogLevel(LogLevel.Trace);
return(builder.Build());
}
public async Task Schema_TypeNameAndKind_ThroughAFragment_ReturnsValidData()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <SodaCanController>().Build();
var builder = server.CreateQueryContextBuilder();
builder.AddQueryText(@"
{
__schema
{
types {
...FullType
}
}
}
fragment FullType on __Type {
kind
name
}");
var response = await server.RenderResult(builder);
var output = @"
{
""data"": {
""__schema"": {
""types"": [
{ ""name"": ""__DirectiveLocation"", ""kind"": ""ENUM"" },
{ ""name"": ""__InputValue"", ""kind"": ""OBJECT"" },
{ ""name"": ""__Directive"", ""kind"": ""OBJECT"" },
{ ""name"": ""__Type"", ""kind"": ""OBJECT"" },
{ ""name"": ""__TypeKind"", ""kind"": ""ENUM"" },
{ ""name"": ""__Schema"", ""kind"": ""OBJECT"" },
{ ""name"": ""__Field"", ""kind"": ""OBJECT"" },
{ ""name"": ""__EnumValue"", ""kind"": ""OBJECT"" },
{ ""name"": ""String"", ""kind"": ""SCALAR"" },
{ ""name"": ""Boolean"", ""kind"": ""SCALAR"" },
{ ""name"": ""Int"", ""kind"": ""SCALAR"" },
{ ""name"": ""SodaCan"", ""kind"": ""OBJECT"" },
{ ""name"": ""Query_Sodas"", ""kind"": ""OBJECT"" },
{ ""name"": ""Query"", ""kind"": ""OBJECT"" },
]
}
}
}";
CommonAssertions.AreEqualJsonStrings(output, response);
}
public void IntrospectedEnum_PropertyCheck()
{
var serverBuilder = new TestServerBuilder(TestOptions.UseCodeDeclaredNames);
var server = serverBuilder
.AddGraphType <IntrospectableEnum>()
.Build();
var template = TemplateHelper.CreateEnumTemplate <IntrospectableEnum>();
var schema = new IntrospectedSchema(server.Schema);
schema.Rebuild();
var enumGraphType = server.CreateGraphType(typeof(IntrospectableEnum), TypeKind.ENUM).GraphType as IEnumGraphType;
Assert.IsNotNull(enumGraphType);
var spected = schema.FindIntrospectedType(enumGraphType);
Assert.AreEqual(enumGraphType.Name, spected.Name);
Assert.AreEqual(enumGraphType.Description, spected.Description);
Assert.AreEqual(enumGraphType.Kind, spected.Kind);
Assert.IsNotNull(spected.EnumValues);
var expected1 = template.Values[0];
var expected2 = template.Values[1];
var val1 = spected.EnumValues[0];
var val2 = spected.EnumValues[1];
Assert.AreEqual(expected1.Name, val1.Name);
Assert.AreEqual(expected1.Description, val1.Description);
Assert.AreEqual(expected1.IsDeprecated, val1.IsDeprecated);
Assert.AreEqual(expected1.DeprecationReason, val1.DeprecationReason);
Assert.AreEqual(expected2.Name, val2.Name);
Assert.AreEqual(expected2.Description, val2.Description);
Assert.AreEqual(expected2.IsDeprecated, val2.IsDeprecated);
Assert.AreEqual(expected2.DeprecationReason, val2.DeprecationReason);
Assert.IsNull(spected.Fields);
Assert.IsNull(spected.Interfaces);
Assert.IsNull(spected.PossibleTypes);
Assert.IsNull(spected.InputFields);
Assert.IsNull(spected.OfType);
}
public async Task Schema_FieldYieldsAUnion_ReturnsValidData()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <SodaFountainController>().Build();
var builder = server.CreateQueryContextBuilder();
builder.AddQueryText(@"{
__schema
{
types { name kind }
}
}");
var response = await server.RenderResult(builder);
var output = @"
{
""data"": {
""__schema"": {
""types"": [
{ ""name"": ""__DirectiveLocation"", ""kind"": ""ENUM"" },
{ ""name"": ""__InputValue"", ""kind"": ""OBJECT"" },
{ ""name"": ""__Directive"", ""kind"": ""OBJECT"" },
{ ""name"": ""__Type"", ""kind"": ""OBJECT"" },
{ ""name"": ""__TypeKind"", ""kind"": ""ENUM"" },
{ ""name"": ""__Schema"", ""kind"": ""OBJECT"" },
{ ""name"": ""__Field"", ""kind"": ""OBJECT"" },
{ ""name"": ""__EnumValue"", ""kind"": ""OBJECT"" },
{ ""name"": ""String"", ""kind"": ""SCALAR"" },
{ ""name"": ""Boolean"", ""kind"": ""SCALAR"" },
{ ""name"": ""SodaTypeA"", ""kind"": ""OBJECT"" },
{ ""name"": ""SodaTypeB"", ""kind"": ""OBJECT"" },
{ ""name"": ""SodaTypes"", ""kind"": ""UNION"" },
{ ""name"": ""Query_Fountain"", ""kind"": ""OBJECT"" },
{ ""name"": ""Query"", ""kind"": ""OBJECT"" },
]
}
}
}
";
CommonAssertions.AreEqualJsonStrings(output, response);
}
public void Introspected_NotNullType_WhenSuppliedANotNullType_ThrowsException()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <string>()
.Build();
var schema = new IntrospectedSchema(server.Schema);
schema.Rebuild();
var scalar = GraphQLProviders.ScalarProvider.RetrieveScalar(typeof(string));
var spected = schema.FindIntrospectedType(scalar);
var wrapped = Introspection.WrapBaseTypeWithModifiers(spected, MetaGraphTypes.IsNotNull);
Assert.Throws <GraphTypeDeclarationException>(() =>
{
var _ = new IntrospectedType(wrapped, TypeKind.NON_NULL);
});
}
public async Task Schema_EnumValues_ReturnsValidData()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <IntrospectableEnum>()
.Build();
var builder = server.CreateQueryContextBuilder();
builder.AddQueryText(@"
{
__type(name: ""IntrospectableEnum"")
{
kind
name
enumValues (includeDeprecated: true) { name }
}
}");
var response = await server.RenderResult(builder);
var output = @"
{
""data"": {
""__type"": {
""kind"": ""ENUM"",
""name"": ""IntrospectableEnum"",
""enumValues"": [
{
""name"" : ""VALUE1""
},
{
""name"" : ""VALUE2""
}
]
}
}
}";
CommonAssertions.AreEqualJsonStrings(output, response);
}
public async Task SingleType_FieldYieldsAUnion_UnionDeliversPossibleTypes()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <SodaFountainController>().Build();
var builder = server.CreateQueryContextBuilder();
builder.AddQueryText(@"
{
__type(name : ""SodaTypes"")
{
name kind possibleTypes { name kind } fields
}
}");
var response = await server.RenderResult(builder);
var output = @"
{
""data"": {
""__type"": {
""name"": ""SodaTypes"",
""kind"": ""UNION"",
""possibleTypes"": [
{
""name"": ""SodaTypeA"",
""kind"": ""OBJECT""
},
{
""name"": ""SodaTypeB"",
""kind"": ""OBJECT""
}
],
""fields"" : null
}
}
} ";
CommonAssertions.AreEqualJsonStrings(output, response);
}
public void IntrospectedSchema_PropertyCheck()
{
var serverBuilder = new TestServerBuilder();
serverBuilder.AddGraphType <string>();
var server = serverBuilder.Build();
var schema = new IntrospectedSchema(server.Schema);
schema.Rebuild();
Assert.AreEqual(server.Schema.Name, schema.Name);
Assert.IsNotNull(schema.FindGraphType(Constants.ScalarNames.STRING));
Assert.IsNotNull(schema.FindIntrospectedType(Constants.ScalarNames.STRING));
Assert.AreEqual(11, schema.KnownTypes.Count());
Assert.IsNotNull(schema.QueryType);
Assert.IsNull(schema.MutationType);
Assert.IsNull(schema.SubscriptionType);
Assert.IsNotNull(schema.Directives);
Assert.AreEqual(2, schema.Directives.Count()); // skip , include
}
public async Task ProductionDefaults_NoChanges()
{
var builder = new TestServerBuilder();
var server = builder.AddGraphType <FanController>()
.Build();
var queryBuilder = server.CreateQueryContextBuilder();
queryBuilder.AddQueryText("{ retrieveFan(name: \"bob\"){ id, name, fanSpeed} }");
var result = await server.RenderResult(queryBuilder).ConfigureAwait(false);
var expectedResult = @"
{
""data"" : {
""retrieveFan"": {
""id"" : 1,
""name"" : ""bob"",
""fanSpeed"" : ""MEDIUM""
}
}
}";
CommonAssertions.AreEqualJsonStrings(expectedResult, result);
}
public async Task SingleType_ObjectType_Interfaces_ReturnsValidData()
{
var serverBuilder = new TestServerBuilder();
// contains an enum CapacityType on SodaCanBuildingData
var server = serverBuilder.AddGraphType <SodaCan2>()
.AddGraphType <ICan>()
.Build();
var builder = server.CreateQueryContextBuilder();
// need to resolve type field now
builder.AddQueryText(@"{
__type(name: ""SodaCan2"")
{
name
kind
interfaces { name kind }
}
}");
var response = await server.RenderResult(builder);
var output = @"
{
""data"": {
""__type"": {
""name"": ""SodaCan2"",
""kind"" : ""OBJECT"",
""interfaces"": [{""name"" : ""ICan"", ""kind"" : ""INTERFACE""}]
}
}
}";
CommonAssertions.AreEqualJsonStrings(output, response);
}
public async Task EndToEndIntegrationTest()
{
var builder = new TestServerBuilder();
builder.AddScoped <IMusicService, MusicService>();
builder.AddSingleton <IMusicRepository, MusicRepository>();
builder.AddGraphType <MusicController>();
builder.AddGraphQL(o =>
{
o.ExecutionOptions.AwaitEachRequestedField = true;
});
var server = builder.Build();
// Test the following areas
// -----------------------------------
// queries
// input values: scalars
// batch child query ("records" is a batch list extension method)
// root level controller actions (note no nesting under the declared "music" field of the controller for the "artists" field)
var expected = LoadOutputFile("RetrieveArtistsAndRecords.json");
var queryBuilder = server.CreateQueryContextBuilder();
queryBuilder.AddQueryText(
@"query {
artists(searchText: ""queen"") {
id
name
records {
id
name
genre {
id
name
}
}
}
}");
var result1 = await server.RenderResult(queryBuilder);
CommonAssertions.AreEqualJsonStrings(expected, result1, "(1): " + result1);
// Test the following areas
// -----------------------------------
// virtual routing (the "music" field is a virtual field declared on the controller)
// mutations
// input values: scalars
// batch sybling query ("company" is a batch sybling extension method)
expected = LoadOutputFile("CreateNewArtist.json");
queryBuilder = server.CreateQueryContextBuilder();
queryBuilder.AddQueryText(
@"mutation {
music{
createArtist(artistName: ""EXO"", recordCompanyId: 4) {
id
name
company {
id
name
}
}
}}");
var result2 = await server.RenderResult(queryBuilder);
CommonAssertions.AreEqualJsonStrings(expected, result2, "(2): " + result2);
// Test the following areas
// -----------------------------------
// virtual routing (the "music" field is a virtual field declared on the controller)
// mutations
// input values: complex objects
// unicode characters
expected = LoadOutputFile("CreateRecord.json");
queryBuilder = server.CreateQueryContextBuilder();
queryBuilder.AddQueryText(
@"mutation {
music{
createRecord(artist: {id: 10, name: ""EXO"", recordCompanyId: 4},
genre: {id:2, name: ""pop""},
songName:""다이아몬드"") {
id
artistId
genre { id name }
name
}
}}");
var result3 = await server.RenderResult(queryBuilder);
CommonAssertions.AreEqualJsonStrings(expected, result3, "(3): " + result3);
}
public async Task StandardExcution_OutputTest()
{
var serverBuilder = new TestServerBuilder(TestOptions.IncludeMetrics);
serverBuilder.AddGraphType <SimpleExecutionController>();
serverBuilder.AddGraphQL(o =>
{
o.ResponseOptions.ExposeMetrics = true;
});
var server = serverBuilder.Build();
var builder = server.CreateQueryContextBuilder()
.AddQueryText("query Operation1{ simple { simpleQueryMethod { property1} } }")
.AddOperationName("Operation1");
var metrics = new ApolloTracingMetricsV1(server.Schema);
builder.AddMetrics(metrics);
var result = await server.RenderResult(builder);
var parsePhase = metrics.PhaseEntries[ApolloExecutionPhase.PARSING];
var validationPhase = metrics.PhaseEntries[ApolloExecutionPhase.VALIDATION];
var simple = metrics.ResolverEntries.First(x => x.Key.Field.Name == "simple").Value;
var queryMethod = metrics.ResolverEntries.First(x => x.Key.Field.Name == "simpleQueryMethod").Value;
var property1 = metrics.ResolverEntries.First(x => x.Key.Field.Name == "property1").Value;
var expectedResult = @"
{
""data"": {
""simple"": {
""simpleQueryMethod"": {
""property1"": ""default string""
}
}
},
""extensions"": {
""tracing"": {
""version"": 1,
""startTime"": ""[StartTime]"",
""endTime"": ""[EndTime]"",
""duration"": [Duration],
""parsing"": {
""startOffset"": [ParsingOffset],
""duration"": [ParsingDuration]
},
""validation"": {
""startOffset"":[ValidationOffset],
""duration"": [ValidationDuration]
},
""execution"": {
""resolvers"": [
{
""path"": [""simple""],
""fieldName"": ""simple"",
""parentType"" : ""Query"",
""returnType"": ""Query_Simple"",
""startOffset"": [simpleStartOffset],
""duration"": [simpleDuration]
},
{
""path"": [""simple"", ""simpleQueryMethod""],
""fieldName"": ""simpleQueryMethod"",
""parentType"": ""Query_Simple"",
""returnType"": ""TwoPropertyObject"",
""startOffset"": [SimpleQueryMethodOffset],
""duration"": [SimpleQueryMethodDuration]
},
{
""path"": [""simple"", ""simpleQueryMethod"", ""property1""],
""fieldName"": ""property1"",
""parentType"": ""TwoPropertyObject"",
""returnType"": ""String"",
""startOffset"": [Property1Offset],
""duration"": [Property1Duration]
}
]
}
}
}
}";
expectedResult = expectedResult.Replace("[StartTime]", metrics.StartDate.ToRfc3339String())
.Replace("[EndTime]", metrics.StartDate.AddTicks(metrics.TotalTicks).ToRfc3339String())
.Replace("[Duration]", metrics.TotalTicks.ToString())
.Replace("[ParsingOffset]", parsePhase.StartOffsetNanoseconds.ToString())
.Replace("[ParsingDuration]", parsePhase.DurationNanoSeconds.ToString())
.Replace("[ValidationOffset]", validationPhase.StartOffsetNanoseconds.ToString())
.Replace("[ValidationDuration]", validationPhase.DurationNanoSeconds.ToString())
.Replace("[simpleStartOffset]", simple.StartOffsetNanoseconds.ToString())
.Replace("[simpleDuration]", simple.DurationNanoSeconds.ToString())
.Replace("[SimpleQueryMethodOffset]", queryMethod.StartOffsetNanoseconds.ToString())
.Replace("[SimpleQueryMethodDuration]", queryMethod.DurationNanoSeconds.ToString())
.Replace("[Property1Offset]", property1.StartOffsetNanoseconds.ToString())
.Replace("[Property1Duration]", property1.DurationNanoSeconds.ToString());
CommonAssertions.AreEqualJsonStrings(expectedResult, result);
}
public async Task SingleType_InputObjectOnFields_ObjectType_ReturnsValidData()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <SodaBottleController>().Build();
var builder = server.CreateQueryContextBuilder();
// need to resolve type field now
builder.AddQueryText(@"{
__type(name: ""Query_Bottles"")
{
name
kind
fields{
name
args {
name
type {
name
kind
inputFields{
name
description
type {name}
}
}
}
}
}
}");
var response = await server.RenderResult(builder);
var output = @"
{
""data"": {
""__type"": {
""name"": ""Query_Bottles"",
""kind"": ""OBJECT"",
""fields"": [
{
""name"": ""retrieveSodaBottles"",
""args"": [
{
""name"": ""bottleData"",
""type"": {
""name"": ""BottleSearch"",
""kind"": ""INPUT_OBJECT"",
""inputFields"": [
{
""name"": ""name"",
""description"": null,
""type"": {""name"": ""String""},
},
{
""name"": ""size"",
""description"": null,
""type"": {""name"": ""Int""},
}
]
}
}
]
}
]
}
}
}
";
CommonAssertions.AreEqualJsonStrings(output, response);
}
public async Task SingleType_InputScalarsOnFields_ObjectType_ReturnsValidData()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <SodaCanController>()
.Build();
var builder = server.CreateQueryContextBuilder();
// need to resolve type field now
builder.AddQueryText(@"{
__type(name: ""Query_Sodas"")
{
name
kind
fields{
name
args {
name
type {name kind ofType {name kind}}
}
}
}
}");
var response = await server.RenderResult(builder);
var output = @"
{
""data"" : {
""__type"": {
""name"": ""Query_Sodas"",
""kind"": ""OBJECT"",
""fields"": [
{
""name"": ""retrieveSoda"",
""args"": [
{
""name"": ""id"",
""type"": {
""name"": null,
""kind"": ""NON_NULL"",
""ofType"": {
""name"": ""Int"",
""kind"": ""SCALAR""
}
}
}
]
},
{
""name"": ""canCount"",
""args"": [
{
""name"": ""id"",
""type"": {
""name"": null,
""kind"": ""NON_NULL"",
""ofType"": {
""name"": ""Int"",
""kind"": ""SCALAR""
}
}
}
]
}
]
}
}
}
";
CommonAssertions.AreEqualJsonStrings(output, response);
}
public async Task SingleType_NameAndFields_ObjectType_ReturnsValidData()
{
var serverBuilder = new TestServerBuilder();
var server = serverBuilder.AddGraphType <SodaCanController>()
.Build();
var builder = server.CreateQueryContextBuilder();
// need to resolve type field now
builder.AddQueryText(@"{
__type(name: ""SodaCan"")
{
name
description
kind
fields{
name
description
isDeprecated
type {
name
description
kind
}
}
}
}");
var response = await server.RenderResult(builder);
var output = @"{
""data"": {
""__type"": {
""name"": ""SodaCan"",
""description"": null,
""kind"": ""OBJECT"",
""fields"": [
{
""name"": ""brand"",
""description"": null,
""isDeprecated"": false,
""type"": {
""name"": ""String"",
""description"": ""A UTF-8 encoded string of characters."",
""kind"": ""SCALAR""
}
},
{
""name"": ""id"",
""description"": null,
""isDeprecated"": false,
""type"": {
""name"": null,
""description"": null,
""kind"": ""NON_NULL""
}
}
]
}
}
}";
CommonAssertions.AreEqualJsonStrings(output, response);
}
public void IntrospectedObject_PropertyCheck()
{
var serverBuilder = new TestServerBuilder(TestOptions.UseCodeDeclaredNames);
var server = serverBuilder
.AddGraphType <IntrospectableObject>()
.Build();
var template = TemplateHelper.CreateObjectTemplate <IntrospectableObject>();
var schema = new IntrospectedSchema(server.Schema);
schema.Rebuild();
var ogt = server.Schema.KnownTypes.FindGraphType(typeof(IntrospectableObject)) as IObjectGraphType;
var spected = schema.FindIntrospectedType(ogt);
Assert.AreEqual(ogt.Name, spected.Name);
Assert.AreEqual(ogt.Description, spected.Description);
Assert.AreEqual(ogt.Kind, spected.Kind);
Assert.IsNotNull(spected.Fields);
Assert.AreEqual(3, spected.Fields.Count);
var expected0 = template.FieldTemplates[$"[type]/{nameof(IntrospectableObject)}/{nameof(IntrospectableObject.Method1)}"];
var expected1 = template.FieldTemplates[$"[type]/{nameof(IntrospectableObject)}/{nameof(IntrospectableObject.Method2)}"];
var expected2 = template.FieldTemplates[$"[type]/{nameof(IntrospectableObject)}/{nameof(IntrospectableObject.Prop1)}"];
var field0 = spected.Fields.FirstOrDefault(x => x.Name == nameof(IntrospectableObject.Method1));
var field1 = spected.Fields.FirstOrDefault(x => x.Name == nameof(IntrospectableObject.Method2));
var field2 = spected.Fields.FirstOrDefault(x => x.Name == nameof(IntrospectableObject.Prop1));
Assert.IsNotNull(field0);
Assert.AreEqual(field0.Name, expected0.Name);
Assert.AreEqual(nameof(TwoPropertyObject), field0.IntrospectedGraphType.Name);
Assert.AreEqual(field0.Description, expected0.Description);
Assert.AreEqual(field0.IsDeprecated, expected0.IsDeprecated);
Assert.AreEqual(field0.DeprecationReason, expected0.DeprecationReason);
Assert.AreEqual(2, field0.Arguments.Count);
var arg1 = field0.Arguments[0];
var arg2 = field0.Arguments[1];
Assert.IsNotNull(arg1);
Assert.AreEqual(expected0.Arguments[0].Name, arg1.Name);
Assert.AreEqual(expected0.Arguments[0].Description, arg1.Description);
var expectedDefault = $"\"{expected0.Arguments[0].DefaultValue}\"";
Assert.AreEqual(expectedDefault, arg1.DefaultValue);
Assert.IsNotNull(arg2);
Assert.AreEqual(expected0.Arguments[1].Name, arg2.Name);
Assert.AreEqual(expected0.Arguments[1].Description, arg2.Description);
Assert.AreEqual(expected0.Arguments[1].DefaultValue?.ToString(), arg2.DefaultValue);
Assert.IsNotNull(field1);
Assert.AreEqual(field1.Name, expected1.Name);
Assert.AreEqual(nameof(TwoPropertyObjectV2), field1.IntrospectedGraphType.Name);
Assert.AreEqual(field1.Description, expected1.Description);
Assert.AreEqual(field1.IsDeprecated, expected1.IsDeprecated);
Assert.AreEqual(field1.DeprecationReason, expected1.DeprecationReason);
Assert.AreEqual(0, field1.Arguments.Count);
Assert.IsNotNull(field2);
Assert.AreEqual(field2.Name, expected2.Name);
Assert.AreEqual(TypeKind.NON_NULL, field2.IntrospectedGraphType.Kind);
Assert.AreEqual(TypeKind.SCALAR, field2.IntrospectedGraphType.OfType.Kind);
Assert.AreEqual(Constants.ScalarNames.LONG, field2.IntrospectedGraphType.OfType.Name);
Assert.AreEqual(field2.Description, expected2.Description);
Assert.AreEqual(field2.IsDeprecated, expected2.IsDeprecated);
Assert.AreEqual(field2.DeprecationReason, expected2.DeprecationReason);
Assert.AreEqual(0, field2.Arguments.Count);
// the not null wrapper should all be null
Assert.IsNull(field2.IntrospectedGraphType.Fields);
Assert.IsNull(field2.IntrospectedGraphType.EnumValues);
Assert.IsNull(field2.IntrospectedGraphType.Interfaces);
Assert.IsNull(field2.IntrospectedGraphType.PossibleTypes);
Assert.IsNull(field2.IntrospectedGraphType.InputFields);
Assert.IsNull(field2.IntrospectedGraphType.Name);
Assert.IsNull(field2.IntrospectedGraphType.Description);
// objects shoudl always return an interface collection even if empty
Assert.IsNotNull(spected.Interfaces);
Assert.AreEqual(0, spected.Interfaces.Count);
Assert.IsNull(spected.EnumValues);
Assert.IsNull(spected.PossibleTypes);
Assert.IsNull(spected.InputFields);
Assert.IsNull(spected.OfType);
}