public void BuildRequest_QueryAndSetExtensions_RequestIsCreated_5()
{
// 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)
.AddExtension("four", "bar")
.Create();
// assert
// only three should exist
request.MatchSnapshot();
}
public static QueryRequestBuilder From(IReadOnlyQueryRequest request)
{
var builder = new QueryRequestBuilder
{
_query = request.Query,
_queryName = request.QueryId,
_queryHash = request.QueryHash,
_operationName = request.OperationName,
_readOnlyVariableValues = request.VariableValues,
_initialValue = request.InitialValue,
_readOnlyProperties = request.ContextData,
_readOnlyExtensions = request.Extensions,
_services = request.Services
};
if (builder._query is null && builder._queryName is null)
{
throw new QueryRequestBuilderException(
AbstractionResources.QueryRequestBuilder_QueryIsNull);
}
return(builder);
}
BuildBatchRequestAsync(
HttpContext context,
IServiceProvider services,
GraphQLRequest request,
IReadOnlyList <string> operationNames)
{
var queryBatch = new IReadOnlyQueryRequest[operationNames.Count];
for (var i = 0; i < operationNames.Count; i++)
{
IQueryRequestBuilder requestBuilder =
QueryRequestBuilder.From(request)
.SetOperation(operationNames[i]);
queryBatch[i] = await BuildRequestAsync(
context,
services,
requestBuilder)
.ConfigureAwait(false);
}
return(queryBatch);
}
public static async Task ExpectError(
string query,
TestConfiguration?configuration,
params Action <IError>[] elementInspectors)
{
// arrange
IRequestExecutor executor = await CreateExecutorAsync(configuration);
IReadOnlyQueryRequest request = CreateRequest(configuration, query);
// act
IExecutionResult result = await executor.ExecuteAsync(request, default);
// assert
Assert.NotNull(result.Errors);
if (elementInspectors.Length > 0)
{
Assert.Collection(result.Errors, elementInspectors);
}
result.MatchSnapshot();
}
public async Task Custom_Scalar_Delegated_Argument()
{
// arrange
IHttpClientFactory clientFactory = CreateRemoteSchemas();
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(clientFactory);
serviceCollection.AddStitchedSchema(builder => builder
.AddSchemaFromHttp("special")
.AddExtensionsFromString("extend type Query { custom_scalar_stitched(bar: MyCustomScalarValue): MyCustomScalarValue @delegate(schema: \"special\", path: \"custom_scalar(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("{ custom_scalar_stitched(bar: \"2019-11-11\") }")
.SetServices(scope.ServiceProvider)
.Create();
result = await executor.ExecuteAsync(request);
}
// assert
result.MatchSnapshot();
}
public async Task TestSensorsQuery()
{
IServiceProvider serviceProvider =
new ServiceCollection()
.AddSingleton <ITimeSeriesRepository, TimeSeriesRepository>()
.AddSingleton <IDatabaseConfig>(sp =>
new DatabaseConfig()
{
DatabaseConnectionString = dbConnectionString
}
)
.BuildServiceProvider();
IQueryExecutor executor = Schema.Create(c =>
{
c.RegisterQueryType(new ObjectType <TimeSeriesQuery>(d => d.Name("Query")));
})
.MakeExecutable();
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery(@"query sensors{
sensors {
sensorTypeName,
sensorIds,
sensorColumns
}
}")
.SetServices(serviceProvider)
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
//Snapshot.Match(result);
result.MatchSnapshot();
}
public async Task InvokeAsync(IMiddlewareContext context)
{
DelegateDirective delegateDirective = context.Field
.Directives[DirectiveNames.Delegate]
.FirstOrDefault()?.ToObject <DelegateDirective>();
if (delegateDirective != null)
{
IImmutableStack <SelectionPathComponent> path =
delegateDirective.Path is null
? ImmutableStack <SelectionPathComponent> .Empty
: SelectionPathParser.Parse(delegateDirective.Path);
IReadOnlyQueryRequest request =
CreateQuery(context, delegateDirective.Schema, path);
IReadOnlyQueryResult result = await ExecuteQueryAsync(
context, request, delegateDirective.Schema)
.ConfigureAwait(false);
UpdateContextData(context, result, delegateDirective);
context.Result = new SerializedData(ExtractData(result.Data, path.Count()));
if (result.Errors is { })
public DefaultExecutionPipelineBenchmark()
{
var md5 = new MD5DocumentHashProvider();
var resources = new ResourceHelper();
var services = new ServiceCollection()
.AddStarWarsRepositories()
.AddGraphQL()
.AddStarWarsTypes()
.ModifyRequestOptions(o => o.IncludeExceptionDetails = true)
.Services
.BuildServiceProvider();
_executor = services
.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync()
.Result;
_getHeroRequest = CreateRequest(md5, resources, "GetHeroQuery.graphql");
_getHeroWithFriendsRequest = CreateRequest(md5, resources, "GetHeroWithFriendsQuery.graphql");
_getTwoHeroesWithFriendsRequest = CreateRequest(md5, resources, "GetTwoHeroesWithFriendsRequest.graphql");
_largeQuery = CreateRequest(md5, resources, "LargeQuery.graphql");
_introspectionRequest = CreateRequest(md5, resources, "IntrospectionQuery.graphql");
SchemaIntrospection().Wait();
}
public async Task GetCinema_With_Results()
{
//arrange
Mock <ICinemaLogic> cinemaLogicMock = new Mock <ICinemaLogic>();
cinemaLogicMock.Setup(p => p.GetCinemas()).Returns(_GetCinemaList());
Mock <IServiceProvider> serviceProvider = new Mock <IServiceProvider>();
serviceProvider.Setup(p => p.GetService(typeof(ICinemaLogic))).Returns(cinemaLogicMock.Object);
IQueryExecutor queryExecutor = QueryExecutorFactory.Create <CinemaQuery>();
IReadOnlyQueryRequest queryRequest = QueryRequestBuilder.New()
.SetQuery(@"query GetAllCinemas{
cinemas{
edges{
cursor
}
nodes{
title
description
iD
duration
}
}
}")
.AddProperty("Key", "value")
.SetServices(serviceProvider.Object)
.Create();
//act
IExecutionResult result = await queryExecutor.ExecuteAsync(queryRequest);
//assert
result.MatchSnapshot();
}
private Task <IExecutionResult> ExecuteStitchedQuery(
IReadOnlyQueryRequest request)
{
// arrange
IHttpClientFactory clientFactory = CreateRemoteSchemas();
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(clientFactory);
serviceCollection.AddRemoteQueryExecutor(b => b
.SetSchemaName("contract")
.SetSchema(FileResource.Open("Contract.graphql"))
.AddScalarType <DateTimeType>());
serviceCollection.AddRemoteQueryExecutor(b => b
.SetSchemaName("customer")
.SetSchema(FileResource.Open("Customer.graphql")));
serviceCollection.AddStitchedSchema(
FileResource.Open("Stitching.graphql"),
c => c.RegisterType <DateTimeType>());
IServiceProvider services =
serviceCollection.BuildServiceProvider();
request = QueryRequestBuilder.From(request)
.SetServices(services)
.Create();
IQueryExecutor executor = services
.GetRequiredService <IQueryExecutor>();
// act
return(executor.ExecuteAsync(request));
}
public void Sort_ComparableAsc_PrefilterInResolver()
{
// arrange
IQueryable <Foo> data = new[] {
new Foo {
Bar = "baz", Baz = "a"
},
new Foo {
Bar = "aa", Baz = "b"
},
new Foo {
Bar = "zz", Baz = "b"
}
}.AsQueryable().OrderBy(x => x.Baz);
ISchema schema = SchemaBuilder.New()
.AddQueryType(ctx =>
{
ctx.Field("foo")
.Resolver(data)
.Type <NonNullType <ListType <NonNullType <ObjectType <Foo> > > > >()
.UseSorting();
})
.Create();
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery("{ foo(order_by: { bar: DESC }) { bar } }")
.Create();
// act
IExecutionResult result = schema.MakeExecutable().Execute(request);
// assert
result.MatchSnapshot();
}
protected static async Task <IBatchQueryResult> ExecuteBatchAsync(
HttpContext context,
IRequestExecutor requestExecutor,
IHttpRequestInterceptor requestInterceptor,
IServerDiagnosticEvents diagnosticEvents,
IReadOnlyList <GraphQLRequest> requests)
{
diagnosticEvents.StartBatchRequest(context, 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 ParseQueryMiddleware_ValidQuery_DocumentIsSet()
{
// arrange
Schema schema = CreateSchema();
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery("{ a }")
.Create();
var context = new QueryContext
(
schema,
MiddlewareTools.CreateEmptyRequestServiceScope(),
request,
(f, s) => f.Middleware
);
var diagnostics = new QueryExecutionDiagnostics(
new DiagnosticListener("Foo"),
new IDiagnosticObserver[0]);
var middleware = new ParseQueryMiddleware(
c => Task.CompletedTask,
new DefaultQueryParser(),
new Cache <ICachedQuery>(10),
diagnostics,
null);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Document);
context.Document.MatchSnapshot();
}
public async Task DispatchMultipleQueriesWithVariables()
{
// arrange
IReadOnlyQueryRequest mergedRequest = null;
int count = 0;
var result = QueryResultBuilder.New();
var data = new OrderedDictionary();
data["__0__a"] = "a";
data["__1__a"] = "b";
data["__1__b"] = "c";
result.SetData(data);
var schema = SchemaBuilder.New()
.AddDocumentFromString("type Query { foo: String }")
.AddResolver("Query", "foo", c => "bar")
.Create();
var executor = new Mock <IQueryExecutor>();
executor.Setup(t => t.ExecuteAsync(
It.IsAny <IReadOnlyQueryRequest>(),
It.IsAny <CancellationToken>()))
.Returns(new Func <IReadOnlyQueryRequest,
CancellationToken, Task <IExecutionResult> >((r, ct) =>
{
count++;
mergedRequest = r;
return(Task.FromResult <IExecutionResult>(result.Create()));
}));
executor.Setup(t => t.Schema).Returns(schema);
var request_a = QueryRequestBuilder.New()
.SetQuery("query a($a: String) { a(b: $a) }")
.SetVariableValue("a", "foo")
.Create();
var request_b = QueryRequestBuilder.Create(
"query b { a b }");
var client = new RemoteQueryClient(
new EmptyServiceProvider(),
executor.Object);
// act
Task <IExecutionResult> task_a = client.ExecuteAsync(request_a);
Task <IExecutionResult> task_b = client.ExecuteAsync(request_b);
await client.DispatchAsync(CancellationToken.None);
// assert
await task_a;
await task_b;
Assert.Equal(1, count);
new
{
Query = mergedRequest.Query.ToString(),
QueryName = mergedRequest.QueryName,
QueryHash = mergedRequest.QueryHash,
OperationName = mergedRequest.OperationName,
Varables = mergedRequest.VariableValues,
Extensions = mergedRequest.Extensions,
}.MatchSnapshot();
}
public Task <QueryResult> FetchAsync(
IReadOnlyQueryRequest request,
HttpClient httpClient,
IEnumerable <IHttpQueryRequestInterceptor> interceptors) =>
FetchAsync(CreateRemoteRequest(request), httpClient, interceptors);
public async Task ConnectionLost()
{
// arrange
var connections = new Dictionary <string, HttpClient>();
IHttpClientFactory clientFactory = CreateRemoteSchemas(connections);
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(clientFactory);
serviceCollection.AddStitchedSchema(builder =>
builder.AddSchemaFromHttp("contract")
.AddSchemaFromHttp("customer")
.RenameType("CreateCustomerInput", "CreateCustomerInput2")
.AddExtensionsFromString(
FileResource.Open("StitchingExtensions.graphql"))
.AddSchemaConfiguration(c =>
c.RegisterType <PaginationAmountType>())
.AddExecutionConfiguration(b =>
{
b.AddErrorFilter(error =>
{
if (error.Exception is Exception ex)
{
return(ErrorBuilder.FromError(error)
.ClearExtensions()
.SetMessage(ex.GetType().FullName)
.SetException(null)
.Build());
}
;
return(error);
});
}));
IServiceProvider services =
serviceCollection.BuildServiceProvider();
IQueryExecutor executor = services
.GetRequiredService <IQueryExecutor>();
IExecutionResult result = null;
using (IServiceScope scope = services.CreateScope())
{
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery(@"
mutation {
createCustomer(input: { name: ""a"" })
{
customer {
name
contracts {
id
}
}
}
}")
.SetServices(scope.ServiceProvider)
.Create();
result = await executor.ExecuteAsync(request);
}
var client = new HttpClient
{
BaseAddress = new Uri("http://127.0.0.1")
};;
connections["contract"] = client;
connections["customer"] = client;
// act
using (IServiceScope scope = services.CreateScope())
{
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery(@"
mutation {
createCustomer(input: { name: ""a"" })
{
customer {
name
contracts {
id
}
}
}
}")
.SetServices(scope.ServiceProvider)
.Create();
result = await executor.ExecuteAsync(request);
}
// assert
result.MatchSnapshot();
}
public async Task GetItems_ObjectEqualsFilter_FirstItems_Is_Returned()
{
// 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
{
Nested = null
},
new Model
{
Nested = new Model
{
Nested = new Model
{
Foo = "abc",
Bar = 1,
Baz = true
}
}
},
new Model
{
Nested = new Model
{
Nested = 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(where: { nested:{ nested: { foo: \"abc\" " +
"} } }) { nested { nested { foo } } } }")
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
// assert
result.MatchSnapshot();
}
public async ValueTask InvokeAsync(IRequestContext context)
{
IReadOnlyQueryRequest request = context.Request;
if (context.Document is null &&
context.Request.Query is { })
public async Task ExecuteStitchedQueryBuilderWithLocalSchema()
{
// arrange
IHttpClientFactory clientFactory = CreateRemoteSchemas();
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(clientFactory);
serviceCollection.AddStitchedSchema(builder =>
builder.AddSchemaFromHttp("contract")
.AddSchemaFromHttp("customer")
.AddSchema("hello",
Schema.Create(
"type Query { hello: String! }",
c => c.BindResolver(ctx => "Hello World")
.To("Query", "hello")))
.RenameField("customer",
new FieldReference("Customer", "name"), "foo")
.RenameType("SomeOtherContract", "Other")
.RenameType("LifeInsuranceContract", "Life")
.AddExtensionsFromString(
FileResource.Open("StitchingExtensions.graphql"))
.AddSchemaConfiguration(c =>
c.RegisterType <PaginationAmountType>()));
IServiceProvider services =
serviceCollection.BuildServiceProvider();
IQueryExecutor executor = services
.GetRequiredService <IQueryExecutor>();
IExecutionResult result = null;
// act
using (IServiceScope scope = services.CreateScope())
{
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery(@"
query a($id: ID!) {
a: customer2(customerId: $id) {
bar: foo
contracts {
id
... life
... on Other {
expiryDate
}
}
}
hello
}
fragment life on Life
{
premium
}
")
.SetVariableValue("id", "Q3VzdG9tZXIKZDE=")
.SetServices(scope.ServiceProvider)
.Create();
result = await executor.ExecuteAsync(request);
}
// assert
Snapshot.Match(result);
}
public async ValueTask <bool> MoveNextAsync()
{
if (_index >= _batch.Count)
{
Current = null;
return(false);
}
try
{
IReadOnlyQueryRequest request = _batch[_index++];
DocumentNode document = request.Query is QueryDocument d
? d.Document
: Utf8GraphQLParser.Parse(request.Query.ToSpan());
OperationDefinitionNode operation =
document.GetOperation(request.OperationName);
if (document != _previous)
{
_fragments = document.GetFragments();
_visitationMap.Initialize(_fragments);
}
operation.Accept(
_visitor,
_visitationMap,
n => VisitorAction.Continue);
_previous = document;
document = RewriteDocument(operation);
operation = (OperationDefinitionNode)document.Definitions[0];
IReadOnlyDictionary <string, object> variableValues =
MergeVariables(request.VariableValues, operation);
request = QueryRequestBuilder.From(request)
.SetQuery(document)
.SetVariableValues(variableValues)
.AddExportedVariables(_exportedVariables)
.SetQueryName(null) // TODO ... should we create a name here?
.SetQueryHash(null)
.Create();
Current =
(IReadOnlyQueryResult)await _executor.ExecuteAsync(
request, _cancellationToken)
.ConfigureAwait(false);
IsCompleted = false;
}
catch (QueryException ex)
{
IsCompleted = true;
Current = QueryResult.CreateError(ex.Errors);
}
catch (Exception ex)
{
IsCompleted = true;
Current = QueryResult.CreateError(
_errorHandler.Handle(
_errorHandler.CreateUnexpectedError(ex).Build()));
}
return(!IsCompleted);
}
private static async Task <IExecutionResult> OneRequest(
IQueryExecutor executer,
IReadOnlyQueryRequest request)
{
return(await executer.ExecuteAsync(request));
}
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.ArgumentValue <int>("newNumber"))
.To("Mutation", "changeTheNumber");
});
DocumentNode query = Utf8GraphQLParser.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 =
QueryRequestBuilder.New()
.SetQuery("{ a }")
.Create();
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,
(f, s) => f.Middleware
)
{
CachedQuery = new CachedQuery("{ a }", query),
Document = query,
QueryKey = "foo",
Operation = operation
};
var options = new QueryExecutionOptions();
var strategyResolver = new ExecutionStrategyResolver(options);
var diagnostics = new QueryExecutionDiagnostics(
new DiagnosticListener("Foo"),
new IDiagnosticObserver[0]);
var middleware = new ExecuteOperationMiddleware(
c => Task.CompletedTask,
strategyResolver,
new Cache <DirectiveMiddlewareCompiler>(10),
diagnostics);
// act
await middleware.InvokeAsync(context);
// assert
context.Result.MatchSnapshot();
}
public async Task Array_Filter_On_Scalar_Types()
{
// arrange
IServiceProvider services = new ServiceCollection()
.AddSingleton <IMongoCollection <Foo> >(sp =>
{
IMongoDatabase database = _mongoResource.CreateDatabase();
return(database.GetCollection <Foo>("col"));
})
.AddGraphQL()
.AddQueryType <QueryType>()
.BindRuntimeType <ObjectId, IdType>()
.Services
.BuildServiceProvider();
IRequestExecutor executor =
await services.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync();
IMongoCollection <Foo> collection = services.GetRequiredService <IMongoCollection <Foo> >();
await collection.InsertOneAsync(new Foo
{
BarCollection = new List <string> {
"a", "b", "c"
},
BazCollection = new List <Baz> {
new Baz {
Quux = "a"
}, new Baz {
Quux = "b"
}
},
Bars = new[] { "d", "e", "f" },
Bazs = new[] { new Baz {
Quux = "c"
}, new Baz {
Quux = "d"
} },
Quux = "abc"
});
ISchema schema = SchemaBuilder.New()
.AddQueryType <QueryType>()
.AddServices(services)
.BindClrType <ObjectId, IdType>()
.Create();
IReadOnlyQueryRequest request = QueryRequestBuilder.New()
.SetQuery(
"{" +
"foos(where: { bars_some: { element: \"e\" } }) { bars } " +
"}")
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
// assert
result.MatchSnapshot();
}
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 = Utf8GraphQLParser.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 =
QueryRequestBuilder.New()
.SetQuery("{ a }")
.Create();
var services = new DictionaryServiceProvider(
new KeyValuePair <Type, object>(
typeof(IErrorHandler),
ErrorHandler.Default));
var context = new QueryContext
(
schema,
services.CreateRequestServiceScope(),
request,
(f, s) => f.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.MatchSnapshot(
new SnapshotNameExtension("complexity", count));
}
}
public async Task AddMetadataQuery()
{
//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 <MetadataMutation>(d => d.Name("Mutation")));
c.RegisterType <List <MetadataType> >();
})
.MakeExecutable();
var input = new MetadataInput()
{
SensorID = 5,
Name = "Jasmine",
Number = "55T77",
Coordinate = "Moholt",
Altitude = 55,
LocationDescription = "samsy like always",
Company = "kundestyrt and co",
ServicePartner = "kundestyrt and co",
Department = "IDI",
OwnerID = "33333",
SerialNumber = "55yh3kk3-4443-455ddw2",
Tag1 = "nada",
Tag2 = "tag222222",
Tag3 = "im tagged boi",
Identificator = "nothing special here",
PurchaseDate = DateTime.Parse("2002-12-25T00:00:00.000Z"),
WarrantyDate = DateTime.Parse("2007-12-25T00:00:00.000Z"),
NextService = DateTime.Parse("2003-12-25T00:00:00.000Z"),
PlannedDisposal = DateTime.Parse("2022-12-25T00:00:00.000Z"),
ActualDisposal = DateTime.Parse("2022-12-25T00:00:00.000Z"),
ModelNumber = "jjhj445",
Picture = "Some picture link or svg?",
Signal = "Wireless",
MeasureArea = "550 550",
Website = "www.sanderkk.com",
InspectionRound = "same like the others",
Lending = true,
Timeless = false,
CheckOnInspectionRound = false,
Tollerance = true,
LendingPrice = 9000,
CableLength = 125,
Voltage = "24volt"
};
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery(@"mutation addMetadata($someMetadata : MetadataInput!)
{ addMetadata(newMetadata:$someMetadata)
{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
, outdatedFrom}}")
.SetServices(serviceProvider)
.AddVariableValue("someMetadata", input)
.Create();
// act
IExecutionResult result = await executor.ExecuteAsync(request);
//Assert
Snapshot.Match(result);
}
public Task <QueryResult> FetchAsync(
IReadOnlyQueryRequest request, HttpClient httpClient) =>
FetchAsync(CreateRemoteRequest(request), httpClient);
public Task <IExecutionResult> ExecuteAsync(
IReadOnlyQueryRequest request,
CancellationToken cancellationToken)
{
return(InnerExecutor.ExecuteAsync(request, cancellationToken));
}
