protected async Task <IBatchQueryResult> ExecuteBatchAsync(
HttpContext context,
IRequestExecutor requestExecutor,
IHttpRequestInterceptor requestInterceptor,
IReadOnlyList <GraphQLRequest> requests)
{
var requestBatch = new IReadOnlyQueryRequest[requests.Count];
for (var i = 0; i < requests.Count; i++)
{
QueryRequestBuilder requestBuilder = QueryRequestBuilder.From(requests[i]);
await requestInterceptor.OnCreateAsync(
context, requestExecutor, requestBuilder, context.RequestAborted);
requestBatch[i] = requestBuilder.Create();
}
return(await requestExecutor.ExecuteBatchAsync(
requestBatch, cancellationToken : context.RequestAborted));
}
public async Task Create_Boolean_OrderBy_Nullable()
{
// arrange
IRequestExecutor tester = _cache.CreateSchema <FooNullable, FooNullableSortType>(
_fooNullableEntities);
// act
IExecutionResult res1 = await tester.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery("{ rootExecutable(order: { bar: ASC}){ bar}}")
.Create());
IExecutionResult res2 = await tester.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery("{ rootExecutable(order: { bar: DESC}){ bar}}")
.Create());
// assert
res1.MatchSnapshot("ASC");
res2.MatchSnapshot("DESC");
}
public async Task Create_BooleanNotEqual_Expression()
{
// arrange
IRequestExecutor?tester = _cache.CreateSchema <Foo, FooFilterInput>(_fooEntities);
// act
// assert
IExecutionResult?res1 = await tester.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery("{ root(where: { bar: { neq: true}}){ bar}}")
.Create());
res1.MatchSnapshot("true");
IExecutionResult?res2 = await tester.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery("{ root(where: { bar: { neq: false}}){ bar}}")
.Create());
res2.MatchSnapshot("false");
}
public async Task GetItems_DescSorting_AllItems_Are_Returned_DescSorted()
{
// arrange
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(sp =>
{
IMongoDatabase database = _mongoResource.CreateDatabase();
IMongoCollection <Model> collection = database.GetCollection <Model>("col");
collection.InsertMany(new[]
{
new Model {
Foo = "abc", Bar = 1, Baz = true
},
new Model {
Foo = "def", Bar = 2, Baz = false
},
});
return(collection);
});
ISchema schema = SchemaBuilder.New()
.AddQueryType <QueryType>()
.AddServices(serviceCollection.BuildServiceProvider())
.Create();
IQueryExecutor executor = schema.MakeExecutable();
IReadOnlyQueryRequest request = QueryRequestBuilder.New()
.SetQuery("{ items(order_by: { foo: DESC }) { foo } }")
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
// assert
Assert.Empty(result.Errors);
result.MatchSnapshot();
}
public async Task Custom_Scalar_Delegated_Input_Argument()
{
// arrange
IHttpClientFactory clientFactory = CreateRemoteSchemas();
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(clientFactory);
serviceCollection.AddStitchedSchema(builder => builder
.AddSchemaFromHttp("special")
.AddExtensionsFromString("extend type Query { custom_scalar_complex_stitched(bar: CustomInputValueInput): MyCustomScalarValue @delegate(schema: \"special\", path: \"custom_scalar_complex(bar: $arguments:bar)\") }")
.AddSchemaConfiguration(c => {
c.RegisterType <MyCustomScalarType>();
}));
IServiceProvider services =
serviceCollection.BuildServiceProvider();
IQueryExecutor executor = services
.GetRequiredService <IQueryExecutor>();
IExecutionResult result = null;
// act
using (IServiceScope scope = services.CreateScope())
{
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery("query ($bar: CustomInputValueInput) { custom_scalar_complex_stitched(bar: $bar) }")
.SetVariableValue("bar", new Dictionary <string, object> {
{ "from", "2019-11-11" }, { "to", "2019-11-17" }
})
.SetServices(scope.ServiceProvider)
.Create();
result = await executor.ExecuteAsync(request);
}
// assert
result.MatchSnapshot();
}
public void TestSchema()
{
IRequestExecutor executor = MakeExecutor();
IServiceProvider serviceProvider = BuildServiceProvider();
IReadOnlyQueryRequest request = QueryRequestBuilder.New()
.SetQuery(@"{
projects {
id
evaluations {
id
participants {
id
}
questions {
id
answers {
id
}
actions {
id
notes {
id
}
}
}
}
}
}")
.SetServices(serviceProvider)
.Create();
IExecutionResult result = executor.Execute(request);
IReadOnlyList <IError> errors = result.Errors ?? new List <IError>();
foreach (IError err in errors)
{
throw err.Exception;
}
}
public async Task DateTimeType_GreaterThan_Filter()
{
// arrange
var serviceCollection = new ServiceCollection();
IServiceProvider services = new ServiceCollection()
.AddSingleton <IMongoCollection <Model> >(sp =>
{
IMongoDatabase database = _mongoResource.CreateDatabase();
IMongoCollection <Model> collection = database.GetCollection <Model>("col");
collection.InsertMany(new[]
{
new Model {
Time = new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc)
},
new Model {
Time = new DateTime(2016, 1, 1, 1, 1, 1, DateTimeKind.Utc)
},
});
return(collection);
})
.AddGraphQL()
.AddQueryType <QueryType>()
.Services
.BuildServiceProvider();
IRequestExecutor executor =
await services.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync();
IReadOnlyQueryRequest request = QueryRequestBuilder.New()
.SetQuery("{ items(where: { time_gt: \"2001-01-01\" }) { time } }")
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
// assert
result.MatchSnapshot();
}
private IReadOnlyQueryRequest NormalizeRequest(
IReadOnlyQueryRequest originalRequest)
{
ImmutableDictionary <string, object> normalizedVariables =
ImmutableDictionary <string, object> .Empty;
OperationDefinitionNode operation = null;
foreach (KeyValuePair <string, object> variable in originalRequest.VariableValues)
{
if (variable.Value as IValueNode is null)
{
if (operation is null)
{
operation = ResolveOperationDefinition(
originalRequest.Query, originalRequest.OperationName);
}
IValueNode normalizedValue = RewriteVariable(
operation, variable.Key, variable.Value);
normalizedVariables =
normalizedVariables.SetItem(variable.Key, normalizedValue);
}
}
if (normalizedVariables.Count > 0)
{
QueryRequestBuilder builder = QueryRequestBuilder.From(originalRequest);
foreach (KeyValuePair <string, object> normalized in normalizedVariables)
{
builder.SetVariableValue(normalized.Key, normalized.Value);
}
return(builder.Create());
}
return(originalRequest);
}
public async Task UseSchemaBuilder()
{
// arrange
IHttpClientFactory clientFactory = CreateRemoteSchemas();
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(clientFactory);
serviceCollection.AddStitchedSchema(builder =>
builder.AddSchemaFromHttp("contract")
.AddSchemaFromHttp("customer")
.AddSchemaConfiguration(c => c
.RegisterType <PaginationAmountType>()
.Extend().OnBeforeBuild(b => b.AddType(
new ObjectTypeExtension(d => d
.Name("Query")
.Field("foo")
.Type <StringType>()
.Resolver("bar"))))));
IServiceProvider services =
serviceCollection.BuildServiceProvider();
IQueryExecutor executor = services
.GetRequiredService <IQueryExecutor>();
IExecutionResult result = null;
// act
using (IServiceScope scope = services.CreateScope())
{
result = await executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery("{ foo }")
.SetServices(scope.ServiceProvider)
.Create());
}
// assert
Snapshot.Match(result);
}
public async Task ListVariableIsCorrectlyPassed()
{
// arrange
var serviceCollection = new ServiceCollection();
var connections = new Dictionary <string, HttpClient>();
serviceCollection.AddSingleton(CreateRemoteSchemas(connections));
serviceCollection.AddStitchedSchema(builder => builder
.AddSchemaFromHttp("contract")
.AddSchemaFromHttp("customer"));
IServiceProvider services =
serviceCollection.BuildServiceProvider();
IQueryExecutor executor = services
.GetRequiredService <IQueryExecutor>();
// act
IExecutionResult result = null;
using (IServiceScope scope = services.CreateScope())
{
IReadOnlyQueryRequest request = QueryRequestBuilder.New()
.SetQuery("query foo ($ids: [ID!]!) { customers(ids: $ids) { id } }")
.SetServices(scope.ServiceProvider)
.SetVariableValue("ids", new List <object> {
"Q3VzdG9tZXIteDE=", "Q3VzdG9tZXIteDE="
})
.Create();
result = await executor.ExecuteAsync(request);
}
// assert
result.MatchSnapshot(new SnapshotNameExtension("result"));
executor.Schema.ToString().MatchSnapshot(
new SnapshotNameExtension("schema"));
}
public async Task <IActionResult> ExecuteFunctionsQueryAsync(
HttpContext httpContext,
IDictionary <string, object> context,
CancellationToken cancellationToken)
{
using var stream = httpContext.Request.Body;
var requestQuery = await _requestParser
.ReadJsonRequestAsync(stream, cancellationToken)
.ConfigureAwait(false);
var builder = QueryRequestBuilder.New();
if (requestQuery.Count > 0)
{
var firstQuery = requestQuery[0];
builder
.SetQuery(firstQuery.Query)
.SetOperation(firstQuery.OperationName)
.SetQueryName(firstQuery.QueryName);
foreach (var item in context)
{
builder.AddProperty(item.Key, item.Value);
}
if (firstQuery.Variables != null &&
firstQuery.Variables.Count > 0)
{
builder.SetVariableValues(firstQuery.Variables);
}
}
var result = await Executor.ExecuteAsync(builder.Create());
await _jsonQueryResultSerializer.SerializeAsync((IReadOnlyQueryResult)result, httpContext.Response.Body);
return(new EmptyResult());
}
public async Task Boolean_Filter_Not_Equals()
{
// arrange
IServiceProvider services = new ServiceCollection()
.AddSingleton <IMongoCollection <Model> >(sp =>
{
IMongoDatabase database = _mongoResource.CreateDatabase();
IMongoCollection <Model> collection = database.GetCollection <Model>("col");
collection.InsertMany(new[]
{
new Model {
Foo = "abc", Bar = 1, Baz = true
},
new Model {
Foo = "def", Bar = 2, Baz = false
},
});
return(collection);
})
.AddGraphQL()
.AddQueryType <QueryType>()
.Services
.BuildServiceProvider();
IRequestExecutor executor =
await services.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync();
IReadOnlyQueryRequest request = QueryRequestBuilder.New()
.SetQuery("{ paging(where: { baz_not: false }) { nodes { foo } } }")
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
// assert
result.MatchSnapshot();
}
public async Task ExecuteExportScalar()
{
// arrange
Snapshot.FullName();
IRequestExecutor executor = await CreateExecutorAsync(c => c
.AddStarWarsTypes()
.AddExportDirectiveType()
.Services
.AddStarWarsRepositories());
// act
var batch = new List <IReadOnlyQueryRequest>
{
QueryRequestBuilder.New()
.SetQuery(
@"
query getHero {
hero(episode: EMPIRE) {
id @export
}
}")
.Create(),
QueryRequestBuilder.New()
.SetQuery(
@"
query getHuman {
human(id: $id) {
name
}
}")
.Create()
};
IBatchQueryResult batchResult = await executor.ExecuteBatchAsync(batch);
// assert
await batchResult.ToJsonAsync().MatchSnapshotAsync();
}
public async Task GetItems_NoSorting_AllItems_Are_Returned_Unsorted()
{
// arrange
IServiceProvider services = new ServiceCollection()
.AddSingleton <IMongoCollection <Model> >(sp =>
{
IMongoDatabase database = _mongoResource.CreateDatabase();
IMongoCollection <Model> collection = database.GetCollection <Model>("col");
collection.InsertMany(new[]
{
new Model {
Foo = "abc", Bar = 1, Baz = true
},
new Model {
Foo = "def", Bar = 2, Baz = false
},
});
return(collection);
})
.AddGraphQL()
.AddQueryType <QueryType>()
.Services
.BuildServiceProvider();
IRequestExecutor executor =
await services.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync();
IReadOnlyQueryRequest request = QueryRequestBuilder.New()
.SetQuery("{ items { foo } }")
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
// assert
Assert.Null(result.Errors);
result.MatchSnapshot();
}
public async Task Get_New_Basket_For_Owner()
{
var result = await ServiceProvider.ExecuteRequestAsync(
QueryRequestBuilder
.New()
.SetQuery(@"
query BasketByOwnerId($id: ID!) {
basketByOwnerId(id: $id) {
ownerId
basketType
items {
id
name
}
}
}
")
.SetVariableValue(name : "id", value : "600dca30-c6e2-4035-ad15-783c122d6ea6")
.Create());
result.MatchSnapshot();
}
public void AddAndUpdate()
{
// Setup
EnsureTestGraph();
Console.WriteLine(JsonConvert.SerializeObject(_trustBuilder.Package, Formatting.Indented));
// Test Add and schema validation
var result = (ObjectResult)_packageController.PostPackage(_trustBuilder.Package).GetAwaiter().GetResult();
Assert.IsNotNull(result);
//var httpResult = (HttpResult)result.Value;
//Assert.AreEqual(HttpResultStatusType.Success.ToString(), httpResult.Status, httpResult.Message + " : " + httpResult.Data);
var builder = new PackageBuilder();
builder.SetServer("testserver");
builder.AddClaim("A", "B", PackageBuilder.BINARY_CLAIM_DTP1, BinaryTrustFalseAttributes);
builder.Build().Sign();
result = (ObjectResult)_packageController.PostPackage(builder.Package).GetAwaiter().GetResult();
Assert.IsNotNull(result);
//httpResult = (HttpResult)result.Value;
//Assert.AreEqual(HttpResultStatusType.Success.ToString(), httpResult.Status, httpResult.Message + " : " + httpResult.Data);
// Test Graph
var queryBuilder = new QueryRequestBuilder(PackageBuilder.BINARY_CLAIM_DTP1);
BuildQuery(queryBuilder, "A", "B");
// Execute
var context = _graphQueryService.Execute(queryBuilder.Query);
var trust = context.Results.Claims[0];
VerfifyResult(context, "A", "B");
Assert.AreEqual(BinaryTrustFalseAttributes, trust.Value, $"Attributes are wrong!");
}
public async Task HandleAsync(
IWebSocketContext context,
GenericOperationMessage message,
CancellationToken cancellationToken)
{
QueryRequestDto payload = message.Payload.ToObject <QueryRequestDto>();
IQueryRequestBuilder requestBuilder =
QueryRequestBuilder.New()
.SetQuery(payload.Query)
.SetOperation(payload.OperationName)
.SetVariableValues(QueryMiddlewareUtilities
.ToDictionary(payload.Variables))
.SetServices(context.HttpContext.CreateRequestServices());
await context.PrepareRequestAsync(requestBuilder)
.ConfigureAwait(false);
IExecutionResult result =
await context.QueryExecutor.ExecuteAsync(
requestBuilder.Create(), cancellationToken)
.ConfigureAwait(false);
if (result is IResponseStream responseStream)
{
context.RegisterSubscription(
new Subscription(context, responseStream, message.Id));
}
else if (result is IReadOnlyQueryResult queryResult)
{
await context.SendSubscriptionDataMessageAsync(
message.Id, queryResult, cancellationToken)
.ConfigureAwait(false);
await context.SendSubscriptionCompleteMessageAsync(
message.Id, cancellationToken)
.ConfigureAwait(false);
}
}
public async Task Create_NullableStringIdNotIn_Expression()
{
// arrange
IRequestExecutor?tester = _cache.CreateSchema <FooNullable, FooNullableFilterInput>(
_fooNullableEntities);
// act
// assert
IExecutionResult?res1 = await tester.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"{
root(where: {
bar: {
nin: [ ""Rm8KZHRlc3RhdGVzdA=="" ""Rm8KZHRlc3RidGVzdA=="" ]
}
}){
bar
}
}")
.Create());
res1.MatchSnapshot("testatestAndtestb");
IExecutionResult?res2 = await tester.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
"{ root(where: { bar: { nin: [\"Rm8KZHRlc3RidGVzdA==\" null]}}){ bar}}")
.Create());
res2.MatchSnapshot("testbtestAndNull");
IExecutionResult?res3 = await tester.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery("{ root(where: { bar: { nin: [ \"Rm8KZHRlc3RhdGVzdA==\" ]}}){ bar}}")
.Create());
res3.MatchSnapshot("testatest");
}
public async Task Create_BufferedRequest()
{
// arrange
ISchema schema =
await new ServiceCollection()
.AddGraphQL()
.AddCustomerSchema()
.BuildSchemaAsync();
var queryA = "query abc($id: ID) { customer(id: $id) { name } }";
var queryB = "query abc($id: ID) { customer(id: $id) { id } }";
IQueryRequest requestA =
QueryRequestBuilder.New()
.SetQuery(queryA)
.SetVariableValue("id", "1")
.Create();
IQueryRequest requestB =
QueryRequestBuilder.New()
.SetQuery(queryB)
.SetVariableValue("id", "1")
.Create();
var bufferedRequestA = BufferedRequest.Create(requestA, schema);
var bufferedRequestB = BufferedRequest.Create(requestB, schema);
// act
IEnumerable <(IQueryRequest, IEnumerable <BufferedRequest>)> mergeResult =
MergeRequestHelper.MergeRequests(
new[] { bufferedRequestA, bufferedRequestB });
// assert
string.Join(Environment.NewLine + "-------" + Environment.NewLine,
mergeResult
.Select(t => t.Item1)
.Select(t => Utf8GraphQLParser.Parse(t.Query !.AsSpan()).ToString(true)))
.MatchSnapshot();
}
public void BuildRequest_QueryAndSetExtensions_RequestIsCreated_4()
{
// arrange
IDictionary <string, object> ext =
new Dictionary <string, object>
{
{ "three", "baz" }
};
// act
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery("{ foo }")
.AddExtension("one", "foo")
.AddExtension("two", "bar")
.SetExtensions(ext)
.Create();
// assert
// only three should exist
request.MatchSnapshot();
}
public async Task EnsureQueryResultContainsExtensionTracing()
{
// arrange
Schema schema = CreateSchema();
IQueryExecutor executor = QueryExecutionBuilder
.BuildDefault(schema, new QueryExecutionOptions
{
TracingPreference = TracingPreference.Always
});
var request = QueryRequestBuilder.New()
.SetQuery("{ a }")
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
// assert
Assert.NotEmpty(result.Extensions);
Assert.True(result.Extensions.ContainsKey("tracing"));
}
public async Task LastMetadataQuery()
{
//Arrange
//Connect to database
IServiceProvider serviceProvider =
new ServiceCollection()
.AddSingleton <IMetadataRepository, MetadataRepository>()
.AddSingleton <IDatabaseConfig>(sp =>
new DatabaseConfig()
{
DatabaseConnectionString = dbConnectionString
}
)
.BuildServiceProvider();
IQueryExecutor executor = Schema.Create(c =>
{
c.RegisterQueryType(new ObjectType <MetadataQuery>(d => d.Name("Query")));
c.RegisterType <List <MetadataType> >();
})
.MakeExecutable();
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery(@"{metadata(sensorID:1, onlyLast:true)
{metadataID,sensorID,locationID,name,serialNumber,number, modelNumber,department,company, ownerID,
purchaseDate,lending,lendingPrice,cableLength,checkOnInspectionRound,inspectionRound, company, servicePartner,voltage,coordinate,
altitude, locationDescription, cableLength, identificator, measureArea, picture,
plannedDisposal, actualDisposal, warrantyDate, voltage, signal, tag1, tag2, tag3, timeless, tollerance
createdAt, updatedAt, outdatedFrom}}")
.SetServices(serviceProvider)
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
//Assert
Snapshot.Match(result);
//result.MatchSnapshot();
}
public async Task DateType_GreaterThan_Filter()
{
// arrange
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton <IMongoCollection <Model> >(sp =>
{
IMongoDatabase database = _mongoResource.CreateDatabase();
IMongoCollection <Model> collection = database.GetCollection <Model>("col");
collection.InsertMany(new[]
{
new Model {
Date = new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc).Date
},
new Model {
Date = new DateTime(2016, 1, 1, 1, 1, 1, DateTimeKind.Utc).Date
},
});
return(collection);
});
ISchema schema = SchemaBuilder.New()
.AddQueryType <QueryType>()
.AddServices(serviceCollection.BuildServiceProvider())
.Create();
IQueryExecutor executor = schema.MakeExecutable();
IReadOnlyQueryRequest request = QueryRequestBuilder.New()
.SetQuery("{ items(where: { date_gt: \"2001-01-01\" }) { date } }")
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
// assert
result.MatchSnapshot();
}
public async Task GetItems_EqualsFilter_FirstItems_Is_Returned()
{
// arrange
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton <IMongoCollection <Model> >(sp =>
{
IMongoDatabase database = _mongoResource.CreateDatabase();
var collection = database.GetCollection <Model>("col");
collection.InsertMany(new[]
{
new Model {
Foo = "abc", Bar = 1, Baz = true
},
new Model {
Foo = "def", Bar = 2, Baz = false
},
});
return(collection);
});
ISchema schema = SchemaBuilder.New()
.AddQueryType <QueryType>()
.AddServices(serviceCollection.BuildServiceProvider())
.Create();
IQueryExecutor executor = schema.MakeExecutable();
IReadOnlyQueryRequest request = QueryRequestBuilder.New()
.SetQuery("{ items(where: { foo: \"abc\" }) { foo } }")
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
// assert
result.MatchSnapshot();
}
public static IEnumerable <(IQueryRequest, IEnumerable <BufferedRequest>)> MergeRequests(
IEnumerable <BufferedRequest> requests,
ISet <string> requestVariableNames)
{
foreach (var group in requests.GroupBy(t => t.Operation.Operation))
{
var rewriter = new MergeRequestRewriter(requestVariableNames);
var variableValues = new Dictionary <string, object?>();
var operationName = group
.Select(r => r.Request.OperationName)
.Where(n => n != null)
.Distinct()
.FirstOrDefault();
if (operationName is not null)
{
rewriter.SetOperationName(new NameNode(operationName));
}
var i = 0;
BufferedRequest first = null !;
foreach (BufferedRequest request in group)
{
first = request;
MergeRequest(request, rewriter, variableValues, $"__{i++}_");
}
IQueryRequest batch =
QueryRequestBuilder.New()
.SetQuery(rewriter.Merge())
.SetOperation(operationName)
.SetVariableValues(variableValues)
.TrySetServices(first.Request.Services)
.Create();
yield return(batch, group);
}
}
public void Source1Target1()
{
// Build up
EnsureTestGraph();
var queryBuilder = new QueryRequestBuilder(ClaimType);
BuildQuery(queryBuilder, "A", "D");
// Execute
var context = _graphQueryService.Execute(queryBuilder.Query);
PrintJson(context.Results);
// Verify
//Assert.AreEqual(4, context.Results.Trusts.Count, $"Should be {4} results!");
VerfifyResult(context, "A", "B");
VerfifyResult(context, "B", "C");
VerfifyResult(context, "B", "E");
VerfifyResult(context, "C", "D");
VerfifyResult(context, "E", "D");
}
public async Task Execute_DateTime_Filter()
{
// arrange
ISchema schema = SchemaBuilder.New()
.AddQueryType <QueryFooDateTime>(d => d
.Name("Query")
.Field(y => y.Foo)
.UseFiltering())
.Create();
IQueryExecutor executor = schema.MakeExecutable();
IReadOnlyQueryRequest request = QueryRequestBuilder.New()
.SetQuery("{ foo(where: { foo_gte: \"2019-06-01\"}) { foo } }")
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
// assert
result.MatchSnapshot();
}
public async Task Should_NotInitializeObject_When_ResultOfLeftJoinIsNull()
{
// arrange
IRequestExecutor tester = _cache.CreateSchema(_barWithoutRelation, OnModelCreating);
// act
// assert
IExecutionResult res1 = await tester.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"
{
root {
foo {
id
}
}
}")
.Create());
res1.MatchSqlSnapshot();
}
public async Task ApolloTracing_OnDemand_WithHeader()
{
// arrange
IRequestExecutor executor = await CreateExecutorAsync(c => c
.AddDocumentFromString(
@"
type Query {
a: String
}")
.AddResolver("Query", "a", () => "hello world a")
.AddApolloTracing(TracingPreference.OnDemand, new TestTimestampProvider()));
// act
IExecutionResult result = await executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery("{ a }")
.SetProperty(WellKnownContextData.EnableTracing, true)
.Create());
// assert
result.ToJson().MatchSnapshot();
}
OnCreateQueryRequestAsync(HttpContext context)
{
using (Stream stream = context.Request.Body)
{
IReadOnlyList <GraphQLRequest> batch = null;
switch (context.Request.ContentType.Split(';')[0])
{
case ContentType.Json:
batch = await _requestHelper
.ReadJsonRequestAsync(stream)
.ConfigureAwait(false);
break;
case ContentType.GraphQL:
batch = await _requestHelper
.ReadGraphQLQueryAsync(stream)
.ConfigureAwait(false);
break;
default:
throw new NotSupportedException();
}
// TODO : batching support has to be added later
GraphQLRequest request = batch[0];
return(QueryRequestBuilder.New()
.SetQuery(request.Query)
.SetQueryName(request.QueryName)
.SetQueryName(request.QueryName) // TODO : we should have a hash here
.SetOperation(request.OperationName)
.SetVariableValues(request.Variables)
.SetProperties(request.Extensions));
}
}
