public void Select_ToList()
{
var expression = new RootQuery()
.Data
.Select(x => new
{
x.Id,
Items = x.Items.Select(i => i.Name).ToList(),
});
var data = @"{
""data"":{
""data"": {
""id"": ""foo"",
""items"": [
{ ""name"": ""item1"" },
{ ""name"": ""item2"" }
]
}
}
}";
var foo = JObject.Parse(data);
var query = new QueryBuilder().Build(expression);
var result = new ResponseDeserializer().Deserialize(query, data).Single();
Assert.Equal("foo", result.Id);
Assert.Equal(new[] { "item1", "item2" }, result.Items);
}
public void DeserializeSuccessfulListTollFreeResponse()
{
var fakeResponse = @"<?xml version=""1.0"" encoding=""UTF-8""?>
<content>
<status>ok</status>
<numbers>
<did>5555555555</did>
<did>6666666666</did>
<did>7777777777</did>
</numbers>
</content>";
var expected = new ListTollFreeResponse
{
Status = "ok",
Numbers = new List <string>
{
"5555555555", "6666666666", "7777777777"
}
};
var sut = new ResponseDeserializer();
var actual = sut.DeserializeListTollFreeResponse(fakeResponse);
Assert.NotNull(actual.Numbers);
expected.Numbers.Sort();
actual.Numbers.Sort();
Assert.IsType(typeof(ListTollFreeResponse), actual);
Assert.Equal(expected.Status, actual.Status);
Assert.True(expected.Numbers.SequenceEqual(actual.Numbers));
}
public ResponseDeserializerTests()
{
_deserializer = new ResponseDeserializer(_resourceGraph);
_linkValues.Add("self", "http://example.com/articles");
_linkValues.Add("next", "http://example.com/articles?page[offset]=2");
_linkValues.Add("last", "http://example.com/articles?page[offset]=10");
}
public void Should_not_parse_wrong_xml()
{
var response = new Response(HttpStatusCode.OK, XmlContentType(), XmlWrongDtoResponseText);
var deserializer = new ResponseDeserializer();
Assert.Throws<UnexpectedXmlContentException>(() => deserializer.DeserializeResponse<Status>(response, false));
}
public ReplicaResponseDeserializer(
IReplicator replicator,
ResponseDeserializer innerDeserializer)
{
Replicator = replicator;
InnerDeserializer = innerDeserializer;
}
public ResponseDeserializerTests()
{
_deserializer = new ResponseDeserializer(_resourceGraph, new ResourceFactory(new ServiceContainer()));
_linkValues.Add("self", "http://example.com/articles");
_linkValues.Add("next", "http://example.com/articles?page[number]=2");
_linkValues.Add("last", "http://example.com/articles?page[number]=10");
}
/// <summary>
/// Gets a RestEase client
/// </summary>
/// <param name="rootUrl">Root URL on which to base client requests</param>
/// <param name="responseDeserializer">Optional response deserializer implementation</param>
/// <param name="requestModifier">Optional delegate called on every request</param>
/// <typeparam name="TClient">Type of the RestEase-decorated interface</typeparam>
/// <returns>Instance of the requested RestEase client</returns>
public static TClient GetRestClient <TClient>(
string rootUrl,
ResponseDeserializer responseDeserializer = null,
RequestModifier requestModifier = null)
{
return((TClient)typeof(TClient).GetRestClient(rootUrl, responseDeserializer, requestModifier));
}
public void ShouldCheckConstructorParameters()
{
ResponseDeserializer deserializer;
deserializer = new ResponseDeserializer();
Assert.ThrowsException <ArgumentNullException>(() => deserializer.Deserialize <string>(null));
}
public void NestedQuery_Select_Multiple_Members_To_Named_Class()
{
var expression = new RootQuery()
.Nested("foo")
.Simple("bar")
.Select(x => new NamedClass
{
Name = x.Name,
Description = x.Description,
});
var data = @"{
""data"":{
""nested"": {
""simple"":{
""name"": ""Hello World!"",
""description"": ""Goodbye cruel world""
}
}
}
}";
var query = new QueryBuilder().Build(expression);
var expectedType = expression.GetType().GetGenericArguments()[0];
var result = new ResponseDeserializer().Deserialize(query, data).Single();
Assert.IsType(expectedType, result);
Assert.Equal("Hello World!", result.Name);
Assert.Equal("Goodbye cruel world", result.Description);
}
public void ThenItShouldThrowExceptionIfResponseIsNotXml(string faultCode, string faultString)
{
var deserializer = new ResponseDeserializer();
var response = "no-xml-in-here";
Assert.Throws <ArgumentException>(() => deserializer.DeserializeResponse(response));
}
public void RepositoryOwner_Repository_Append_From_Different_Entities()
{
var expression = new Query()
.RepositoryOwner("foo")
.Repository("bar")
.Select(x => new
{
Owner = x.Owner.Select(o => new
{
Thing = x.Name + ": " + o.Login,
}),
});
string data = @"{
""data"": {
""repositoryOwner"": {
""repository"": {
""name"": ""Octokit.GraphQL.Core"",
""owner"": {
""login"": ""grokys""
},
}
}
}
}";
var query = new QueryBuilder().Build(expression);
var result = new ResponseDeserializer().Deserialize(query, data).Single();
Assert.Equal("Octokit.GraphQL.Core: grokys", Enumerable.Single(result.Owner).Thing);
}
public void Union()
{
var expression = new RootQuery()
.Union
.Select(x => x.Simple)
.Select(x => new
{
x.Name,
x.Description,
});
var data = @"{
""data"":{
""union"": [
{
""__typename"": ""Simple"",
""name"": ""foo"",
""description"": ""bar""
},
{
""__typename"": ""Another"",
}
]
}
}";
var foo = JObject.Parse(data);
var query = new QueryBuilder().Build(expression);
var result = new ResponseDeserializer().Deserialize(query, data).Single();
Assert.Equal("foo", result.Name);
Assert.Equal("bar", result.Description);
}
public void Select_ToDictionary()
{
var expression = new RootQuery()
.Data
.Select(x => new
{
x.Id,
Items = x.Items.Select(i => new
{
i.Name,
i.Description,
}).ToDictionary(d => d.Name, d => d.Description),
});
var data = @"{
""data"":{
""data"": {
""id"": ""foo"",
""items"": [
{ ""name"": ""item1"", ""description"": ""foo"" },
{ ""name"": ""item2"", ""description"": ""bar"" }
]
}
}
}";
var foo = JObject.Parse(data);
var query = new QueryBuilder().Build(expression);
var result = new ResponseDeserializer().Deserialize(query, data).Single();
Assert.Equal("foo", result.Id);
Assert.Equal(new[] { "item1", "item2" }, result.Items.Keys);
Assert.Equal(new[] { "foo", "bar" }, result.Items.Values);
}
public void should_throw_exception_when_deserialize_into_wrong_type()
{
var deserializer = new ResponseDeserializer();
var response = new Response(HttpStatusCode.OK, XmlContentType(), TestObjectXmlResponse);
Assert.Throws <UnexpectedXmlContentException>(() => deserializer.DeserializeResponse <Status>(response, true));
}
public void Should_not_parse_json_identified_as_xml()
{
var response = new Response(HttpStatusCode.OK, XmlContentType(), JsonResponseText);
var deserializer = new ResponseDeserializer();
Assert.Throws <NonXmlContentException>(() => deserializer.DeserializeResponse <Status>(response, false));
}
public void Should_not_parse_xml_identified_as_json()
{
var response = new Response(HttpStatusCode.OK, JsonContentType(), XmlResponseText);
var deserializer = new ResponseDeserializer();
Assert.Throws <JsonParseFailedException>(() => deserializer.DeserializeResponse <Status>(response, false));
}
public void ProviderDeserializationTestWithMissingPropertiesJson()
{
var response = "{\"type\": \"video\",\"html\": \"TestHtml\"}";
var actual = ResponseDeserializer.DeserializeResponse(response);
Assert.True(MissingPropertiesObject.Equals(actual));
}
public async Task <bool> RunPage()
{
var deserializer = new ResponseDeserializer();
var data = await connection.Run(parent.GetPayload(variables));
Result = deserializer.Deserialize(parent.ResultBuilder, data);
return(false);
}
/// <inheritdoc />
public async Task <bool> RunPage(CancellationToken cancellationToken = default)
{
var deserializer = new ResponseDeserializer();
var data = await connection.Run(parent.GetPayload(variables), cancellationToken).ConfigureAwait(false);
Result = deserializer.Deserialize(parent.ResultBuilder, data);
return(false);
}
public void Should_not_parse_xml_identified_as_json()
{
var response = new Response(HttpStatusCode.OK, JsonContentType(), XmlResponseText);
var deserializer = new ResponseDeserializer();
Assert.Throws<JsonParseFailedException>(() => deserializer.DeserializeResponse<Status>(response, false));
}
public void Should_not_parse_wrong_xml()
{
var response = new Response(HttpStatusCode.OK, XmlContentType(), XmlWrongDtoResponseText);
var deserializer = new ResponseDeserializer();
Assert.Throws <UnexpectedXmlContentException>(() => deserializer.DeserializeResponse <Status>(response, false));
}
public void Should_not_parse_json_identified_as_xml()
{
var response = new Response(HttpStatusCode.OK, XmlContentType(), JsonResponseText);
var deserializer = new ResponseDeserializer();
Assert.Throws<NonXmlContentException>(() => deserializer.DeserializeResponse<Status>(response, false));
}
public void should_throw_exception_when_deserialize_into_wrong_type_such_as_one_that_is_not_wrapped_in_a_response_tag()
{
var deserializer = new ResponseDeserializer();
var wrongTag = TestObjectXmlResponse.Replace("response", "rexponse");
var response = new Response(HttpStatusCode.OK, XmlContentType(), wrongTag);
Assert.Throws <UnexpectedXmlContentException>(() => deserializer.DeserializeResponse <Status>(response, true));
}
public async Task <RestResponse <T> > GetAsync <T>(string route, CancellationToken cancelToken)
{
var rawResponse = await _client.GetAsync(route, cancelToken);
var response = await ResponseDeserializer.DeserializeAsync <T>(rawResponse);
return(response);
}
public void ProviderDeserializationTestWithAdditionalPropertiesJson()
{
var response = "{\"type\": \"video\", \"title\": \"TestTitle\", \"thumbnail_url\": \"TestThumbnailUrl\", \"additional\": \"Test\"," +
"\"thumbnail_width\": 640, \"thumbnail_height\": 480, \"html\": \"TestHtml\", \"width\": 800, \"height\": 600}";
var actual = ResponseDeserializer.DeserializeResponse(response);
Assert.True(FullObject.Equals(actual));
}
public void Should_parse_json()
{
var response = new Response(HttpStatusCode.OK, JsonContentType(), JsonResponseText);
var deserializer = new ResponseDeserializer();
var status = deserializer.DeserializeResponse <Status>(response, false);
Assert.That(status, Is.Not.Null);
}
public void Should_parse_xml()
{
var response = new Response(HttpStatusCode.OK, XmlContentType(), XmlResponseText);
var deserializer = new ResponseDeserializer();
var status = deserializer.ResponseAs <Status>(response);
Assert.That(status, Is.Not.Null);
}
public void should_deserialize_Empty_xml_to_empty_object()
{
var deserializer = new ResponseDeserializer();
var response = new Response(HttpStatusCode.OK, XmlContentType(), EmptyXmlResponse);
var testObject = deserializer.DeserializeResponse <TestEmptyObject>(response, true);
Assert.That(testObject, Is.Not.Null);
}
public async Task <RestResponse <TResponse> > PostAsync <TRequest, TResponse>(string route, TRequest body, CancellationToken cancelToken)
{
var requestContent = ContentEncoder.Encode(body);
var rawResponse = await _client.PostAsync(route, requestContent, cancelToken);
var response = await ResponseDeserializer.DeserializeAsync <TResponse>(rawResponse);
return(response);
}
public void ThenItShouldThrowExceptionIfResponseIsNotSoapResponse(string faultCode, string faultString)
{
var deserializer = new ResponseDeserializer();
var response = "<nosoap>just xml</nosoap>";
var actual = Assert.Throws <SoapException>(() => deserializer.DeserializeResponse(response));
Assert.AreEqual("Response XML does not appear to be a valid SOAP response", actual.Message);
}
public void Should_parse_json()
{
var response = new Response(HttpStatusCode.OK, JsonContentType(), JsonResponseText);
var deserializer = new ResponseDeserializer();
var status = deserializer.DeserializeResponse<Status>(response, false);
Assert.That(status, Is.Not.Null);
}
public void ThenItShouldThrowSoapExceptionIfResponseIsFault(string faultCode, string faultString)
{
var deserializer = new ResponseDeserializer();
var response = GetFaultResponse(faultCode, faultString);
var actual = Assert.Throws <SoapException>(() => deserializer.DeserializeResponse(response));
Assert.AreEqual(faultCode, actual.FaultCode);
Assert.AreEqual(faultString, actual.FaultString);
}
private Sender()
{
this.receiver = new ConfigurationMessageReceiver();
ResponseDeserializer parser = new ResponseDeserializer();
this.receiver.HandleMessage += parser.HandleEvent;
IMulticastSender sender = new ConfigurationMulticastSender(new ScanInterfaces().NetworkInterfaces);
this.service = new ConfigurationService(parser, sender);
}
public void can_deseralize_card_types()
{
var xmlSerializer = new ResponseDeserializer<PaymentCardTypes>();
var result = xmlSerializer.Deserialize(stubResponse);
Assert.That(result.CardTypes.Count(),Is.EqualTo(4));
var lastCard = result.CardTypes.Last();
Assert.That(lastCard.Type, Is.EqualTo("American Express"));
Assert.That(lastCard.Id, Is.EqualTo("AMEX"));
}
/// <summary>
/// Gets a RestEase client
/// </summary>
/// <param name="type">Type of the RestEase-decorated interface</param>
/// <param name="rootUrl">Root URL on which to base client requests</param>
/// <param name="responseDeserializer">Optional response deserializer implementation</param>
/// <param name="requestModifier">Optional delegate called on every request</param>
/// <returns>Instance of the requested RestEase client</returns>
public static object GetRestClient(
this Type type,
string rootUrl,
ResponseDeserializer responseDeserializer = null,
RequestModifier requestModifier = null)
{
return(new RestClient(rootUrl, requestModifier ?? NoopRequestModifier)
{
ResponseDeserializer = responseDeserializer ?? new BaseJsonResponseDeserializer(),
}.For(type));
}
public void should_deserialize_emtpy_release_type_to_unknown()
{
var responseXml = File.ReadAllText("StubResponses/ArtistReleases.xml");
var response = new Response
{
StatusCode = HttpStatusCode.OK,
Body = responseXml
};
var xmlSerializer = new ResponseDeserializer<ArtistReleases>();
var release = xmlSerializer.Deserialize(response).Releases.First();
Assert.That(release.Type,Is.EqualTo(ReleaseType.Unknown));
}
public void Can_Deserialise_ok_response_without_body__as_DeleteCard()
{
const string ResponseXml = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?><response status=\"ok\" version=\"1.2\" />";
var response = new Response
{
StatusCode = HttpStatusCode.OK,
Body = ResponseXml
};
var xmlSerializer = new ResponseDeserializer<DeleteCard>();
var result = xmlSerializer.Deserialize(response);
Assert.That(result, Is.Not.Null);
}
public void should_deserialize_well_formed_xml()
{
var deserializer = new ResponseDeserializer();
var response = new Response(HttpStatusCode.OK, XmlContentType(), TestObjectXmlResponse);
var testObject = deserializer.DeserializeResponse<TestObject>(response, true);
Assert.That(testObject, Is.Not.Null);
Assert.That(testObject.Id, Is.EqualTo(1));
Assert.That(testObject.Name, Is.EqualTo("A big test object"));
Assert.That(testObject.StringList, Is.Not.Null);
Assert.That(testObject.StringList.Count, Is.GreaterThan(0));
Assert.That(testObject.ObjectList, Is.Not.Null);
Assert.That(testObject.ObjectList.Count, Is.GreaterThan(0));
}
public void Can_deserialize_object()
{
//success case with well formed response
const string xml = "<?xml version=\"1.0\"?><response xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" status=\"ok\"><testObject id=\"1\"> <name>A big test object</name><listOfThings><string>one</string><string>two</string><string>three</string></listOfThings><listOfInnerObjects><InnerObject id=\"1\"><Name>Trevor</Name></InnerObject><InnerObject id=\"2\"><Name>Bill</Name></InnerObject></listOfInnerObjects></testObject></response>";
var stubResponse = new Response
{
StatusCode = HttpStatusCode.OK,
Body = xml
};
var xmlSerializer = new ResponseDeserializer<TestObject>();
Assert.DoesNotThrow(() => xmlSerializer.Deserialize(stubResponse));
TestObject testObject = xmlSerializer.Deserialize(stubResponse);
Assert.That(testObject.Id, Is.EqualTo(1));
}
public void Can_deserialize_well_formed_error()
{
const string errorXml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?><response status=\"error\" version=\"1.2\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://api.7digital.com/1.2/static/7digitalAPI.xsd\" ><error code=\"1001\"><errorMessage>Test error</errorMessage></error></response>";
var response = new Response
{
StatusCode = HttpStatusCode.OK,
Body = errorXml
};
var xmlSerializer = new ResponseDeserializer<TestObject>();
var ex = Assert.Throws<ApiXmlException>(() => xmlSerializer.Deserialize(response));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
Assert.That(ex.Message, Is.StringStarting("Error response"));
Assert.That(ex.Message, Is.StringEnding(errorXml));
Assert.That(ex.Error.Code, Is.EqualTo(1001));
Assert.That(ex.Error.ErrorMessage, Is.EqualTo("Test error"));
}
public void Should_throw_api_exception_with_null()
{
var apiXmlDeSerializer = new ResponseDeserializer<Status>();
var apiException = Assert.Throws<ApiXmlException>(() => apiXmlDeSerializer.Deserialize(null));
Assert.That(apiException.Message, Is.EqualTo("No response"));
}
public void Error_captures_http_status_code_from_html()
{
const string badXml = "<html><head>Error</head><body>It did not work<br><hr></body></html>";
var response = new Response
{
StatusCode = HttpStatusCode.InternalServerError,
Body = badXml
};
var xmlSerializer = new ResponseDeserializer<TestObject>();
var ex = Assert.Throws<ApiXmlException>(() => xmlSerializer.Deserialize(response));
Assert.That(ex, Is.Not.Null);
Assert.That(ex.Message, Is.StringStarting("Server error:"));
Assert.That(ex.Message, Is.StringEnding(badXml));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
}
public void Should_handle_plaintext_OauthFail()
{
var response = new Response
{
StatusCode = HttpStatusCode.Unauthorized,
Body = "OAuth authentication error: Not authorised - no user credentials provided"
};
var xmlSerializer = new ResponseDeserializer<TestObject>();
var ex = Assert.Throws<ApiXmlException>(() => xmlSerializer.Deserialize(response));
Assert.That(ex, Is.Not.Null);
Assert.That(ex.Message, Is.StringStarting("Error response"));
Assert.That(ex.Message, Is.StringEnding(response.Body));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
Assert.That(ex.Error.Code, Is.EqualTo(9001));
Assert.That(ex.Error.ErrorMessage, Is.EqualTo(response.Body));
}
public void should_throw_exception_when_deserialize_with_missing_status()
{
const string MissingStatusXmlResponse = "<?xml version=\"1.0\"?><response version=\"1.2\"></response>";
var response = new Response
{
StatusCode = HttpStatusCode.OK,
Body = MissingStatusXmlResponse
};
var deserializer = new ResponseDeserializer<TestEmptyObject>();
var ex = Assert.Throws<ApiXmlException>(() => deserializer.Deserialize(response));
Assert.That(ex, Is.Not.Null);
Assert.That(ex.Message, Is.StringStarting("No valid status found in response."));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
}
public void should_deserialize_Empty_xml_to_empty_object()
{
var deserializer = new ResponseDeserializer();
var response = new Response(HttpStatusCode.OK, XmlContentType(), EmptyXmlResponse);
var testObject = deserializer.DeserializeResponse<TestEmptyObject>(response, true);
Assert.That(testObject, Is.Not.Null);
}
public void should_throw_exception_when_deserialize_into_wrong_type()
{
var deserializer = new ResponseDeserializer();
var response = new Response(HttpStatusCode.OK, XmlContentType(), TestObjectXmlResponse);
Assert.Throws<UnexpectedXmlContentException>(() => deserializer.DeserializeResponse<Status>(response, true));
}
public void should_throw_exception_when_deserialize_into_wrong_type_such_as_one_that_is_not_wrapped_in_a_response_tag()
{
var deserializer = new ResponseDeserializer();
var wrongTag = TestObjectXmlResponse.Replace("response", "rexponse");
var response = new Response(HttpStatusCode.OK, XmlContentType(), wrongTag);
Assert.Throws<UnexpectedXmlContentException>(() => deserializer.DeserializeResponse<Status>(response, true));
}
public void turns_html_ok_response_into_error()
{
const string badXml = "<html><head>Error</head><body>Some random html page<br><hr></body></html>";
var response = new Response
{
StatusCode = HttpStatusCode.OK,
Body = badXml
};
var xmlSerializer = new ResponseDeserializer<TestObject>();
var ex = Assert.Throws<ApiXmlException>(() => xmlSerializer.Deserialize(response));
Assert.That(ex, Is.Not.Null);
Assert.That(ex.Message, Is.StringStarting("Error trying to deserialize xml response"));
Assert.That(ex.Message, Is.StringEnding(badXml));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
}
public void Should_not_fail_if_xml_is_missing_error_code()
{
const string validXml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?><response status=\"error\" version=\"1.2\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://api.7digital.com/1.2/static/7digitalAPI.xsd\" ><error><errorMessage>An error</errorMessage></error></response>";
var response = new Response
{
StatusCode = HttpStatusCode.OK,
Body = validXml
};
var xmlSerializer = new ResponseDeserializer<TestObject>();
var ex = Assert.Throws<ApiXmlException>(() => xmlSerializer.Deserialize(response));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
Assert.That(ex.Error.ErrorMessage, Is.StringStarting("XML error parse failed"));
}
