public void ShouldSetTitle()
{
var generator = new SchemaGenerator <ISampleService>();
var schema = generator.Generate();
Assert.Equal(nameof(ISampleService), schema.Title);
}
/// <inheritdoc />
protected override void PostStart(IComponentContext componentContext)
{
base.PostStart(componentContext);
var contextManager = componentContext.Resolve <UniversalContextFactory>();
var config = componentContext.Resolve <Config>();
var connectionString = config.GetString(NodeManagerActor.ConfigConnectionStringPath);
var repository = componentContext.Resolve <IPackageRepository>();
var databaseName = config.GetString(NodeManagerActor.ConfigDatabaseNamePath);
using (var context =
contextManager.CreateContext <ConfigurationContext>("InMemory", connectionString, databaseName))
{
context.ResetValueGenerators();
context.Database.EnsureDeleted();
var seeder = new Seeder(config, contextManager, repository);
Serilog.Log.Information("!!!!!!!!!!! Seeding started");
seeder.Seed();
Serilog.Log.Information("!!!!!!!!!!! Seeding finished");
}
var schemaProvider = componentContext.Resolve <SchemaProvider>();
var apiProviders = componentContext.Resolve <IEnumerable <API.Provider.ApiProvider> >()
.Select(p => new DirectProvider(p, error => Serilog.Log.Error("API ERROR: {error}", error)))
.Cast <ApiProvider>()
.ToList();
schemaProvider.CurrentSchema = SchemaGenerator.Generate(apiProviders);
}
public void ShouldSetNameWhenAttribute()
{
var generator = new SchemaGenerator <ISampleService>();
var schema = generator.Generate();
Assert.Equal(typeof(ISampleService).GetTypeInfo().GetCustomAttribute <ServiceAttribute>().Name, schema.Name);
}
public void Trivial2Test()
{
var api = new ApiDescription
{
ApiName = "TestApi1",
TypeName = "TestApi1",
Version = new Version("0.0.0.1"),
};
var provider = new MoqProvider {
Description = api
};
var schema = SchemaGenerator.Generate(new List <ApiProvider> {
provider
});
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.NotNull(schema.Query);
Assert.Equal(3, schema.Query.Fields.Count());
Assert.True(schema.Query.HasField("api"));
}
static void Main(string[] args)
{
while (true)
{
var gen = new SchemaGenerator(new List <string> {
@"C:\Users\toshe\source\repos\Test\Test\bin\Test.dll"
});
var schema = gen.Generate(url: "http://*****:*****@"C:\Users\toshe\Desktop\Test.schema");
var endpoint = schema.Controllers[0].Endpoints[0];
System.Console.WriteLine(JsonConvert.SerializeObject(schema, Formatting.Indented));
System.Console.WriteLine("============================");
System.Console.WriteLine(schema.Do(endpoint));
System.Console.WriteLine("============================");
System.Console.WriteLine(Request.Do(schema, schema.Controllers[0].Endpoints[1], Input.Get(schema.Controllers[0].Endpoints[1].Input)));
System.Console.WriteLine("============================");
System.Console.WriteLine(schema.Do(schema.Controllers[0].Endpoints[2]));
System.Console.ReadKey();
}
}
public void ShouldSetNameWhenNotAttribute()
{
var generator = new SchemaGenerator <INoAttributeService>();
var schema = generator.Generate(new SchemaGenerationOptions
{
MemberNameToSchemaName = Extensions.ToDottedName
});
Assert.Equal(nameof(INoAttributeService).ToDottedName(true), schema.Name);
}
public void TrivialTest()
{
var schema = SchemaGenerator.Generate(new List <ApiProvider>());
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine(description);
Assert.False(string.IsNullOrEmpty(description));
}
}
public static int Run(string[] args)
{
var sw = Stopwatch.StartNew();
int loadResult = LoadOptions(args);
if (loadResult != 0)
{
return(loadResult);
}
_basePath = AbsolutePath(_options.Source);
AppDomain.CurrentDomain.AssemblyResolve += ResolveAssembly; // Look in the base path for referenced .dll files instead of the startup path
Console.Write("Scanning for DTO objects in {0}... ", _basePath);
var apiControllers = GetApiControllers(_basePath);
var controllerModels = new HashSet <Type>(apiControllers.SelectMany(GetModelsFromController)); // return and parameter models
var allModels = GetAllModelsToGenerate(controllerModels);
Console.WriteLine("Found {0}", allModels.Count);
var targetPath = AbsolutePath(_options.Destination);
Console.WriteLine("Generating to Target Path: " + targetPath);
// Invoke all generators and pass the results to the index generator
List <string> allGeneratedNames;
if (_options.Generator == "react")
{
allGeneratedNames = IndexGenerator.Generate(targetPath,
InterfaceGenerator.Generate(targetPath, allModels, _options),
PromiseDataServiceGenerator.Generate(apiControllers, controllerModels, targetPath, _options)
).Select(n => n + ".ts").ToList();
}
else
{
allGeneratedNames = IndexGenerator.Generate(targetPath,
EntityGenerator.Generate(targetPath, allModels, _options),
DataServiceGenerator.Generate(apiControllers, controllerModels, targetPath, _options)
).Select(n => n + ".ts").ToList();
}
allGeneratedNames.AddRange(SchemaGenerator.Generate(targetPath, allModels, _options));
RemoveNonGeneratedFiles(targetPath, allGeneratedNames);
Console.WriteLine("Done in {0:N3}s", sw.Elapsed.TotalSeconds);
return(0);
}
public async Task EnumApiTest()
{
var enumType = new ApiEnumType("EnumType", new[] { "item1", "item2" });
var api = new ApiDescription(
"TestApi1",
"0.0.0.1",
new ApiType[] { enumType },
new[] { ApiField.Object("enumField", enumType.TypeName) });
var provider = new MoqProvider {
Description = api, Data = "{\"enumField\": \"item2\"}"
};
var schema = SchemaGenerator.Generate(new List <ApiProvider> {
provider
});
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine("-------- Schema -----------");
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.NotNull(schema.Query);
Assert.Equal(3, schema.Query.Fields.Count());
Assert.True(schema.Query.HasField("api"));
var result = await new DocumentExecuter().ExecuteAsync(
r =>
{
r.Schema = schema;
r.Query = "query { api { enumField } } ";
}).ConfigureAwait(true);
this.output.WriteLine("-------- Response -----------");
var response = new DocumentWriter(true).Write(result);
this.output.WriteLine(response);
var expectedResponse = @"{
""data"": {
""api"": {
""enumField"": ""item2""
}
}
}";
Assert.Equal(CleanResponse(expectedResponse), CleanResponse(response));
}
static void Main(string[] args)
{
var schema = new ServiceSchema
{
Title = "Test",
Name = "test",
Version = Version.Parse("1.0")
};
schema.Endpoints.Add("event1", new EventEndpointSchema
{
Title = "Event1",
Event = new ObjectTypeSchema
{
}
});
schema.Endpoints.Add("cmd1", new CommandEndpointSchema
{
Title = "Command1"
});
schema.Endpoints.Add("call1", new CallableEndpointSchema()
{
Title = "Call1"
});
var json = schema.ToString();
var obj = ServiceSchema.FromString(json);
var generator = new SchemaGenerator <ISampleService>();
schema = generator.Generate(new SchemaGenerationOptions(new RabbitSchemaGenerator()));
json = schema.ToString();
schema.ToFile("sample.json");
schema = ServiceSchema.FromString(json);
var csgenerator = new CSharpCodeGenerator(schema, new CSharpCodeGenerationOptions("Test")
{
ExcludedTypes = new[] { "SampleCommand" },
Endpoints = new[] { "AwesomeEvent" }.Include(),
GeneratedProperties = new Dictionary <string, SkipInclude>
{
{ "SampleEvent", new [] { "Order" }.Skip() }
}
}, new RabbitCSharpGenerator());
var csharp = csgenerator.GenerateContracts();
//File.WriteAllText("sample.cs", csharp);
var cintf = csgenerator.GenerateInterface();
File.WriteAllText("sample.cs", csharp + "\n" + cintf);
Console.ReadKey();
}
public void ApiGenerationTest()
{
var system = ActorSystem.Create("test");
var api = new ApiProvider(system, new TestRepository());
foreach (var error in api.GenerationErrors)
{
this.output.WriteLine($"Error: {error}");
}
Assert.Equal(0, api.GenerationErrors.Count);
var webApiProvider = new DirectProvider(api, this.output.WriteLine)
{
UseJsonRepack = true
};
var schema = SchemaGenerator.Generate(new List <Web.GraphQL.Publisher.ApiProvider> {
webApiProvider
});
var hasSchemaErrors = false;
foreach (var error in SchemaGenerator.CheckSchema(schema))
{
hasSchemaErrors = true;
this.output.WriteLine($"Schema error: {error}");
}
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine("-------- Schema -----------");
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.False(hasSchemaErrors);
hasSchemaErrors = false;
foreach (var error in SchemaGenerator.CheckSchemaIntrospection(schema))
{
hasSchemaErrors = true;
this.output.WriteLine($"Schema introspection error: {error}");
}
Assert.False(hasSchemaErrors);
}
public async Task EmptyVariablesTest(string variables)
{
this.ExpectNoMsg();
var internalApiProvider = new TestProvider();
var publishingProvider = new DirectProvider(internalApiProvider, this.output.WriteLine)
{
UseJsonRepack = true
};
var schemaProvider = this.Container.Resolve <SchemaProvider>();
schemaProvider.CurrentSchema = SchemaGenerator.Generate(new List <ApiProvider> {
publishingProvider
});
var client = new RestClient($"http://*****:*****@"
{
api {
syncScalarField
}
}";
var body = $"{{\"query\": {JsonConvert.SerializeObject(query)}, \"variables\": {variables}}}";
request.AddParameter("application/json", body, ParameterType.RequestBody);
var result = await client.ExecuteTaskAsync(request);
Assert.Equal(ResponseStatus.Completed, result.ResponseStatus);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
this.Sys.Log.Info("Response {Response}", result.Content);
}
public async Task SchemaDescriptionTest()
{
var checkAttributeArguments = new[]
{
ApiField.Scalar(
"attribute",
EnScalarType.String,
description: "attribute to check")
};
var objectFields = new[]
{
ApiField.Scalar(
"uid",
EnScalarType.Guid,
description: "The object unique identifier"),
ApiField.Scalar("name", EnScalarType.String, description: "The object name"),
ApiField.Scalar(
"attributes",
EnScalarType.String,
EnFieldFlags.IsArray,
description: "The object attributes"),
ApiField.Scalar(
"checkAttribute",
EnScalarType.Boolean,
arguments: checkAttributeArguments,
description: "checks the attribute")
};
var objectType = new ApiObjectType("object", objectFields)
{
Description = "Some abstract object"
};
var apiField = objectType.CreateField(
"new",
description: "The new object data");
var mutations = new[]
{
ApiMutation.CreateFromField(
ApiField.Object(
"objects_create",
"object",
arguments: new[] { apiField },
description: "creates a new object"),
ApiMutation.EnType.ConnectionCreate,
new List <ApiRequest>())
};
var api = new ApiDescription(
"TestApi",
"0.0.0.1",
new[] { objectType },
new[] { objectType.CreateField("objects", EnFieldFlags.IsConnection, "The objects dataset") },
mutations)
{
Description = "The test api"
};
var provider = new MoqProvider {
Description = api
};
var schema = SchemaGenerator.Generate(new List <ApiProvider> {
provider
});
var errors = SchemaGenerator.CheckSchema(schema).Select(e => $"Schema type error: {e}")
.Union(SchemaGenerator.CheckSchemaIntrospection(schema))
.Select(e => $"Schema introspection error: {e}");
var hasErrors = false;
foreach (var error in errors)
{
hasErrors = true;
this.output.WriteLine(error);
}
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine("-------- Schema -----------");
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.False(hasErrors);
var query = BaseInstaller.ReadTextResource(
this.GetType().GetTypeInfo().Assembly,
"KlusterKite.Web.Tests.GraphQL.Resources.IntrospectionQuery.txt");
var result = await new DocumentExecuter().ExecuteAsync(
r =>
{
r.Schema = schema;
r.Query = query;
}).ConfigureAwait(true);
var response = new DocumentWriter(true).Write(result);
this.output.WriteLine(response);
var expectedResponse = BaseInstaller.ReadTextResource(
this.GetType().GetTypeInfo().Assembly,
"KlusterKite.Web.Tests.GraphQL.Resources.SchemaDescriptionTestSnapshot.txt");
Assert.Equal(CleanResponse(expectedResponse), CleanResponse(response));
}
public void ShouldThrowWhenNoNameAttribute()
{
var generator = new SchemaGenerator <INoAttributeService>();
Assert.Throws <ServiceInterfaceException>(() => generator.Generate());
}
public async Task LoadTest()
{
this.ExpectNoMsg();
var initialObjects = new List <TestObject>
{
new TestObject
{
Id =
Guid.Parse(
"{3BEEE369-11DF-4A30-BF11-1D8465C87110}"),
Name = "1-test",
Value = 100m
},
new TestObject
{
Id =
Guid.Parse(
"{B500CA20-F649-4DCD-BDA8-1FA5031ECDD3}"),
Name = "2-test",
Value = 50m
},
new TestObject
{
Id =
Guid.Parse(
"{67885BA0-B284-438F-8393-EE9A9EB299D1}"),
Name = "3-test",
Value = 50m
},
new TestObject
{
Id =
Guid.Parse(
"{3AF2C973-D985-4F95-A0C7-AA928D276881}"),
Name = "4-test",
Value = 70m
},
new TestObject
{
Id =
Guid.Parse(
"{F0607502-5B77-4A3C-9142-E6197A7EE61E}"),
Name = "5-test",
Value = 6m
},
};
var internalApiProvider = new TestProvider(initialObjects);
var publishingProvider = new DirectProvider(internalApiProvider, this.output.WriteLine)
{
UseJsonRepack = true
};
var schemaProvider = this.Container.Resolve <SchemaProvider>();
schemaProvider.CurrentSchema = SchemaGenerator.Generate(new List <ApiProvider> {
publishingProvider
});
var client = new RestClient($"http://*****:*****@"
{
api {
asyncArrayOfScalarField,
asyncForwardedScalar,
nestedAsync {
asyncScalarField,
syncScalarField
},
asyncScalarField,
forwardedArray,
syncArrayOfScalarField,
nestedSync {
asyncScalarField,
syncScalarField
},
syncScalarField,
syncEnumField,
syncFlagsField,
connection(sort: [value_asc, name_asc], filter: {value_gt: 10}, offset: 1, limit: 2) {
count,
edges {
cursor,
node {
id,
__id,
name,
value
}
}
}
}
}
";
var stopwatch = new Stopwatch();
var request = new RestRequest {
Method = Method.POST
};
request.AddHeader("Accept", "application/json, text/json");
var body = $"{{\"query\": {JsonConvert.SerializeObject(query)}, \"variables\": null}}";
request.AddParameter("application/json", body, ParameterType.RequestBody);
stopwatch.Start();
var result = client.ExecuteTaskAsync(request).Result;
stopwatch.Stop();
Assert.Equal(ResponseStatus.Completed, result.ResponseStatus);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
this.Sys.Log.Info("!!!!!!!!!! First request served in {StopWatch}ms", (double)stopwatch.ElapsedTicks * 1000 / Stopwatch.Frequency);
stopwatch.Reset();
stopwatch.Start();
client.ExecuteTaskAsync(request).Wait();
stopwatch.Stop();
this.Sys.Log.Info("!!!!!!!!!! Second request served in {StopWatch}ms", (double)stopwatch.ElapsedTicks * 1000 / Stopwatch.Frequency);
stopwatch.Reset();
stopwatch.Start();
var numberOfRequests = 3000;
await Task.WhenAll(Enumerable.Range(1, numberOfRequests).Select(i => client.ExecuteTaskAsync(request)));
stopwatch.Stop();
this.Sys.Log.Info(
"!!!!!!!!!! Served {numberOfRequests} requests in {StopWatch}ms ({StopWatchRequest}ms/req)",
numberOfRequests,
(double)stopwatch.ElapsedTicks * 1000 / Stopwatch.Frequency,
(double)stopwatch.ElapsedTicks * 1000 / numberOfRequests / Stopwatch.Frequency);
this.Sys.Log.Info("Response {Response}", result.Content);
}
public async Task SchemaInitializedTest()
{
this.ExpectNoMsg();
var internalApiProvider = new TestProvider();
var publishingProvider = new DirectProvider(internalApiProvider, this.output.WriteLine)
{
UseJsonRepack = true
};
var schemaProvider = this.Container.Resolve <SchemaProvider>();
schemaProvider.CurrentSchema = SchemaGenerator.Generate(new List <ApiProvider> {
publishingProvider
});
var client = new RestClient($"http://*****:*****@"
{
api {
asyncArrayOfScalarField,
asyncForwardedScalar,
nestedAsync {
asyncScalarField,
syncScalarField
},
asyncScalarField,
faultedSyncField,
forwardedArray,
syncArrayOfScalarField,
nestedSync {
asyncScalarField,
syncScalarField
},
syncScalarField,
faultedASyncMethod {
asyncScalarField,
syncScalarField
}
}
}";
request.AddJsonBody(new EndpointController.QueryRequest {
Query = query
});
var result = await client.ExecuteTaskAsync(request);
this.Sys.Log.Info("Response {Response}", result.Content);
Assert.Equal(ResponseStatus.Completed, result.ResponseStatus);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
var expectedResult = @"
{
""data"": {
""api"": {
""asyncArrayOfScalarField"": [
4.0,
5.0
],
""asyncForwardedScalar"": ""AsyncForwardedScalar"",
""nestedAsync"": {
""asyncScalarField"": ""AsyncScalarField"",
""syncScalarField"": ""SyncScalarField""
},
""asyncScalarField"": ""AsyncScalarField"",
""faultedSyncField"": null,
""forwardedArray"": [
5,
6,
7
],
""syncArrayOfScalarField"": [
1,
2,
3
],
""nestedSync"": {
""asyncScalarField"": ""AsyncScalarField"",
""syncScalarField"": ""SyncScalarField""
},
""syncScalarField"": ""SyncScalarField"",
""faultedASyncMethod"": null
}
}
}
";
Assert.Equal(
ApiProviderPublishResolveIntegration.CleanResponse(expectedResult),
ApiProviderPublishResolveIntegration.CleanResponse(result.Content));
}
public async Task NonEmptyApiTest()
{
var viewerType = new ApiObjectType(
"viewer",
new[] { ApiField.Scalar("id", EnScalarType.Integer), ApiField.Scalar("name", EnScalarType.String) });
var api = new ApiDescription(
"TestApi1",
"0.0.0.1",
new[] { viewerType },
new[] { viewerType.CreateField("viewer") });
var provider = new MoqProvider
{
Description = api,
Data = "{\"viewer\": {\"__id\": 1, \"name\": \"test name\"}}"
};
var schema = SchemaGenerator.Generate(new List <ApiProvider> {
provider
});
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine("-------- Schema -----------");
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.NotNull(schema.Query);
Assert.Equal(3, schema.Query.Fields.Count());
Assert.True(schema.Query.HasField("api"));
var result = await new DocumentExecuter().ExecuteAsync(
r =>
{
r.Schema = schema;
r.Query = @"
query {
api {
viewer {
__id,
name
}
}
}
";
}).ConfigureAwait(true);
this.output.WriteLine("-------- Response -----------");
var response = new DocumentWriter(true).Write(result);
this.output.WriteLine(response);
var expectedResponse = @"{
""data"": {
""api"": {
""viewer"": {
""__id"": 1,
""name"": ""test name""
}
}
}
}";
Assert.Equal(CleanResponse(expectedResponse), CleanResponse(response));
}
public async Task ArraysApiTest()
{
var viewerFields = new[]
{
ApiField.Scalar("id", EnScalarType.Guid, EnFieldFlags.Queryable | EnFieldFlags.IsKey),
ApiField.Scalar("name", EnScalarType.String),
ApiField.Scalar("numbers", EnScalarType.Integer, EnFieldFlags.IsArray | EnFieldFlags.Queryable)
};
var viewerType = new ApiObjectType("viewer", viewerFields);
var objectFields = new[]
{
ApiField.Scalar("id", EnScalarType.Integer, EnFieldFlags.IsKey | EnFieldFlags.Queryable),
ApiField.Scalar("name", EnScalarType.String)
};
var objectType = new ApiObjectType("object", objectFields);
var api = new ApiDescription(
"TestApi1",
"0.0.0.1",
new[] { viewerType, objectType },
new[] { viewerType.CreateField("viewer"), objectType.CreateField("object", EnFieldFlags.IsConnection | EnFieldFlags.Queryable) });
var provider = new MoqProvider
{
Description = api,
Data = @"{
""viewer"": {
""__id"": ""FD73BAFB-3698-4FA1-81F5-27C8C83BB4F0"",
""name"": ""test name"",
""numbers"": [1, 2, 3]
},
""object"": {
""count"": 2,
""edges"": [
{""__id"": 10, ""node___id"": 10},
{""__id"": 20, ""node___id"": 20}
]
}
}"
};
var schema = SchemaGenerator.Generate(new List <ApiProvider> {
provider
});
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine("-------- Schema -----------");
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.NotNull(schema.Query);
Assert.Equal(3, schema.Query.Fields.Count());
Assert.True(schema.Query.HasField("api"));
var result = await new DocumentExecuter().ExecuteAsync(
r =>
{
r.Schema = schema;
r.Query = @"
query {
api {
viewer {
__id,
name,
numbers
},
object {
count,
edges {
cursor,
node {
__id
}
}
}
}
}
";
}).ConfigureAwait(true);
this.output.WriteLine("-------- Response -----------");
var response = new DocumentWriter(true).Write(result);
this.output.WriteLine(response);
var expectedResponse = @"{
""data"": {
""api"": {
""viewer"": {
""__id"": ""fd73bafb-3698-4fa1-81f5-27c8c83bb4f0"",
""name"": ""test name"",
""numbers"": [1, 2, 3]
},
""object"": {
""count"": 2,
""edges"": [
{
""cursor"": 10,
""node"": {
""__id"": 10
}
},
{
""cursor"": 20,
""node"": {
""__id"": 20
}
}
]
}
}
}
}";
Assert.Equal(CleanResponse(expectedResponse), CleanResponse(response));
}
