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, schema.MutationType,
null);
IReadOnlyQueryRequest request = new QueryRequest("{ a }")
.ToReadOnly();
var services = new DictionaryServiceProvider(
new KeyValuePair <Type, object>(
typeof(IErrorHandler),
ErrorHandler.Default));
var context = new QueryContext(
schema, services.CreateRequestServiceScope(), request)
{
Document = query,
Operation = operation,
Variables = new VariableValueBuilder(
schema, operation.Definition)
.CreateValues(new Dictionary <string, object>())
};
var options = new QueryExecutionOptions();
var strategyResolver = new ExecutionStrategyResolver(options);
var middleware = new ExecuteOperationMiddleware(
c => Task.CompletedTask,
strategyResolver,
new Cache <DirectiveLookup>(10));
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Result);
context.Result.Snapshot();
}
public async Task ValidateMaxComplexityWithMiddlewareWithObjectsAndVar(
int count, bool valid)
{
// arrange
var schema = Schema.Create(
@"
type Query {
foo(i: FooInput): String
@cost(complexity: 5 multipliers: [""i.index""])
}
input FooInput {
index : Int
}
",
c =>
{
c.BindResolver(() => "Hello")
.To("Query", "foo");
});
var options = new Mock <IValidateQueryOptionsAccessor>();
options.SetupGet(t => t.MaxOperationComplexity).Returns(20);
options.SetupGet(t => t.UseComplexityMultipliers).Returns(true);
DocumentNode query = Parser.Default.Parse(
"query f($i:Int) { foo(i: { index:$i }) }");
OperationDefinitionNode operationNode = query.Definitions
.OfType <OperationDefinitionNode>()
.FirstOrDefault();
var operation = new Operation
(
query,
operationNode,
new VariableValueBuilder(
schema,
operationNode)
.CreateValues(new Dictionary <string, object>
{
{ "i", count }
}),
schema.QueryType,
null
);
IReadOnlyQueryRequest request = new QueryRequest("{ a }");
var services = new DictionaryServiceProvider(
new KeyValuePair <Type, object>(
typeof(IErrorHandler),
ErrorHandler.Default));
var context = new QueryContext
(
schema,
services.CreateRequestServiceScope(),
request,
fs => fs.Field.Middleware
)
{
Document = query,
Operation = operation
};
var middleware = new MaxComplexityMiddleware(
c => Task.CompletedTask,
options.Object,
null);
// act
await middleware.InvokeAsync(context);
// assert
if (valid)
{
Assert.Null(context.Result);
}
else
{
context.Result.Snapshot(
"ValidateMaxComplexityWithMiddlewareWithObjectsAndVar" +
count);
}
}
