public Task ParseQueryMiddleware_InvalidQuery_DocumentNull()
{
// arrange
Schema schema = CreateSchema();
IReadOnlyQueryRequest request = new QueryRequest("{");
var context = new QueryContext
(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request,
fs => fs.Field.Middleware
);
var diagnostics = new QueryExecutionDiagnostics(
new DiagnosticListener("Foo"),
new IDiagnosticObserver[0]);
var middleware = new ParseQueryMiddleware(
c => Task.CompletedTask,
new DefaultQueryParser(),
new Cache <DocumentNode>(10),
diagnostics);
// act
Func <Task> invoke = () => middleware.InvokeAsync(context);
// assert
return(Assert.ThrowsAsync <SyntaxException>(invoke));
}
public QueryExecutor(
ISchema schema,
IServiceProvider applicationServices,
QueryDelegate queryDelegate,
FieldMiddleware fieldMiddleware)
{
Schema = schema
?? throw new ArgumentNullException(nameof(schema));
_applicationServices = applicationServices
?? throw new ArgumentNullException(nameof(applicationServices));
_queryDelegate = queryDelegate
?? throw new ArgumentNullException(nameof(queryDelegate));
if (Schema.Services != null)
{
IEnumerable <IDiagnosticObserver> observers = Schema.Services
.GetService <IEnumerable <IDiagnosticObserver> >();
if (observers != null)
{
QueryExecutionDiagnostics diagnosticEvents = _applicationServices
.GetService <QueryExecutionDiagnostics>();
diagnosticEvents.Subscribe(observers);
}
}
_fieldMiddlewareCompiler = new FieldMiddlewareCompiler(
schema, fieldMiddleware);
}
public async Task ParseQueryMiddleware_ValidQuery_DocumentIsSet()
{
// arrange
Schema schema = CreateSchema();
IReadOnlyQueryRequest request = new QueryRequest("{ a }");
var context = new QueryContext
(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request,
fs => fs.Field.Middleware
);
var diagnostics = new QueryExecutionDiagnostics(
new DiagnosticListener("Foo"),
new IDiagnosticObserver[0]);
var middleware = new ParseQueryMiddleware(
c => Task.CompletedTask,
new DefaultQueryParser(),
new Cache <DocumentNode>(10),
diagnostics);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Document);
context.Document.Snapshot();
}
public InstrumentationMiddleware(
QueryDelegate next,
QueryExecutionDiagnostics diagnosticEvents)
{
_next = next ?? throw new ArgumentNullException(nameof(next));
_diagnosticEvents = diagnosticEvents
?? throw new ArgumentNullException(nameof(diagnosticEvents));
}
public void CloneExecutionContext()
{
// arrange
var schema = Schema.Create(
"type Query { foo: String }",
c => c.Use(next => context => Task.CompletedTask));
DocumentNode query = Utf8GraphQLParser.Parse("{ foo }");
var errorHandler = new Mock <IErrorHandler>();
var services = new Mock <IServiceProvider>();
services.Setup(t => t.GetService(typeof(IErrorHandler)))
.Returns(errorHandler.Object);
IRequestServiceScope serviceScope = services.Object
.CreateRequestServiceScope();
var variables = new Mock <IVariableValueCollection>();
var operation = new Mock <IOperation>();
operation.Setup(t => t.Document).Returns(query);
operation.Setup(t => t.Variables).Returns(variables.Object);
var contextData = new Dictionary <string, object>
{
{ "abc", "123" }
};
var diagnostics = new QueryExecutionDiagnostics(
new DiagnosticListener("Foo"),
new IDiagnosticObserver[0]);
var requestContext = new RequestContext(
serviceScope,
(f, s) => null,
new CachedQuery("{ foo }", Utf8GraphQLParser.Parse("{ foo }")),
contextData,
diagnostics);
// act
var executionContext = new ExecutionContext(
schema, operation.Object, requestContext,
CancellationToken.None);
IExecutionContext cloned = executionContext.Clone();
// assert
Assert.Equal(contextData, executionContext.ContextData);
Assert.Equal(contextData, cloned.ContextData);
Assert.False(object.ReferenceEquals(
executionContext.Result, cloned.Result));
Assert.False(object.ReferenceEquals(
executionContext.ContextData, cloned.ContextData));
}
public ValidateQueryMiddleware(
QueryDelegate next,
IQueryValidator validator,
Cache <QueryValidationResult> validatorCache,
QueryExecutionDiagnostics diagnostics)
{
_next = next ??
throw new ArgumentNullException(nameof(next));
_validator = validator ??
throw new ArgumentNullException(nameof(validator));
_validatorCache = validatorCache ??
new Cache <QueryValidationResult>(Defaults.CacheSize);
_diagnostics = diagnostics ??
throw new ArgumentNullException(nameof(diagnostics));
}
public RequestContext(
IRequestServiceScope serviceScope,
Func <FieldSelection, FieldDelegate> middlewareResolver,
IDictionary <string, object> contextData,
QueryExecutionDiagnostics diagnostics)
{
ServiceScope = serviceScope
?? throw new ArgumentNullException(nameof(serviceScope));
_resolveMiddleware = middlewareResolver
?? throw new ArgumentNullException(nameof(middlewareResolver));
ContextData = contextData
?? throw new ArgumentNullException(nameof(contextData));
Diagnostics = diagnostics
?? throw new ArgumentNullException(nameof(diagnostics));
}
public ExecuteOperationMiddleware(
QueryDelegate next,
IExecutionStrategyResolver strategyResolver,
Cache <DirectiveMiddlewareCompiler> directiveCache,
QueryExecutionDiagnostics diagnosticEvents)
{
_next = next ??
throw new ArgumentNullException(nameof(next));
_strategyResolver = strategyResolver ??
throw new ArgumentNullException(nameof(strategyResolver));
_cache = directiveCache ??
throw new ArgumentNullException(nameof(directiveCache));
_diagnosticEvents = diagnosticEvents ??
throw new ArgumentNullException(nameof(diagnosticEvents));
}
public ParseQueryMiddleware(
QueryDelegate next,
IQueryParser parser,
Cache <ICachedQuery> queryCache,
QueryExecutionDiagnostics diagnosticEvents)
{
_next = next
?? throw new ArgumentNullException(nameof(next));
_parser = parser
?? throw new ArgumentNullException(nameof(parser));
_queryCache = queryCache
?? throw new ArgumentNullException(nameof(queryCache));
_diagnosticEvents = diagnosticEvents
?? throw new ArgumentNullException(nameof(diagnosticEvents));
}
public ValidateQueryMiddleware(
QueryDelegate next,
IDocumentValidatorFactory validatorFactory,
Cache <DocumentValidatorResult> validatorCache,
QueryExecutionDiagnostics diagnostics)
{
if (validatorFactory == null)
{
throw new ArgumentNullException(nameof(validatorFactory));
}
_next = next ?? throw new ArgumentNullException(nameof(next));
_validator = validatorFactory.CreateValidator();
_validatorCache = validatorCache ??
new Cache <DocumentValidatorResult>(Defaults.CacheSize);
_diagnostics = diagnostics ?? throw new ArgumentNullException(nameof(diagnostics));
}
public RequestContext(
IRequestServiceScope serviceScope,
Func <ObjectField, FieldNode, FieldDelegate> middlewareFactory,
ICachedQuery cachedQuery,
IDictionary <string, object> contextData,
QueryExecutionDiagnostics diagnostics)
{
ServiceScope = serviceScope
?? throw new ArgumentNullException(nameof(serviceScope));
_factory = middlewareFactory
?? throw new ArgumentNullException(nameof(middlewareFactory));
CachedQuery = cachedQuery
?? throw new ArgumentNullException(nameof(cachedQuery));
ContextData = contextData
?? throw new ArgumentNullException(nameof(contextData));
Diagnostics = diagnostics
?? throw new ArgumentNullException(nameof(diagnostics));
}
public async Task ExecuteOperationMiddleware_Mutation_ExecutedSerially()
{
// arrange
var state = 0;
var schema = Schema.Create(
FileResource.Open("MutationExecutionSchema.graphql"),
cnf =>
{
cnf.BindResolver(() => state)
.To("Query", "state");
cnf.BindResolver(() => state)
.To("CurrentState", "theNumber");
cnf.BindResolver(
ctx => state = ctx.Argument <int>("newNumber"))
.To("Mutation", "changeTheNumber");
});
DocumentNode query = Parser.Default.Parse(
FileResource.Open("MutationExecutionQuery.graphql"));
OperationDefinitionNode operationNode = query.Definitions
.OfType <OperationDefinitionNode>()
.FirstOrDefault();
var operation = new Operation
(
query,
operationNode,
new VariableValueBuilder(
schema,
operationNode)
.CreateValues(new Dictionary <string, object>()),
schema.MutationType,
null
);
IReadOnlyQueryRequest request = new QueryRequest("{ a }");
var observable = new DiagnosticListener("Foo");
var services = new DictionaryServiceProvider(
new KeyValuePair <Type, object>(
typeof(IErrorHandler),
ErrorHandler.Default),
new KeyValuePair <Type, object>(
typeof(DiagnosticListener),
observable),
new KeyValuePair <Type, object>(
typeof(DiagnosticSource),
observable));
var context = new QueryContext
(
schema,
services.CreateRequestServiceScope(),
request,
fs => fs.Field.Middleware
)
{
Document = query,
Operation = operation
};
var options = new QueryExecutionOptions();
var strategyResolver = new ExecutionStrategyResolver(options);
var diagnostics = new QueryExecutionDiagnostics(
new DiagnosticListener("Foo"),
new IDiagnosticObserver[0],
TracingPreference.Never);
var middleware = new ExecuteOperationMiddleware(
c => Task.CompletedTask,
strategyResolver,
new Cache <DirectiveMiddlewareCompiler>(10),
diagnostics);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Result);
context.Result.Snapshot();
}
