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")); }