public override void Assert(Scenario scenario, HttpContext context, ScenarioAssertionException ex)
{
var expectedResult = CreateQueryResult(_result);
// for Alba v4
// string actualResultJson = ex.ReadBody(context);
// for Alba v6 [ScenarioAssertionException.ReadBody internal]
context.Request.Body.Position = 0;
string actualResultJson = new StreamReader(context.Response.Body).ReadToEnd();
if (_ignoreExtensions)
{
expectedResult.Extensions = null;
var actualResult = actualResultJson.ToDictionary();
if (actualResult.ContainsKey(extensionsKey))
{
actualResult.Remove(extensionsKey);
}
actualResultJson = _writer.Serialize(actualResult);
}
string expectedResultJson = _writer.Serialize(expectedResult);
if (!actualResultJson.Equals(expectedResultJson))
{
ex.Add($"Expected '{expectedResultJson}' but got '{actualResultJson}'");
}
}
public static void ShouldBeSimilarTo(this object?actual, object?expected, string?customMessage = null)
{
if (expected is string str)
{
expected = _serializer.Deserialize <Inputs>(str);
}
var expectedJson = _serializer.Serialize(expected);
var actualJson = _serializer.Serialize(actual);
actualJson.ShouldBe(expectedJson, customMessage);
}
public async Task should_map(IGraphQLTextSerializer serializer)
{
var documentExecuter = new DocumentExecuter();
var executionResult = await documentExecuter.ExecuteAsync(_ =>
{
_.Schema = new Issue2275Schema();
_.Query = @"query($data:Input!) {
request(data: $data)
}";
_.Variables = serializer.Deserialize <Inputs>(@"{
""data"": {
""clientId"": 2,
""filters"": [{
""key"": ""o"",
""value"": 25
}]
}
}");
}).ConfigureAwait(false);
var json = serializer.Serialize(executionResult);
executionResult.Errors.ShouldBeNull();
json.ShouldBe(@"{
""data"": {
""request"": ""2: [o=25]""
}
}");
}
public void serialization_should_have_correct_case(IGraphQLTextSerializer writer)
{
var trace = new ApolloTrace(new DateTime(2019, 12, 05, 15, 38, 00, DateTimeKind.Utc), 102.5);
var expected = @"{
""version"": 1,
""startTime"": ""2019-12-05T15:38:00Z"",
""endTime"": ""2019-12-05T15:38:00.103Z"",
""duration"": 102500000,
""parsing"": {
""startOffset"": 0,
""duration"": 0
},
""validation"": {
""startOffset"": 0,
""duration"": 0
},
""execution"": {
""resolvers"": []
}
}";
var result = writer.Serialize(trace);
result.ShouldBeCrossPlat(expected);
}
public void Null(IGraphQLTextSerializer serializer)
{
var expected = "null";
var actual = serializer.Serialize <ExecutionError>(null);
actual.ShouldBeCrossPlatJson(expected);
}
public void Writes_OperationMessage_Nulls(IGraphQLTextSerializer serializer)
{
var message = new OperationMessage();
var actual = serializer.Serialize(message);
var expected = @"{}";
actual.ShouldBeCrossPlatJson(expected);
}
public static async Task <string> ExecuteAsync(this ISchema schema, Action <ExecutionOptions> configure)
{
var options = new ExecutionOptions {
Schema = schema
};
configure(options);
return(_serializer.Serialize(await _executer.ExecuteAsync(options).ConfigureAwait(false)));
}
public void Simple(IGraphQLTextSerializer serializer)
{
var error = new ExecutionError("some error 1");
var expected = @"{""message"": ""some error 1""}";
var actual = serializer.Serialize(error);
actual.ShouldBeCrossPlatJson(expected);
}
public void Array(IGraphQLTextSerializer serializer)
{
var errors = new ExecutionError[] { new ExecutionError("some error 1"), new ExecutionError("some error 2") };
var expected = @"[{""message"": ""some error 1""}, {""message"": ""some error 2""}]";
var actual = serializer.Serialize(errors);
actual.ShouldBeCrossPlatJson(expected);
}
public ExecutionResult AssertQuery(Action <ExecutionOptions> options, ExecutionResult expectedExecutionResult)
{
var runResult = Executer.ExecuteAsync(options).Result;
var writtenResult = Serializer.Serialize(runResult);
var expectedResult = Serializer.Serialize(expectedExecutionResult);
string additionalInfo = null;
if (runResult.Errors?.Any() == true)
{
additionalInfo = string.Join(Environment.NewLine, runResult.Errors
.Where(x => x.InnerException is GraphQLSyntaxErrorException)
.Select(x => x.InnerException.Message));
}
writtenResult.ShouldBeCrossPlat(expectedResult, additionalInfo);
return(runResult);
}
public async Task <string> ExecuteAsync(string query)
{
using var scope = _scopeFactory.CreateScope();
var result = await _executer.ExecuteAsync(new ExecutionOptions
{
Query = query,
RequestServices = scope.ServiceProvider,
}).ConfigureAwait(false);
return(_serializer.Serialize(result));
}
public void Writes_GraphQLRequest_Array_Correctly(IGraphQLTextSerializer serializer)
{
var request = new GraphQLRequest
{
Query = "hello",
};
var expected = @"[{ ""query"": ""hello"" }]";
var actual = serializer.Serialize(new GraphQLRequest[] { request });
actual.ShouldBeCrossPlatJson(expected);
}
public void Writes_GraphQLRequest_Correctly_Simple(IGraphQLTextSerializer serializer)
{
var request = new GraphQLRequest
{
Query = "hello",
};
var expected = @"{ ""query"": ""hello"" }";
var actual = serializer.Serialize(request);
actual.ShouldBeCrossPlatJson(expected);
}
public void Writes_Correct_Execution_Result_With_Null_Data_And_Null_Errors(IGraphQLTextSerializer serializer)
{
var executionResult = new ExecutionResult {
Executed = true
};
var expected = @"{
""data"": null
}";
var actual = serializer.Serialize(executionResult);
actual.ShouldBeCrossPlatJson(expected);
}
public async Task introspection_should_return_applied_directives(IGraphQLTextSerializer serializer)
{
var documentExecuter = new DocumentExecuter();
var executionResult = await documentExecuter.ExecuteAsync(_ =>
{
_.Schema = new AppliedSchema().EnableExperimentalIntrospectionFeatures(ExperimentalIntrospectionFeaturesMode.IntrospectionAndExecution);
_.Query = "AppliedDirectives".ReadGraphQLRequest();
}).ConfigureAwait(false);
var json = serializer.Serialize(executionResult);
executionResult.Errors.ShouldBeNull();
json.ShouldBe("AppliedDirectivesResult".ReadJsonResult());
}
/// <summary>
/// Executes a GraphQL request with the default <see cref="DocumentExecuter"/>, serializes the result using the specified <see cref="IGraphQLTextSerializer"/>, and returns the result
/// </summary>
/// <param name="schema">An instance of <see cref="ISchema"/> to use to execute the query</param>
/// <param name="serializer">An instance of <see cref="IGraphQLTextSerializer"/> to use to serialize the result</param>
/// <param name="configure">A delegate which configures the execution options</param>
public static async Task <string> ExecuteAsync(this ISchema schema, IGraphQLTextSerializer serializer, Action <ExecutionOptions> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
var executor = new DocumentExecuter();
var result = await executor.ExecuteAsync(options =>
{
options.Schema = schema;
configure(options);
}).ConfigureAwait(false);
return(serializer.Serialize(result));
}
public async Task validate_core_schema(IGraphQLTextSerializer serializer)
{
var documentExecuter = new DocumentExecuter();
var executionResult = await documentExecuter.ExecuteAsync(_ =>
{
_.Schema = new Schema
{
Query = new TestQuery()
};
_.Query = "IntrospectionQuery".ReadGraphQLRequest();
}).ConfigureAwait(false);
var json = serializer.Serialize(executionResult);
ShouldBe(json, "IntrospectionResult".ReadJsonResult());
}
public void Writes_Correct_Execution_Result_With_Null_Data_Errors_And_Extensions_When_Executed(IGraphQLTextSerializer serializer)
{
var executionResult = new ExecutionResult
{
Data = null,
Errors = new ExecutionErrors(),
Extensions = new Dictionary <string, object>(),
Executed = true
};
var expected = @"{ ""data"": null }";
var actual = serializer.Serialize(executionResult);
actual.ShouldBeCrossPlatJson(expected);
}
public void Writes_Correct_Execution_Result_With_Empty_Data_Errors_And_Extensions_When_Not_Executed(IGraphQLTextSerializer writer)
{
var executionResult = new ExecutionResult
{
Data = new Dictionary <string, object>().ToExecutionTree(),
Errors = new ExecutionErrors(),
Extensions = new Dictionary <string, object>(),
Executed = false
};
var expected = @"{ }";
var actual = writer.Serialize(executionResult);
actual.ShouldBeCrossPlatJson(expected);
}
public async Task validate_core_schema_pascal_case(IGraphQLTextSerializer serializer)
{
var documentExecuter = new DocumentExecuter();
var executionResult = await documentExecuter.ExecuteAsync(_ =>
{
_.Schema = new Schema
{
Query = new TestQuery(),
NameConverter = PascalCaseNameConverter.Instance,
};
_.Query = "IntrospectionQuery".ReadGraphQLRequest();
}).ConfigureAwait(false);
var json = serializer.Serialize(executionResult);
ShouldBe(json, "IntrospectionResult".ReadJsonResult().Replace("\"test\"", "\"Test\""));
}
public void Writes_GraphQLRequest_Correctly_SampleData(IGraphQLTextSerializer serializer)
{
var request = new GraphQLRequest
{
Query = "hello",
Variables = new Inputs(new Dictionary <string, object>
{
{ "arg", ExampleData },
}),
};
var expected = $"{{ \"query\": \"hello\", \"variables\": {{ \"arg\": {ExampleJson} }} }}";
var actual = serializer.Serialize(request);
actual.ShouldBeCrossPlatJson(expected);
}
public async Task <string> GenerateAsync()
{
var result = await _executor.ExecuteAsync(
new ExecutionOptions
{
Schema = _schema,
Query = _introspectionQuery
}
);
if (result.Errors?.Any() ?? false)
{
throw result.Errors.First();
}
return(_serializer.Serialize(result));
}
public async Task Synchronous_and_Async_Works_Same(IGraphQLTextSerializer serializer)
{
//ISSUE: manually created test instance with ServiceProvider
var builder = new MicrosoftDI.GraphQLBuilder(new ServiceCollection(), b => new StarWarsTestBase().RegisterServices(b.Services));
var schema = new GraphQL.StarWars.StarWarsSchema(builder.ServiceCollection.BuildServiceProvider());
var result = await new DocumentExecuter().ExecuteAsync(new ExecutionOptions
{
Schema = schema,
Query = "IntrospectionQuery".ReadGraphQLRequest()
}).ConfigureAwait(false);
var syncResult = serializer.Serialize(result);
var stream = new System.IO.MemoryStream();
await serializer.WriteAsync(stream, result).ConfigureAwait(false);
var asyncResult = System.Text.Encoding.UTF8.GetString(stream.ToArray());
syncResult.ShouldBe(asyncResult);
}
public async Task LongMaxValueShouldBeSerialized(IGraphQLTextSerializer serializer)
{
var documentExecuter = new DocumentExecuter();
var executionResult = await documentExecuter.ExecuteAsync(_ =>
{
_.Schema = new LongSchema();
_.Query = "{ testField }";
}).ConfigureAwait(false);
var json = serializer.Serialize(executionResult);
executionResult.Errors.ShouldBeNull();
json.ShouldBe(@"{
""data"": {
""testField"": 9223372036854775807
}
}");
}
public void Can_Write_Execution_Result(IGraphQLTextSerializer serializer)
{
var executionResult = new ExecutionResult
{
Executed = true,
Data = @"{ ""someType"": { ""someProperty"": ""someValue"" } }".ToDictionary().ToExecutionTree(),
Errors = new ExecutionErrors
{
new ExecutionError("some error 1"),
new ExecutionError("some error 2"),
},
Extensions = new Dictionary <string, object>
{
{ "someExtension", new { someProperty = "someValue", someOtherPropery = 1 } }
}
};
var expected = @"{
""errors"": [
{
""message"": ""some error 1""
},
{
""message"": ""some error 2""
}
],
""data"": {
""someType"": {
""someProperty"": ""someValue""
}
},
""extensions"": {
""someExtension"": {
""someProperty"": ""someValue"",
""someOtherPropery"": 1
}
}
}";
var actual = serializer.Serialize(executionResult);
actual.ShouldBeCrossPlatJson(expected);
}
public void Writes_OperationMessage_Populated(IGraphQLTextSerializer serializer)
{
var message = new OperationMessage
{
Id = "hello",
Type = "hello2",
Payload = new GraphQLRequest
{
Query = "hello3",
Variables = new Inputs(new Dictionary <string, object> {
{ "arg", ExampleData },
}),
}
};
var actual = serializer.Serialize(message);
var expected = $"{{\"type\":\"hello2\",\"id\":\"hello\",\"payload\":{{\"query\":\"hello3\",\"variables\":{{\"arg\":{ExampleJson}}}}}}}";
actual.ShouldBeCrossPlatJson(expected);
}
public void Writes_Path_Property_Correctly(IGraphQLTextSerializer serializer)
{
var executionResult = new ExecutionResult
{
Data = null,
Errors = new ExecutionErrors(),
Extensions = null,
};
var executionError = new ExecutionError("Error testing index")
{
Path = new object[] { "parent", 23, "child" }
};
executionResult.Errors.Add(executionError);
var expected = @"{ ""errors"": [{ ""message"": ""Error testing index"", ""path"": [ ""parent"", 23, ""child"" ] }] }";
var actual = serializer.Serialize(executionResult);
actual.ShouldBeCrossPlatJson(expected);
}
public void Writes_Correct_Execution_Result_With_Null_Data_And_Some_Errors(IGraphQLTextSerializer serializer)
{
// "If an error was encountered before execution begins, the data entry should not be present in the result."
// Source: https://github.com/graphql/graphql-spec/blob/master/spec/Section%207%20--%20Response.md#data
var executionResult = new ExecutionResult
{
Errors = new ExecutionErrors
{
new ExecutionError("some error 1"),
new ExecutionError("some error 2"),
}
};
var expected = @"{
""errors"": [{""message"":""some error 1""},{""message"":""some error 2""}]
}";
var actual = serializer.Serialize(executionResult);
actual.ShouldBeCrossPlatJson(expected);
}
public void Writes_GraphQLRequest_Correctly_Complex(IGraphQLTextSerializer serializer)
{
var request = new GraphQLRequest
{
Query = "hello",
OperationName = "opname",
Variables = new Inputs(new Dictionary <string, object>
{
{ "arg1", 1 },
{ "arg2", "test" },
}),
Extensions = new Inputs(new Dictionary <string, object>
{
{ "arg1", 2 },
{ "arg2", "test2" },
}),
};
var expected = @"{ ""query"": ""hello"", ""operationName"": ""opname"", ""variables"": { ""arg1"": 1, ""arg2"": ""test"" }, ""extensions"": { ""arg1"": 2, ""arg2"": ""test2"" } }";
var actual = serializer.Serialize(request);
actual.ShouldBeCrossPlatJson(expected);
}
public string Serialize(ExecutionResult result) => _serializer.Serialize(result);
