public void MergeIdenticalEnumsTakeDescriptionFromSecondType()
{
// arrange
DocumentNode schema_a =
Parser.Default.Parse("enum Foo { BAR BAZ }");
DocumentNode schema_b =
Parser.Default.Parse(@"""Foo Bar"" enum Foo { BAR BAZ }");
var types = new List <ITypeInfo>
{
TypeInfo.Create(
schema_a.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_A", schema_a)),
TypeInfo.Create(
schema_b.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_B", schema_b))
};
var context = new SchemaMergeContext();
// act
var typeMerger = new EnumTypeMergeHandler((c, t) => { });
typeMerger.Merge(context, types);
// assert
SchemaSyntaxSerializer.Serialize(context.CreateSchema())
.MatchSnapshot();
}
public void AddExtensionsFromFile()
{
// arrange
var builder = new MockStitchingBuilder();
// act
builder.AddExtensionsFromFile(
IOPath.Combine("__resources__", "Contract.graphql"))
.AddExtensionsFromFile(
IOPath.Combine("__resources__", "Customer.graphql"));
// assert
var services = new EmptyServiceProvider();
var merger = new SchemaMerger();
var list = new List <string>();
foreach (LoadSchemaDocument item in builder.Extensions)
{
list.Add(SchemaSyntaxSerializer.Serialize(
item.Invoke(services)));
}
list.MatchSnapshot();
}
public void Merge_SimpleIdenticalDirectives_TypeMerges()
{
// arrange
DocumentNode schema_a =
Parser.Default.Parse("directive @test(arg: String) on OBJECT");
DocumentNode schema_b =
Parser.Default.Parse("directive @test(arg: String) on OBJECT");
var types = new List <IDirectiveTypeInfo>
{
new DirectiveTypeInfo(schema_a.Definitions.OfType <DirectiveDefinitionNode>().First(),
new SchemaInfo("Schema_A", schema_a)),
new DirectiveTypeInfo(schema_b.Definitions.OfType <DirectiveDefinitionNode>().First(),
new SchemaInfo("Schema_B", schema_b)),
};
var context = new SchemaMergeContext();
// act
var typeMerger = new DirectiveTypeMergeHandler((c, t) => { });
typeMerger.Merge(context, types);
// assert
SchemaSyntaxSerializer.Serialize(context.CreateSchema())
.MatchSnapshot();
}
public void AddSchemaFromFile()
{
// arrange
IHttpClientFactory clientFactory = CreateRemoteSchemas();
var builder = new MockStitchingBuilder();
// act
builder.AddSchemaFromFile("contract",
IOPath.Combine("__resources__", "Contract.graphql"))
.AddSchemaFromFile("customer",
IOPath.Combine("__resources__", "Customer.graphql"));
// assert
var services = new DictionaryServiceProvider(
typeof(IHttpClientFactory),
clientFactory);
var merger = new SchemaMerger();
foreach (KeyValuePair <NameString, LoadSchemaDocument> item in
builder.Schemas)
{
merger.AddSchema(item.Key, item.Value.Invoke(services));
}
SchemaSyntaxSerializer.Serialize(merger.Merge()).MatchSnapshot();
}
public void AddSchema()
{
// arrange
StitchingBuilder stitchingBuilder = StitchingBuilder.New();
DocumentNode schema_a = Parser.Default.Parse(
"type A { b: String }");
DocumentNode schema_b = Parser.Default.Parse(
"type B { c: String }");
// act
stitchingBuilder.AddSchema("a", s => schema_a)
.AddSchema("b", s => schema_b);
// assert
var services = new ServiceCollection();
stitchingBuilder.Populate(services);
DocumentNode schema = services.BuildServiceProvider()
.GetRequiredService <StitchingBuilder.StitchingFactory>()
.MergedSchema;
SchemaSyntaxSerializer.Serialize(schema).MatchSnapshot();
}
public void Merge_SimpleIdenticalInterfaces_TypeMerges()
{
// arrange
DocumentNode schema_a =
Utf8GraphQLParser.Parse("interface A { b: String }");
DocumentNode schema_b =
Utf8GraphQLParser.Parse("interface A { b: String }");
var types = new List <ITypeInfo>
{
TypeInfo.Create(
schema_a.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_A", schema_a)),
TypeInfo.Create(
schema_b.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_B", schema_b))
};
var context = new SchemaMergeContext();
// act
var typeMerger = new InterfaceTypeMergeHandler((c, t) => { });
typeMerger.Merge(context, types);
// assert
SchemaSyntaxSerializer.Serialize(context.CreateSchema())
.MatchSnapshot();
}
public void AddSchema_2()
{
// arrange
Schema customerSchema = Schema.Create(
CustomerSchemaFactory.ConfigureSchema);
Schema contractSchema = Schema.Create(
ContractSchemaFactory.ConfigureSchema);
var builder = new MockStitchingBuilder();
// act
builder.AddSchema("customer", customerSchema)
.AddSchema("contract", contractSchema);
// assert
var services = new EmptyServiceProvider();
var merger = new SchemaMerger();
foreach (KeyValuePair <NameString, ExecutorFactory> item in
builder.Executors)
{
ISchema schema = item.Value.Invoke(services).Schema;
merger.AddSchema(item.Key,
SchemaSerializer.SerializeSchema(schema));
}
SchemaSyntaxSerializer.Serialize(merger.Merge()).MatchSnapshot();
}
public void Merge_RootTypeWithCollisions_CollidingFieldsAreRenamed()
{
// arrange
DocumentNode schema_a =
Utf8GraphQLParser.Parse("type Query { a: String }");
DocumentNode schema_b =
Utf8GraphQLParser.Parse("type Query { a: String }");
var types = new List <ITypeInfo>
{
TypeInfo.Create(
schema_a.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_A", schema_a)),
TypeInfo.Create(
schema_b.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_B", schema_b))
};
var context = new SchemaMergeContext();
// act
var typeMerger = new RootTypeMergeHandler((c, t) => { });
typeMerger.Merge(context, types);
// assert
SchemaSyntaxSerializer.Serialize(context.CreateSchema())
.MatchSnapshot();
}
public void MergeTypeWithCustomRule()
{
// arrange
DocumentNode schema_a =
Utf8GraphQLParser.Parse("type Foo { a: String }");
DocumentNode schema_b =
Utf8GraphQLParser.Parse("type Foo { b: String }");
// act
DocumentNode a = SchemaMerger.New()
.AddSchema("A", schema_a)
.AddSchema("B", schema_b)
.AddTypeMergeRule(next => (context, types) =>
{
var typeInfos = types.OfType <ObjectTypeInfo>().ToArray();
var fields = typeInfos[0].Definition.Fields.ToList();
fields.AddRange(typeInfos[1].Definition.Fields);
context.AddType(
typeInfos[0].Definition.WithFields(fields));
})
.Merge();
// assert
SchemaSyntaxSerializer.Serialize(a).MatchSnapshot();
}
private async Task <bool> DownloadSchemaAsync(InitCommandContext context)
{
using var activity = Output.WriteActivity("Download schema");
try
{
HttpClient client = HttpClientFactory.Create(
context.Uri, context.Token, context.Scheme);
DocumentNode schema = await IntrospectionClient.LoadSchemaAsync(client);
schema = IntrospectionClient.RemoveBuiltInTypes(schema);
string schemaFilePath = FileSystem.CombinePath(
context.Path, context.SchemaFileName);
await FileSystem.WriteToAsync(schemaFilePath, stream =>
Task.Run(() => SchemaSyntaxSerializer.Serialize(
schema, stream, true)));
return(true);
}
catch (HttpRequestException ex)
{
activity.WriteError(
HCErrorBuilder.New()
.SetMessage(ex.Message)
.SetCode("HTTP_ERROR")
.Build());
return(false);
}
}
public void MergeUnionTypes()
{
// arrange
DocumentNode schema_a =
Parser.Default.Parse("union Foo = Bar | Baz");
DocumentNode schema_b =
Parser.Default.Parse("union Foo = Bar | Baz");
var types = new List <ITypeInfo>
{
TypeInfo.Create(
schema_a.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_A", schema_a)),
TypeInfo.Create(
schema_b.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_B", schema_b))
};
var context = new SchemaMergeContext();
// act
var typeMerger = new UnionTypeMergeHandler((c, t) => { });
typeMerger.Merge(context, types);
// assert
SchemaSyntaxSerializer.Serialize(context.CreateSchema())
.MatchSnapshot();
}
public void MergeNonIdenticalEnums()
{
// arrange
DocumentNode schema_a =
Utf8GraphQLParser.Parse("enum Foo { BAR BAZ }");
DocumentNode schema_b =
Utf8GraphQLParser.Parse("enum Foo { BAR BAZ }");
DocumentNode schema_c =
Utf8GraphQLParser.Parse("enum Foo { BAR BAZ QUX }");
var types = new List <ITypeInfo>
{
TypeInfo.Create(
schema_a.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_A", schema_a)),
TypeInfo.Create(
schema_b.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_B", schema_b)),
TypeInfo.Create(
schema_c.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_C", schema_c))
};
var context = new SchemaMergeContext();
// act
var typeMerger = new EnumTypeMergeHandler((c, t) => { });
typeMerger.Merge(context, types);
// assert
SchemaSyntaxSerializer.Serialize(context.CreateSchema())
.MatchSnapshot();
}
public void Merge_ThreeObjectsWhereTwoAreIdentical_TwoTypesAfterMerge()
{
// arrange
DocumentNode schema_a =
Parser.Default.Parse("type A { b: String }");
DocumentNode schema_b =
Parser.Default.Parse("type A { b(a: String): String }");
DocumentNode schema_c =
Parser.Default.Parse("type A { b: String }");
var types = new List <ITypeInfo>
{
TypeInfo.Create(
schema_a.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_A", schema_a)),
TypeInfo.Create(
schema_b.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_B", schema_b)),
TypeInfo.Create(
schema_c.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_C", schema_c))
};
var context = new SchemaMergeContext();
// act
var typeMerger = new ObjectTypeMergeHandler((c, t) => { });
typeMerger.Merge(context, types);
// assert
SchemaSyntaxSerializer.Serialize(context.CreateSchema())
.MatchSnapshot();
}
public void RenameReferencingType()
{
// arrange
DocumentNode schema_a =
Utf8GraphQLParser.Parse(
"type A { b1: B } " +
"type B implements C { c: String } " +
"interface C { c: String }");
DocumentNode schema_b =
Utf8GraphQLParser.Parse(
"type B { b1: String b3: String } type C { c: String }");
// act
DocumentNode a = SchemaMerger.New()
.AddSchema("A", schema_a)
.AddSchema("B", schema_b)
.RenameType("A", "B", "Foo")
.Merge();
DocumentNode b = SchemaMerger.New()
.AddSchema("B", schema_b)
.AddSchema("A", schema_a)
.RenameType("A", "B", "Foo")
.Merge();
// assert
SchemaSyntaxSerializer.Serialize(a).MatchSnapshot(
SnapshotNameExtension.Create("A"));
SchemaSyntaxSerializer.Serialize(b).MatchSnapshot(
SnapshotNameExtension.Create("B"));
}
public void Merge_ObjectWithDifferentInterfaces_TypesMerge()
{
// arrange
DocumentNode schema_a =
Parser.Default.Parse("type A implements IA { b: String }");
DocumentNode schema_b =
Parser.Default.Parse("type A implements IB { b : String }");
DocumentNode schema_c =
Parser.Default.Parse("type A implements IC { b: String }");
var types = new List <ITypeInfo>
{
TypeInfo.Create(
schema_a.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_A", schema_a)),
TypeInfo.Create(
schema_b.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_B", schema_b)),
TypeInfo.Create(
schema_c.Definitions.OfType <ITypeDefinitionNode>().First(),
new SchemaInfo("Schema_C", schema_c))
};
var context = new SchemaMergeContext();
// act
var typeMerger = new ObjectTypeMergeHandler((c, t) => { });
typeMerger.Merge(context, types);
// assert
SchemaSyntaxSerializer.Serialize(context.CreateSchema())
.MatchSnapshot();
}
public void DeserializeStarWarsIntrospectionResult()
{
// arrange
string json = FileResource.Open("StarWarsIntrospectionResult.json");
// act
DocumentNode schema = IntrospectionDeserializer.Deserialize(json);
// assert
SchemaSyntaxSerializer.Serialize(schema).MatchSnapshot();
}
public void DeserializeIntrospectionWithIntDefaultValues()
{
// arrange
string json = FileResource.Open("IntrospectionWithDefaultValues.json");
// act
DocumentNode schema = IntrospectionDeserializer.Deserialize(json);
// assert
SchemaSyntaxSerializer.Serialize(schema).MatchSnapshot();
}
public async Task Download_Schema_AST()
{
// arrange
TestServer server = CreateStarWarsServer();
var introspectionClient = new IntrospectionClient();
// act
DocumentNode schema =
await introspectionClient.DownloadSchemaAsync(
server.CreateClient());
// assert
SchemaSyntaxSerializer.Serialize(schema, true).MatchSnapshot();
}
public void DeserializeIntrospectionWithIntDefaultValues()
{
// arrange
string json = FileResource.Open("IntrospectionWithDefaultValues.json");
IntrospectionResult result = JsonSerializer.Deserialize <IntrospectionResult>(
json,
IntrospectionClient.SerializerOptions);
// act
DocumentNode schema = IntrospectionDeserializer.Deserialize(result);
// assert
SchemaSyntaxSerializer.Serialize(schema).MatchSnapshot();
}
public void InterfaceType_AddScalarField()
{
// arrange
const string schema = "interface Foo { bar: String }";
const string extensions = "extend interface Foo { baz: Int }";
// act
var rewriter = new AddSchemaExtensionRewriter();
DocumentNode merged = rewriter.AddExtensions(
Parser.Default.Parse(schema),
Parser.Default.Parse(extensions));
// assert
SchemaSyntaxSerializer.Serialize(merged).MatchSnapshot();
}
public void EnumType_AddValue()
{
// arrange
const string schema = "enum Foo { BAR BAZ }";
const string extensions = "extend enum Foo { QUX }";
// act
var rewriter = new AddSchemaExtensionRewriter();
DocumentNode merged = rewriter.AddExtensions(
Parser.Default.Parse(schema),
Parser.Default.Parse(extensions));
// assert
SchemaSyntaxSerializer.Serialize(merged).MatchSnapshot();
}
public void ObjectType_AddScalarField()
{
// arrange
const string schema = "type Foo { bar: String }";
const string extensions = "extend type Foo { baz: Int }";
// act
var rewriter = new AddSchemaExtensionRewriter();
DocumentNode merged = rewriter.AddExtensions(
Utf8GraphQLParser.Parse(schema),
Utf8GraphQLParser.Parse(extensions));
// assert
SchemaSyntaxSerializer.Serialize(merged).MatchSnapshot();
}
public void ObjectType_AddDirectives()
{
// arrange
const string schema = "type Foo { bar: String } " +
"directive @foo on OBJECT";
const string extensions = "extend type Foo @foo";
// act
var rewriter = new AddSchemaExtensionRewriter();
DocumentNode merged = rewriter.AddExtensions(
Parser.Default.Parse(schema),
Parser.Default.Parse(extensions));
// assert
SchemaSyntaxSerializer.Serialize(merged).MatchSnapshot();
}
public void InputObjectType_AddDirectives()
{
// arrange
const string schema = "input Foo { bar: String } " +
"directive @foo on INPUT_OBJECT";
const string extensions = "extend input Foo @foo";
// act
var rewriter = new AddSchemaExtensionRewriter();
DocumentNode merged = rewriter.AddExtensions(
Utf8GraphQLParser.Parse(schema),
Utf8GraphQLParser.Parse(extensions));
// assert
SchemaSyntaxSerializer.Serialize(merged).MatchSnapshot();
}
public void EnumType_AddDirectives()
{
// arrange
const string schema = "enum Foo { BAR BAZ } " +
"directive @foo on ENUM";
const string extensions = "extend enum Foo @foo";
// act
var rewriter = new AddSchemaExtensionRewriter();
DocumentNode merged = rewriter.AddExtensions(
Utf8GraphQLParser.Parse(schema),
Utf8GraphQLParser.Parse(extensions));
// assert
SchemaSyntaxSerializer.Serialize(merged).MatchSnapshot();
}
public void MergeSimpleSchemaWithDefaultHandler()
{
// arrange
DocumentNode schema_a =
Utf8GraphQLParser.Parse("union Foo = Bar | Baz union A = B | C");
DocumentNode schema_b =
Utf8GraphQLParser.Parse("union Foo = Bar | Baz");
// act
DocumentNode schema = SchemaMerger.New()
.AddSchema("A", schema_a)
.AddSchema("B", schema_b)
.Merge();
// assert
SchemaSyntaxSerializer.Serialize(schema).MatchSnapshot();
}
private async Task UpdateSchemaAsync(string path, SchemaFile schemaFile)
{
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri(schemaFile.Url);
if (Token != null)
{
httpClient.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue(
Scheme ?? "bearer", Token);
}
var stopwatch = Stopwatch.StartNew();
Console.WriteLine("Download schema started.");
DocumentNode schema = await IntrospectionClient.LoadSchemaAsync(httpClient);
schema = IntrospectionClient.RemoveBuiltInTypes(schema);
Console.WriteLine(
"Download schema completed in " +
$"{stopwatch.ElapsedMilliseconds} ms for {path}.");
stopwatch.Restart();
Console.WriteLine("Client configuration started.");
string fileName = IOPath.Combine(path, schemaFile.Name + ".graphql");
if (File.Exists(fileName))
{
File.Delete(fileName);
}
using (var stream = File.Create(fileName))
{
using (var sw = new StreamWriter(stream))
{
SchemaSyntaxSerializer.Serialize(schema, sw, true);
}
}
Console.WriteLine(
"Client configuration completed in " +
$"{stopwatch.ElapsedMilliseconds} ms for {path}.");
}
public void UnionType_AddDirectives()
{
// arrange
const string schema = "union Foo = A | B "
+ "type A { a: String } "
+ "type B { b: String } "
+ "directive @foo on INTERFACE";
const string extensions = "extend union Foo @foo";
// act
var rewriter = new AddSchemaExtensionRewriter();
DocumentNode merged = rewriter.AddExtensions(
Parser.Default.Parse(schema),
Parser.Default.Parse(extensions));
// assert
SchemaSyntaxSerializer.Serialize(merged).MatchSnapshot();
}
public void MergeTypeWithCustomHandler()
{
// arrange
DocumentNode schema_a =
Utf8GraphQLParser.Parse("type Foo { a: String }");
DocumentNode schema_b =
Utf8GraphQLParser.Parse("type Foo { b: String }");
// act
DocumentNode a = SchemaMerger.New()
.AddSchema("A", schema_a)
.AddSchema("B", schema_b)
.AddTypeMergeHandler <CustomTypeMergeHandler>()
.Merge();
// assert
SchemaSyntaxSerializer.Serialize(a).MatchSnapshot();
}
public void MergeDirectivesWithCustomHandler()
{
// arrange
DocumentNode schema_a =
Utf8GraphQLParser.Parse("directive @foo on FIELD");
DocumentNode schema_b =
Utf8GraphQLParser.Parse("directive @foo(a: String) on FIELD");
// act
DocumentNode a = SchemaMerger.New()
.AddSchema("A", schema_a)
.AddSchema("B", schema_b)
.AddDirectiveMergeHandler <CustomDirectiveMergeHandler>()
.Merge();
// assert
SchemaSyntaxSerializer.Serialize(a).MatchSnapshot();
}
