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