public void AddSchemaFromString()
{
// arrange
var builder = new MockStitchingBuilder();
// act
builder.AddSchemaFromString("contract",
FileResource.Open("Contract.graphql"))
.AddSchemaFromString("customer",
FileResource.Open("Customer.graphql"));
// assert
var services = new EmptyServiceProvider();
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 LastFieldRenameWins()
{
// arrange
DocumentNode schema_a =
Utf8GraphQLParser.Parse(
"type A { b1: B } " +
"type B implements D { c: String } " +
"type C implements D { c: String } " +
"interface D { 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)
.RenameField("A", new FieldReference("B", "c"), "c123")
.RenameField("A", new FieldReference("C", "c"), "c456")
.RenameField("A", new FieldReference("D", "c"), "c789")
.Merge();
DocumentNode b = SchemaMerger.New()
.AddSchema("A", schema_a)
.AddSchema("B", schema_b)
.RenameField("A", new FieldReference("B", "c"), "c123")
.RenameField("A", new FieldReference("D", "c"), "c789")
.RenameField("A", new FieldReference("C", "c"), "c456")
.Merge();
// assert
SchemaSyntaxSerializer.Serialize(a).MatchSnapshot(
SnapshotNameExtension.Create("A"));
SchemaSyntaxSerializer.Serialize(b).MatchSnapshot(
SnapshotNameExtension.Create("B"));
}
public void Merge_DifferentTypes_InputMergesLeftoversArePassed()
{
// arrange
DocumentNode schema_a =
Parser.Default.Parse("input A { b: String }");
DocumentNode schema_b =
Parser.Default.Parse("enum A { B C }");
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();
var leftovers = new List<ITypeInfo>();
// act
var typeMerger = new InputObjectTypeMergeHandler(
(c, t) => leftovers.AddRange(t));
typeMerger.Merge(context, types);
// assert
Assert.Collection(leftovers,
t => Assert.IsType<EnumTypeInfo>(t));
Snapshot.Match(new List<object>
{
SchemaSyntaxSerializer.Serialize(context.CreateSchema()),
leftovers
});
}
public void Merge_ThreeDirectivessWhereTwoAreIdentical_TwoTypesAfterMerge()
{
// arrange
DocumentNode schema_a =
Utf8GraphQLParser.Parse(
"directive @test(arg: String) on OBJECT");
DocumentNode schema_b =
Utf8GraphQLParser.Parse(
"directive @test1(arg: String) on OBJECT");
DocumentNode schema_c =
Utf8GraphQLParser.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)),
new DirectiveTypeInfo(schema_c.Definitions
.OfType <DirectiveDefinitionNode>().First(),
new SchemaInfo("Schema_C", schema_c))
};
var context = new SchemaMergeContext();
// act
var typeMerger = new DirectiveTypeMergeHandler((c, t) => { });
typeMerger.Merge(context, types);
// assert
SchemaSyntaxSerializer.Serialize(context.CreateSchema())
.MatchSnapshot();
}
public void RenameObjectField()
{
// arrange
DocumentNode schema_a =
Utf8GraphQLParser.Parse(
"type A { b1: B } " +
"type B { c: String } " +
"type C implements D { c: String } " +
"interface D { 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)
.RenameField("A", new FieldReference("B", "c"), "c123")
.Merge();
// assert
SchemaSyntaxSerializer.Serialize(a).MatchSnapshot();
}
public async Task DownloadSchemaAsync(
HttpClient client,
Stream stream,
CancellationToken cancellationToken = default)
{
if (client is null)
{
throw new ArgumentNullException(nameof(client));
}
if (stream is null)
{
throw new ArgumentNullException(nameof(stream));
}
DocumentNode document = await DownloadSchemaAsync(
client, cancellationToken)
.ConfigureAwait(false);
await Task.Run(
() => SchemaSyntaxSerializer.Serialize(document, stream, true),
cancellationToken)
.ConfigureAwait(false);
}
public void AddSchemaFromHttp()
{
// arrange
IHttpClientFactory clientFactory = CreateRemoteSchemas();
var builder = new MockStitchingBuilder();
// act
builder.AddSchemaFromHttp("customer")
.AddSchemaFromHttp("contract");
// 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 async Task <int> OnExecute()
{
if (Path is null)
{
throw new InvalidOperationException("Path mustn't not be null.");
}
if (Url is null)
{
throw new InvalidOperationException("Url mustn't not be null.");
}
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri(Url);
httpClient.DefaultRequestHeaders.UserAgent.Add(
new ProductInfoHeaderValue(
new ProductHeaderValue(
"StrawberryShake",
GetType() !.Assembly !.GetName() !.Version !.ToString())));
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.");
stopwatch.Restart();
Console.WriteLine("Client configuration started.");
if (!Directory.Exists(Path))
{
Directory.CreateDirectory(Path);
}
SchemaName = (SchemaName ?? "schema").Trim();
string schemaFielName = SchemaName + ".graphql";
var configuration = new Configuration();
configuration.ClientName = SchemaName + "Client";
configuration.Schemas = new List <SchemaFile>();
configuration.Schemas.Add(new SchemaFile
{
Type = "http",
Name = SchemaName,
File = schemaFielName,
Url = Url
});
using (var stream = File.Create(IOPath.Combine(Path, WellKnownFiles.Config)))
{
await JsonSerializer.SerializeAsync(stream, configuration);
}
using (var stream = File.Create(IOPath.Combine(Path, schemaFielName)))
{
using (var sw = new StreamWriter(stream))
{
SchemaSyntaxSerializer.Serialize(schema, sw, true);
}
}
Console.WriteLine(
"Client configuration completed in " +
$"{stopwatch.ElapsedMilliseconds} ms for {Path}.");
return(0);
}
public async Task <int> OnExecute()
{
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri(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.");
stopwatch.Restart();
Console.WriteLine("Client configuration started.");
if (!Directory.Exists(Path))
{
Directory.CreateDirectory(Path);
}
SchemaName = SchemaName ?? "schema";
string schemaFielName = SchemaName + ".graphql";
var configuration = new Configuration();
configuration.ClientName = SchemaName + "Client";
configuration.Schemas = new List <SchemaFile>();
configuration.Schemas.Add(new SchemaFile
{
Type = "http",
Name = SchemaName,
File = schemaFielName,
Url = Url
});
using (var stream = File.Create(IOPath.Combine(Path, "config.json")))
{
await JsonSerializer.SerializeAsync(stream, configuration);
}
using (var stream = File.Create(IOPath.Combine(Path, schemaFielName)))
{
using (var sw = new StreamWriter(stream))
{
SchemaSyntaxSerializer.Serialize(schema, sw, true);
}
}
Console.WriteLine(
"Client configuration completed in " +
$"{stopwatch.ElapsedMilliseconds} ms for {Path}.");
return(0);
}
