public async Task ResolveRootTypeWithCustomNames(string rootType)
{
// arrange
Schema schema = Schema.Create(@"
type Foo { a: String }
schema { " + rootType + @": Foo }
", c =>
{
c.BindResolver(() => "hello world")
.To("Foo", "a");
});
var request = new QueryRequest("query a { a }").ToReadOnly();
var context = new QueryContext(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request);
context.Document = Parser.Default.Parse(request.Query);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Operation.RootType);
}
public async Task RootClrTypeIsObject()
{
// arrange
Schema schema = Schema.Create(@"
type Query { a: String }
", c =>
{
c.BindResolver(() => "hello world")
.To("Query", "a");
});
var request = new QueryRequest("query a { a }").ToReadOnly();
var context = new QueryContext(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request);
context.Document = Parser.Default.Parse(request.Query);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.Null(context.Operation.RootValue);
}
public async Task RootValueProvidedByRequest()
{
// arrange
Schema schema = Schema.Create(c =>
{
c.RegisterQueryType <DisposableQuery>();
});
var rootValue = new DisposableQuery();
var request = new QueryRequest("{ isDisposable }")
{
InitialValue = rootValue
}.ToReadOnly();
var context = new QueryContext(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request);
context.Document = Parser.Default.Parse(request.Query);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.True(object.ReferenceEquals(
rootValue, context.Operation.RootValue));
}
public async Task RootValueNotProvidedAndRegisteredWithServices()
{
// arrange
Schema schema = Schema.Create(c =>
{
c.RegisterQueryType <DisposableQuery>();
});
var request = new QueryRequest("{ isDisposable }").ToReadOnly();
var context = new QueryContext(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request);
context.Document = Parser.Default.Parse(request.Query);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
DisposableQuery query = Assert.IsType <DisposableQuery>(
context.Operation.RootValue);
Assert.True(query.IsDisposed);
}
public async Task ParseQueryMiddleware_ValidQuery_DocumentIsSet()
{
// arrange
Schema schema = CreateSchema();
var request = new QueryRequest("query foo($a: String) { a }")
{
VariableValues = new Dictionary <string, object>
{
{ "a", "abc" }
}
}.ToReadOnly();
var context = new QueryContext(
schema, MiddlewareTools.CreateEmptyRequestServiceScope(), request);
context.Document = Parser.Default.Parse(request.Query);
context.Operation = new Operation(
context.Document,
context.Document.Definitions
.OfType <OperationDefinitionNode>()
.First(),
schema.QueryType,
null);
var middleware = new CoerceVariablesMiddleware(
c => Task.CompletedTask);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Variables);
Assert.Equal("abc", context.Variables.GetVariable <string>("a"));
}
public async Task OperationIsResolved()
{
// arrange
Schema schema = Schema.Create(@"
type Query { a: String }
", c =>
{
c.BindResolver(() => "hello world")
.To("Query", "a");
});
var request = new QueryRequest("query a { a }");
var context = new QueryContext
(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request,
fs => fs.Field.Middleware
);
context.Document = Parser.Default.Parse(request.Query);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Operation);
Assert.Equal("a", context.Operation.Name);
}
public async Task RootValueIsRegisterdAsService()
{
// arrange
var services = new DictionaryServiceProvider(
typeof(DisposableQuery), new DisposableQuery());
Schema schema = Schema.Create(c =>
{
c.RegisterQueryType <DisposableQuery>();
});
var request = new QueryRequest("{ isDisposable }");
var context = new QueryContext
(
schema,
MiddlewareTools.CreateRequestServiceScope(services),
request,
fs => fs.Field.Middleware
);
context.Document = Parser.Default.Parse(request.Query);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
DisposableQuery query = Assert.IsType <DisposableQuery>(
context.Operation.RootValue);
Assert.False(query.IsDisposed);
}
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 async Task TwoOperations_ShortHand_QueryException()
{
// arrange
Schema schema = Schema.Create(@"
type Query { a: String }
", c =>
{
c.BindResolver(() => "hello world")
.To("Query", "a");
});
var request = new QueryRequest("{ a } query a { a }").ToReadOnly();
var context = new QueryContext(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request);
context.Document = Parser.Default.Parse(request.Query);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
Func <Task> func = () => middleware.InvokeAsync(context);
// assert
QueryException exception =
await Assert.ThrowsAsync <QueryException>(func);
Assert.Equal(
"Only queries that contain one operation can be executed " +
"without specifying the opartion name.",
exception.Message);
}
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 async Task ParseQueryMiddleware_ValidQuery_DocumentIsSet()
{
// arrange
var schema = Schema.Create(@"
type Query { a(b:String): String }
", c =>
{
c.BindResolver(() => "hello world")
.To("Query", "a");
});
var sourceText = "query foo($a: String) { a }";
var request = QueryRequestBuilder.New()
.SetQuery(sourceText)
.SetVariableValue("a", "abc")
.Create();
var context = new QueryContext
(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request,
(f, s) => f.Middleware
);
context.QueryKey = "Foo";
context.Document = Utf8GraphQLParser.Parse(sourceText);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Operation.Variables);
Assert.Equal(
"abc",
context.Operation.Variables.GetVariable <string>("a"));
}
public async Task TwoOperations_WrongOperationName_QueryException()
{
// arrange
var schema = Schema.Create(@"
type Query { a: String }
", c =>
{
c.BindResolver(() => "hello world")
.To("Query", "a");
});
var sourceText = "query a { a } query b { a }";
var request = QueryRequestBuilder.New()
.SetQuery(sourceText)
.SetOperation("c")
.Create();
var context = new QueryContext
(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request,
(f, s) => f.Middleware
);
context.Document = Utf8GraphQLParser.Parse(sourceText);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
Func <Task> func = () => middleware.InvokeAsync(context);
// assert
QueryException exception =
await Assert.ThrowsAsync <QueryException>(func);
Assert.Equal(
"The specified operation `c` does not exist.",
exception.Message);
}
public async Task InnerMiddlewareTimesOut()
{
// arrange
var options = new Mock <IRequestTimeoutOptionsAccessor>();
options
.SetupGet(o => o.ExecutionTimeout)
.Returns(TimeSpan.FromMilliseconds(10));
var schema = Schema.Create(@"
type Query { a: String }
", c =>
{
c.BindResolver(() => "hello world")
.To("Query", "a");
});
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery("{ a }")
.Create();
var context = new QueryContext
(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request,
(f, s) => f.Middleware
);
var middleware = new RequestTimeoutMiddleware(
c => Task.Delay(1000, c.RequestAborted),
options.Object);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Result);
Assert.IsType <TaskCanceledException>(context.Exception);
context.Result.MatchSnapshot();
}
public async Task ProvidedRootValueTakesPrecedenceOverService()
{
// arrange
var services = new DictionaryServiceProvider(
typeof(DisposableQuery), new DisposableQuery());
var schema = Schema.Create(c =>
{
c.RegisterQueryType <DisposableQuery>();
});
var rootValue = new DisposableQuery();
var sourceText = "{ isDisposable }";
var request = QueryRequestBuilder.New()
.SetQuery(sourceText)
.SetInitialValue(rootValue)
.Create();
var context = new QueryContext
(
schema,
MiddlewareTools.CreateRequestServiceScope(services),
request,
(f, s) => f.Middleware
);
context.Document = Utf8GraphQLParser.Parse(sourceText);
context.QueryKey = "foo";
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.True(object.ReferenceEquals(
rootValue, context.Operation.RootValue));
}
public async Task ParseQueryMiddleware_ValidQuery_DocumentIsSet()
{
// arrange
Schema schema = Schema.Create(@"
type Query { a(b:String): String }
", c =>
{
c.BindResolver(() => "hello world")
.To("Query", "a");
});
var request = new QueryRequest("query foo($a: String) { a }")
{
VariableValues = new Dictionary <string, object>
{
{ "a", "abc" }
}
};
var context = new QueryContext
(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request,
fs => fs.Field.Middleware
);
context.Document = Parser.Default.Parse(request.Query);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Operation.Variables);
Assert.Equal(
"abc",
context.Operation.Variables.GetVariable <string>("a"));
}
public async Task ResolveRootTypeWithCustomNames(string rootType)
{
// arrange
string queryType = rootType == "query"
? string.Empty
: "type Query { a : String }";
var schema = Schema.Create(@"
type Foo { a: String }
schema { " + rootType + @": Foo }
" + queryType, c =>
{
c.Use(n => ctx => Task.CompletedTask);
});
var sourceText = "query a { a }";
var request = QueryRequestBuilder.New()
.SetQuery(sourceText)
.Create();
var context = new QueryContext
(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request,
(f, s) => f.Middleware
);
context.QueryKey = "foo";
context.Document = Utf8GraphQLParser.Parse(sourceText);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Operation.RootType);
}
public async Task RootValueIsRegisterdAsService()
{
// arrange
var services = new DictionaryServiceProvider(
typeof(DisposableQuery), new DisposableQuery());
var schema = Schema.Create(c =>
{
c.RegisterQueryType <DisposableQuery>();
});
var sourceText = "{ isDisposable }";
var request = QueryRequestBuilder.New()
.SetQuery(sourceText)
.Create();
var context = new QueryContext
(
schema,
MiddlewareTools.CreateRequestServiceScope(services),
request,
(f, s) => f.Middleware
);
context.Document = Utf8GraphQLParser.Parse(sourceText);
context.QueryKey = "foo";
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
DisposableQuery query = Assert.IsType <DisposableQuery>(
context.Operation.RootValue);
Assert.False(query.IsDisposed);
}
public async Task ProvidedRootValueTakesPrecedenceOverService()
{
// arrange
var services = new DictionaryServiceProvider(
typeof(DisposableQuery), new DisposableQuery());
Schema schema = Schema.Create(c =>
{
c.RegisterQueryType <DisposableQuery>();
});
var rootValue = new DisposableQuery();
var request = new QueryRequest("{ isDisposable }")
{
InitialValue = rootValue
};
var context = new QueryContext
(
schema,
MiddlewareTools.CreateRequestServiceScope(services),
request,
fs => fs.Field.Middleware
);
context.Document = Parser.Default.Parse(request.Query);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.True(object.ReferenceEquals(
rootValue, context.Operation.RootValue));
}
public async Task OperationIsResolved()
{
// arrange
var schema = Schema.Create(@"
type Query { a: String }
", c =>
{
c.BindResolver(() => "hello world")
.To("Query", "a");
});
var sourceText = "query a { a }";
var request = QueryRequestBuilder.New()
.SetQuery(sourceText)
.Create();
var context = new QueryContext
(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request,
(f, s) => f.Middleware
);
context.Document = Utf8GraphQLParser.Parse(sourceText);
context.QueryKey = "foo";
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Operation);
Assert.Equal("a", context.Operation.Name);
}
public Task ParseQueryMiddleware_InvalidQuery_DocumentNull()
{
// arrange
Schema schema = CreateSchema();
var request = new QueryRequest("{").ToReadOnly();
var context = new QueryContext(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request);
var middleware = new ParseQueryMiddleware(
c => Task.CompletedTask,
new DefaultQueryParser(),
new Cache <DocumentNode>(10));
// act
Func <Task> invoke = () => middleware.InvokeAsync(context);
// assert
return(Assert.ThrowsAsync <SyntaxException>(invoke));
}
public async Task ParseQueryMiddleware_ValidQuery_DocumentIsSet()
{
// arrange
Schema schema = CreateSchema();
var request = new QueryRequest("{ a }").ToReadOnly();
var context = new QueryContext(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request);
var middleware = new ParseQueryMiddleware(
c => Task.CompletedTask,
new DefaultQueryParser(),
new Cache <DocumentNode>(10));
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Document);
context.Document.Snapshot();
}
public async Task ResolveRootTypeWithCustomNames(string rootType)
{
// arrange
string queryType = rootType == "query"
? string.Empty
: "type Query { a : String }";
var schema = Schema.Create(@"
type Foo { a: String }
schema { " + rootType + @": Foo }
" + queryType, c =>
{
c.Use(n => ctx => Task.CompletedTask);
});
var request = new QueryRequest("query a { a }");
var context = new QueryContext
(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request,
fs => fs.Field.Middleware
);
context.Document = Parser.Default.Parse(request.Query);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Operation.RootType);
}
public async Task TwoOperations_WrongOperationName_QueryException()
{
// arrange
Schema schema = Schema.Create(@"
type Query { a: String }
", c =>
{
c.BindResolver(() => "hello world")
.To("Query", "a");
});
var request = new QueryRequest(
"query a { a } query b { a }", "c")
.ToReadOnly();
var context = new QueryContext(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request);
context.Document = Parser.Default.Parse(request.Query);
var middleware = new ResolveOperationMiddleware(
c => Task.CompletedTask, null);
// act
Func <Task> func = () => middleware.InvokeAsync(context);
// assert
QueryException exception =
await Assert.ThrowsAsync <QueryException>(func);
Assert.Equal(
"The specified operation `c` does not exist.",
exception.Message);
}
