protected override Task<object> ProvideResult(HttpApiRequest request, HttpApiResponse response)
{
// Use JSON.NET to do the deserialization
var form = (FormHttpBody)response.Body;
var json = JToken.FromObject(form.Values);
return Task.FromResult(json.ToObject(ResponseType));
}
protected override async Task <object> ProvideResult(HttpApiRequest request, HttpApiResponse response)
{
var body = response.Body;
var byteArray = await body.AcceptAsync(new ByteArrayExtractor());
return(byteArray);
}
protected override Task <object> ProvideResult(HttpApiRequest request, HttpApiResponse response)
{
// Use JSON.NET to do the deserialization
var form = (FormHttpBody)response.Body;
var json = JToken.FromObject(form.Values);
return(Task.FromResult(json.ToObject(ResponseType)));
}
public async override Task ApplyArgument(HttpApiResponse response, string name, object argument)
{
var handler = (Func <Stream, Task>)argument;
var stream = ((StreamHttpBody)response.Body).Stream;
await handler(stream);
await base.ApplyArgument(response, name, argument);
}
protected override Task<object> ProvideResult(HttpApiRequest request, HttpApiResponse response)
{
var jsonBody = response.Body as JsonHttpBody;
if (jsonBody == null)
throw new Exception("Expected a JsonHttpBody in the response");
var result = TypeConverter.ConvertTo(TypeConversionContext.Body, ResponseType, jsonBody.Json);
return Task.FromResult(result);
}
private static bool IsProxyRequiredException(HttpRequestException e, out HttpApiResponse apiResponse)
{
if (e.InnerException is WebException webException && webException.Response is HttpWebResponse response &&
response.StatusCode == HttpStatusCode.ProxyAuthenticationRequired)
{
var responseHeaders = new List <HttpHeader>();
responseHeaders.AddRange(response.Headers.AllKeys.Select(x => new HttpHeader(x, response.Headers[x].Split(','))));
apiResponse = new HttpApiResponse(HttpStatusCode.ProxyAuthenticationRequired, headers: responseHeaders, responseUri: response.ResponseUri.ToString());
return(true);
}
protected override Task <object> ProvideResult(HttpApiRequest request, HttpApiResponse response)
{
var jsonBody = response.Body as JsonHttpBody;
if (jsonBody == null)
{
throw new Exception("Expected a JsonHttpBody in the response");
}
var result = TypeConverter.ConvertTo(TypeConversionContext.Body, ResponseType, jsonBody.Json);
return(Task.FromResult(result));
}
protected override Task<object> ProvideResult(HttpApiRequest request, HttpApiResponse response)
{
var contentType = response.Headers.SingleOrDefault(x => x.Name == "Content-Type")?.Values?.Single();
contentType = contentType ?? "application/json";
switch (contentType)
{
case "application/x-www-form-urlencoded":
return formHandler.HandleResponse(request, response);
case "text/plain":
return stringHandler.HandleResponse(request, response);
default:
return jsonHandler.HandleResponse(request, response);
}
}
protected override Task <object> ProvideResult(HttpApiRequest request, HttpApiResponse response)
{
switch (response.Body)
{
case JsonHttpBody _:
return(jsonHandler.HandleResponse(request, response));
case StringHttpBody _:
return(stringHandler.HandleResponse(request, response));
case FormHttpBody _:
return(formHandler.HandleResponse(request, response));
default:
return(Task.FromResult <object>(null));
}
}
private void SetupData(bool hasValidContent = true, HttpStatusCode statusCode = HttpStatusCode.OK)
{
var config = new AppSettings
{
UrlPath = statusCode == HttpStatusCode.OK ? "ValidURL" : "Invalid URL"
};
var response = new HttpApiResponse
{
StatusCode = statusCode,
Content = statusCode == HttpStatusCode.OK
? hasValidContent
? @"[ { ""name"": ""Bob"", ""gender"": ""Male"", ""age"": 23, ""pets"": [ { ""name"": ""Garfield"", ""type"": ""Cat"" }, { ""name"": ""Fido"", ""type"": ""Dog"" }] }]"
: @"{ ""name"": ""Bob"", ""gender"": ""Male"", ""pets"": [ { ""name"": ""Garfield"", ""type"": ""Cat"" }] }"
: null
};
var mockConfig = new Mock <IOptions <AppSettings> >();
mockConfig.Setup(c => c.Value)
.Returns(config);
_mockService = new Mock <IHttpClient>();
if (statusCode == HttpStatusCode.OK)
{
_mockService.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(response));
}
else
{
_mockService.Setup(x => x.GetAsync(It.IsAny <string>()))
.Throws <HttpRequestException>();
}
var mockLogger = new Mock <ILogger <ParseService> >();
_service = new ParseService(_mockService.Object, mockConfig.Object, mockLogger.Object);
}
protected override Task <object> ProvideResult(HttpApiRequest request, HttpApiResponse response)
{
return(Task.FromResult <object>(response));
}
public MockHttpHandler(HttpApiResponse response) : this(_ => response)
{
}
protected override Task<object> ProvideResult(HttpApiRequest request, HttpApiResponse response)
{
return Task.FromResult<object>(null);
}
protected override Task<object> ProvideResult(HttpApiRequest request, HttpApiResponse response)
{
return Task.FromResult<object>(((StringHttpBody)response.Body).Text);
}
protected override Task <object> ProvideResult(HttpApiRequest request, HttpApiResponse response)
{
return(Task.FromResult <object>(((StringHttpBody)response.Body).Text));
}
public MockHttpHandler(HttpApiResponse response)
: this(_ => response)
{
}
public Task <HttpHandlerResponse> Call(HttpApiRequest request)
{
var webRequest = WebRequest.CreateHttp(request.Url.ToString());
webRequest.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
webRequest.Method = request.Method.ToString();
if (request.Proxy != null)
{
webRequest.Proxy = request.Proxy;
}
foreach (var header in request.Headers)
{
switch (header.Name)
{
case "User-Agent":
webRequest.UserAgent = header.Values.Single();
break;
case "Accept":
webRequest.Accept = header.Values.Single();
break;
case "Content-Type":
webRequest.ContentType = header.Values.Single();
break;
default:
webRequest.Headers.Add(header.Name, string.Join(",", header.Values));
break;
}
}
var requestWriteTime = new Stopwatch();
requestWriteTime.Start();
if (request.Body != null)
{
var requestStream = webRequest.GetRequestStream();
var stream = request.Body.Accept(new ContentCreator());
stream.CopyTo(requestStream);
requestStream.Close();
}
else if (request.Method != HttpMethod.Get && request.Method != HttpMethod.Head)
{
var requestStream = webRequest.GetRequestStream();
requestStream.Close();
}
HttpWebResponse response;
try
{
response = (HttpWebResponse)webRequest.GetResponse();
}
catch (WebException e) when(e.Response != null)
{
response = (HttpWebResponse)e.Response;
}
requestWriteTime.Stop();
var responseHeaders = new List <HttpHeader>();
HttpBody responseBody = null;
responseHeaders.AddRange(response.Headers.AllKeys.Select(x => new HttpHeader(x, response.Headers[x].Split(','))));
var responseReadTime = new Stopwatch();
responseReadTime.Start();
var responseStream = response.GetResponseStream();
switch (request.ResponseContentTypeOverride ?? response.ContentType.Split(';')[0])
{
case "application/json":
var jsonString = Encoding.UTF8.GetString(responseStream.ReadToEnd());
var json = !string.IsNullOrEmpty(jsonString) ? JToken.Parse(jsonString) : null; // Hack to workaround silly servers that send a content type and a 204
if (json != null)
{
responseBody = new JsonHttpBody(json);
}
break;
case "application/x-www-form-urlencoded":
throw new NotSupportedException();
// var stream = await message.Content.ReadAsStreamAsync();
// body = FormParser.ParseForm(stream);
// break;
case "text/plain":
case "text/html":
case "":
var text = Encoding.UTF8.GetString(responseStream.ReadToEnd());
responseBody = new StringHttpBody(text);
break;
case "application/octet-stream":
var stream = new MemoryStream();
responseStream.CopyTo(stream);
stream.Position = 0;
responseBody = new StreamHttpBody(stream);
break;
}
responseStream.Close();
responseReadTime.Stop();
var result = new HttpApiResponse(response.StatusCode, responseBody, responseHeaders, response.ResponseUri.ToString());
return(Task.FromResult(new HttpHandlerResponse(result, requestWriteTime.Elapsed, responseReadTime.Elapsed)));
}
