From 74a7f5d2701c93dc69669d20491e623aa4316cdf Mon Sep 17 00:00:00 2001 From: "tom.pallister" Date: Thu, 6 Oct 2016 21:18:12 +0100 Subject: [PATCH] ripping out flurl...sorry flurl --- .../HttpClient/HttpClientWrapper.cs | 210 ++++++++++++++++++ .../Infrastructure/HttpClient/IHttpClient.cs | 49 ++++ .../RequestBuilder/IRequestBuilder.cs | 17 ++ .../RequestBuilder/RequestBuilder.cs | 49 ++++ .../Requester/HttpClientHttpRequester.cs | 53 +---- .../Requester/IHttpRequester.cs | 14 +- .../Middleware/HttpRequesterMiddleware.cs | 14 +- src/Ocelot.Library/project.json | 5 +- src/Ocelot/Startup.cs | 6 + .../Configuration/Requester/RequesterTests.cs | 82 ++++--- 10 files changed, 406 insertions(+), 93 deletions(-) create mode 100644 src/Ocelot.Library/Infrastructure/HttpClient/HttpClientWrapper.cs create mode 100644 src/Ocelot.Library/Infrastructure/HttpClient/IHttpClient.cs create mode 100644 src/Ocelot.Library/Infrastructure/RequestBuilder/IRequestBuilder.cs create mode 100644 src/Ocelot.Library/Infrastructure/RequestBuilder/RequestBuilder.cs diff --git a/src/Ocelot.Library/Infrastructure/HttpClient/HttpClientWrapper.cs b/src/Ocelot.Library/Infrastructure/HttpClient/HttpClientWrapper.cs new file mode 100644 index 00000000..9a08eb1c --- /dev/null +++ b/src/Ocelot.Library/Infrastructure/HttpClient/HttpClientWrapper.cs @@ -0,0 +1,210 @@ +namespace Ocelot.Library.Infrastructure.HttpClient +{ + using System; + using System.IO; + using System.Net.Http; + using System.Net.Http.Headers; + using System.Threading; + using System.Threading.Tasks; + + public class HttpClientWrapper : IHttpClient + { + private readonly HttpClient _httpClient; + + public HttpClientWrapper(HttpClient httpClient) + { + _httpClient = httpClient; + } + + public void Dispose() + { + _httpClient.Dispose(); + } + + public Uri BaseAddress + { + get { return _httpClient.BaseAddress; } + set { _httpClient.BaseAddress = value; } + } + + public HttpRequestHeaders DefaultRequestHeaders + { + get { return _httpClient.DefaultRequestHeaders; } + } + + public long MaxResponseContentBufferSize + { + get { return _httpClient.MaxResponseContentBufferSize; } + set { _httpClient.MaxResponseContentBufferSize = value; } + } + + public TimeSpan Timeout + { + get { return _httpClient.Timeout; } + set { _httpClient.Timeout = value; } + } + + public void CancelPendingRequests() + { + _httpClient.CancelPendingRequests(); + } + + public async Task DeleteAsync(string requestUri) + { + return await _httpClient.DeleteAsync(requestUri); + } + + public async Task DeleteAsync(Uri requestUri) + { + return await _httpClient.DeleteAsync(requestUri); + } + + public async Task DeleteAsync(Uri requestUri, CancellationToken cancellationToken) + { + return await _httpClient.DeleteAsync(requestUri, cancellationToken); + } + + public async Task DeleteAsync(string requestUri, CancellationToken cancellationToken) + { + return await _httpClient.DeleteAsync(requestUri, cancellationToken); + } + + public async Task GetAsync(string requestUri) + { + return await _httpClient.GetAsync(requestUri); + } + + public async Task GetAsync(Uri requestUri) + { + return await _httpClient.GetAsync(requestUri); + } + + public async Task GetAsync(string requestUri, HttpCompletionOption completionOption) + { + return await _httpClient.GetAsync(requestUri, completionOption); + } + + public async Task GetAsync(string requestUri, CancellationToken cancellationToken) + { + return await _httpClient.GetAsync(requestUri, cancellationToken); + } + + public async Task GetAsync(Uri requestUri, HttpCompletionOption completionOption) + { + return await _httpClient.GetAsync(requestUri, completionOption); + } + + public async Task GetAsync(Uri requestUri, CancellationToken cancellationToken) + { + return await _httpClient.GetAsync(requestUri, cancellationToken); + } + + public async Task GetAsync(string requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken) + { + return await _httpClient.GetAsync(requestUri, completionOption, cancellationToken); + } + + public async Task GetAsync(Uri requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken) + { + return await _httpClient.GetAsync(requestUri, completionOption, cancellationToken); + } + + public async Task GetByteArrayAsync(string requestUri) + { + return await _httpClient.GetByteArrayAsync(requestUri); + } + + public async Task GetByteArrayAsync(Uri requestUri) + { + return await _httpClient.GetByteArrayAsync(requestUri); + } + + public async Task GetStreamAsync(string requestUri) + { + return await _httpClient.GetStreamAsync(requestUri); + } + + public async Task GetStreamAsync(Uri requestUri) + { + return await _httpClient.GetStreamAsync(requestUri); + } + + public async Task GetStringAsync(string requestUri) + { + return await _httpClient.GetStringAsync(requestUri); + } + + public async Task GetStringAsync(Uri requestUri) + { + return await _httpClient.GetStringAsync(requestUri); + } + + public async Task PostAsync(string requestUri, HttpContent content) + { + return await _httpClient.PostAsync(requestUri, content); + } + + public async Task PostAsync(Uri requestUri, HttpContent content) + { + return await _httpClient.PostAsync(requestUri, content); + } + + public async Task PostAsync(string requestUri, HttpContent content, CancellationToken cancellationToken) + { + return await _httpClient.PostAsync(requestUri, content, cancellationToken); + } + + public async Task PostAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken) + { + return await _httpClient.PostAsync(requestUri, content, cancellationToken); + } + + public async Task PutAsync(string requestUri, HttpContent content) + { + return await _httpClient.PutAsync(requestUri, content); + } + + public async Task PutAsync(Uri requestUri, HttpContent content) + { + return await _httpClient.PutAsync(requestUri, content); + } + + public async Task PutAsync(string requestUri, HttpContent content, CancellationToken cancellationToken) + { + return await _httpClient.PutAsync(requestUri, content, cancellationToken); + } + + public async Task PutAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken) + { + return await _httpClient.PutAsync(requestUri, content, cancellationToken); + } + + public async Task SendAsync(HttpRequestMessage request) + { + return await _httpClient.SendAsync(request); + } + + public async Task SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption) + { + return await _httpClient.SendAsync(request, completionOption); + } + + public async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) + { + return await _httpClient.SendAsync(request, cancellationToken); + } + + public async Task SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken) + { + return await _httpClient.SendAsync(request, completionOption, cancellationToken); + } + + public void Dispose(bool disposing) + { + if (!disposing) + { + _httpClient.Dispose(); + } + } + } +} diff --git a/src/Ocelot.Library/Infrastructure/HttpClient/IHttpClient.cs b/src/Ocelot.Library/Infrastructure/HttpClient/IHttpClient.cs new file mode 100644 index 00000000..b74a4246 --- /dev/null +++ b/src/Ocelot.Library/Infrastructure/HttpClient/IHttpClient.cs @@ -0,0 +1,49 @@ +namespace Ocelot.Library.Infrastructure.HttpClient +{ + using System; + using System.IO; + using System.Net.Http; + using System.Net.Http.Headers; + using System.Threading; + using System.Threading.Tasks; + + public interface IHttpClient + { + Uri BaseAddress { get; set; } + HttpRequestHeaders DefaultRequestHeaders { get; } + long MaxResponseContentBufferSize { get; set; } + TimeSpan Timeout { get; set; } + void CancelPendingRequests(); + Task DeleteAsync(string requestUri); + Task DeleteAsync(Uri requestUri); + Task DeleteAsync(Uri requestUri, CancellationToken cancellationToken); + Task DeleteAsync(string requestUri, CancellationToken cancellationToken); + Task GetAsync(string requestUri); + Task GetAsync(Uri requestUri); + Task GetAsync(string requestUri, HttpCompletionOption completionOption); + Task GetAsync(string requestUri, CancellationToken cancellationToken); + Task GetAsync(Uri requestUri, HttpCompletionOption completionOption); + Task GetAsync(Uri requestUri, CancellationToken cancellationToken); + Task GetAsync(string requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken); + Task GetAsync(Uri requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken); + Task GetByteArrayAsync(string requestUri); + Task GetByteArrayAsync(Uri requestUri); + Task GetStreamAsync(string requestUri); + Task GetStreamAsync(Uri requestUri); + Task GetStringAsync(string requestUri); + Task GetStringAsync(Uri requestUri); + Task PostAsync(string requestUri, HttpContent content); + Task PostAsync(Uri requestUri, HttpContent content); + Task PostAsync(string requestUri, HttpContent content, CancellationToken cancellationToken); + Task PostAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken); + Task PutAsync(string requestUri, HttpContent content); + Task PutAsync(Uri requestUri, HttpContent content); + Task PutAsync(string requestUri, HttpContent content, CancellationToken cancellationToken); + Task PutAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken); + Task SendAsync(HttpRequestMessage request); + Task SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption); + Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken); + Task SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken); + void Dispose(bool disposing); + } +} \ No newline at end of file diff --git a/src/Ocelot.Library/Infrastructure/RequestBuilder/IRequestBuilder.cs b/src/Ocelot.Library/Infrastructure/RequestBuilder/IRequestBuilder.cs new file mode 100644 index 00000000..5bb6e27d --- /dev/null +++ b/src/Ocelot.Library/Infrastructure/RequestBuilder/IRequestBuilder.cs @@ -0,0 +1,17 @@ +namespace Ocelot.Library.Infrastructure.RequestBuilder +{ + using System.IO; + using System.Net.Http; + using Microsoft.AspNetCore.Http; + + public interface IRequestBuilder + { + HttpRequestMessage Build(string httpMethod, + string downstreamUrl, + Stream content, + IHeaderDictionary headers, + IRequestCookieCollection cookies, + IQueryCollection queryString, + string contentType); + } +} diff --git a/src/Ocelot.Library/Infrastructure/RequestBuilder/RequestBuilder.cs b/src/Ocelot.Library/Infrastructure/RequestBuilder/RequestBuilder.cs new file mode 100644 index 00000000..578b60b5 --- /dev/null +++ b/src/Ocelot.Library/Infrastructure/RequestBuilder/RequestBuilder.cs @@ -0,0 +1,49 @@ +namespace Ocelot.Library.Infrastructure.RequestBuilder +{ + using System; + using System.IO; + using System.Net.Http; + using System.Net.Http.Headers; + using Microsoft.AspNetCore.Http; + + public class RequestBuilder : IRequestBuilder + { + public HttpRequestMessage Build(string httpMethod, string downstreamUrl, Stream content, IHeaderDictionary headers, + IRequestCookieCollection cookies, IQueryCollection queryString, string contentType) + { + var method = new HttpMethod(httpMethod); + + var uri = new Uri(downstreamUrl + queryString); + + var httpRequestMessage = new HttpRequestMessage(method, uri) + { + Content = new StreamContent(content), + }; + + if (!string.IsNullOrEmpty(contentType)) + { + var splitCt = contentType.Split(';'); + var cT = splitCt[0]; + httpRequestMessage.Content.Headers.ContentType = new MediaTypeHeaderValue(cT); + } + + //todo get rid of if + if (headers != null) + { + headers.Remove("Content-Type"); + } + + //todo get rid of if + if (headers != null) + { + foreach (var header in headers) + { + httpRequestMessage.Headers.Add(header.Key, header.Value.ToArray()); + } + } + + return httpRequestMessage; + + } + } +} \ No newline at end of file diff --git a/src/Ocelot.Library/Infrastructure/Requester/HttpClientHttpRequester.cs b/src/Ocelot.Library/Infrastructure/Requester/HttpClientHttpRequester.cs index 977526fb..b2a14c7e 100644 --- a/src/Ocelot.Library/Infrastructure/Requester/HttpClientHttpRequester.cs +++ b/src/Ocelot.Library/Infrastructure/Requester/HttpClientHttpRequester.cs @@ -1,53 +1,22 @@ -using System.IO; -using System.Net.Http; -using System.Net.Http.Headers; +using System.Net.Http; using System.Threading.Tasks; -using Flurl; -using Flurl.Http; -using Microsoft.AspNetCore.Http; namespace Ocelot.Library.Infrastructure.Requester { + using HttpClient; + public class HttpClientHttpRequester : IHttpRequester { - public async Task GetResponse( - string httpMethod, - string downstreamUrl, - Stream content, - IHeaderDictionary headers, - IRequestCookieCollection cookies, - IQueryCollection queryString, - string contentType) + private readonly IHttpClient _httpClient; + + public HttpClientHttpRequester(IHttpClient httpClient) { - var method = new HttpMethod(httpMethod); - var streamContent = new StreamContent(content); + _httpClient = httpClient; + } - if (!string.IsNullOrEmpty(contentType)) - { - var splitCt = contentType.Split(';'); - var cT = splitCt[0]; - streamContent.Headers.ContentType = new MediaTypeHeaderValue(cT); - } - - if (headers != null) - { - headers.Remove("Content-Type"); - } - - if (content.Length > 0) - { - return await downstreamUrl - .SetQueryParams(queryString) - .WithCookies(cookies) - .WithHeaders(headers) - .SendAsync(method, streamContent); - } - - return await downstreamUrl - .SetQueryParams(queryString) - .WithHeaders(headers) - .WithCookies(cookies) - .SendAsync(method, streamContent); + public async Task GetResponse(HttpRequestMessage httpRequestMessage) + { + return await _httpClient.SendAsync(httpRequestMessage); } } } \ No newline at end of file diff --git a/src/Ocelot.Library/Infrastructure/Requester/IHttpRequester.cs b/src/Ocelot.Library/Infrastructure/Requester/IHttpRequester.cs index eaacbc54..2a426d52 100644 --- a/src/Ocelot.Library/Infrastructure/Requester/IHttpRequester.cs +++ b/src/Ocelot.Library/Infrastructure/Requester/IHttpRequester.cs @@ -1,20 +1,10 @@ -using System.IO; -using System.Net.Http; +using System.Net.Http; using System.Threading.Tasks; -using Flurl.Http; -using Microsoft.AspNetCore.Http; namespace Ocelot.Library.Infrastructure.Requester { public interface IHttpRequester { - Task GetResponse( - string httpMethod, - string downstreamUrl, - Stream content, - IHeaderDictionary headers, - IRequestCookieCollection cookies, - IQueryCollection queryString, - string contentType); + Task GetResponse(HttpRequestMessage httpRequestMessage); } } diff --git a/src/Ocelot.Library/Middleware/HttpRequesterMiddleware.cs b/src/Ocelot.Library/Middleware/HttpRequesterMiddleware.cs index bc767a22..4521e858 100644 --- a/src/Ocelot.Library/Middleware/HttpRequesterMiddleware.cs +++ b/src/Ocelot.Library/Middleware/HttpRequesterMiddleware.cs @@ -6,22 +6,27 @@ using Ocelot.Library.Infrastructure.Responder; namespace Ocelot.Library.Middleware { + using Infrastructure.RequestBuilder; + public class HttpRequesterMiddleware { private readonly RequestDelegate _next; private readonly IHttpRequester _requester; private readonly IHttpResponder _responder; private readonly IScopedRequestDataRepository _scopedRequestDataRepository; + private readonly IRequestBuilder _requestBuilder; public HttpRequesterMiddleware(RequestDelegate next, IHttpRequester requester, IHttpResponder responder, - IScopedRequestDataRepository scopedRequestDataRepository) + IScopedRequestDataRepository scopedRequestDataRepository, + IRequestBuilder requestBuilder) { _next = next; _requester = requester; _responder = responder; _scopedRequestDataRepository = scopedRequestDataRepository; + _requestBuilder = requestBuilder; } public async Task Invoke(HttpContext context) @@ -34,9 +39,12 @@ namespace Ocelot.Library.Middleware return; } + var request = _requestBuilder + .Build(context.Request.Method, downstreamUrl.Data, context.Request.Body, + context.Request.Headers, context.Request.Cookies, context.Request.Query, context.Request.ContentType); + var response = await _requester - .GetResponse(context.Request.Method, downstreamUrl.Data, context.Request.Body, - context.Request.Headers, context.Request.Cookies, context.Request.Query, context.Request.ContentType); + .GetResponse(request); await _responder.CreateResponse(context, response); diff --git a/src/Ocelot.Library/project.json b/src/Ocelot.Library/project.json index 07d34181..b3d22c5c 100644 --- a/src/Ocelot.Library/project.json +++ b/src/Ocelot.Library/project.json @@ -1,4 +1,4 @@ -{ +{ "version": "1.0.0-*", "dependencies": { @@ -17,8 +17,7 @@ "Microsoft.Extensions.Logging.Debug": "1.0.0", "Microsoft.Extensions.Options.ConfigurationExtensions": "1.0.0", "Microsoft.AspNetCore.Http": "1.0.0", - "YamlDotNet": "3.9.0", - "Flurl.Http": "1.0.1" + "YamlDotNet": "3.9.0" }, "frameworks": { diff --git a/src/Ocelot/Startup.cs b/src/Ocelot/Startup.cs index 17f68c6c..71d329a5 100644 --- a/src/Ocelot/Startup.cs +++ b/src/Ocelot/Startup.cs @@ -12,7 +12,10 @@ using Ocelot.Library.Middleware; namespace Ocelot { + using System.Net.Http; using Library.Infrastructure.Configuration; + using Library.Infrastructure.HttpClient; + using Library.Infrastructure.RequestBuilder; using Library.Infrastructure.UrlMatcher; using Library.Infrastructure.UrlTemplateReplacer; @@ -44,6 +47,9 @@ namespace Ocelot services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); + services.AddTransient(); + services.AddTransient(); + services.AddSingleton(); // see this for why we register this as singleton http://stackoverflow.com/questions/37371264/invalidoperationexception-unable-to-resolve-service-for-type-microsoft-aspnetc services.AddSingleton(); diff --git a/test/Ocelot.UnitTests/Configuration/Requester/RequesterTests.cs b/test/Ocelot.UnitTests/Configuration/Requester/RequesterTests.cs index 9e3b4f61..46708773 100644 --- a/test/Ocelot.UnitTests/Configuration/Requester/RequesterTests.cs +++ b/test/Ocelot.UnitTests/Configuration/Requester/RequesterTests.cs @@ -1,11 +1,8 @@ -using System; -using System.Collections.Generic; +using System.Collections.Generic; using System.IO; using System.Linq; using System.Net; using System.Net.Http; -using System.Threading.Tasks; -using Flurl.Http.Testing; using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http.Internal; using Microsoft.Extensions.Primitives; @@ -16,10 +13,13 @@ using Xunit; namespace Ocelot.UnitTests.Requester { - public class RequesterTests : IDisposable + using System; + using Library.Infrastructure.HttpClient; + using Moq; + + public class RequesterTests { private readonly IHttpRequester _httpRequester; - private readonly HttpTest _httpTest; private string _httpMethod; private string _downstreamUrl; private HttpResponseMessage _result; @@ -28,11 +28,12 @@ namespace Ocelot.UnitTests.Requester private IRequestCookieCollection _cookies; private IQueryCollection _query; private string _contentType; + private Mock _httpClient; public RequesterTests() { - _httpTest = new HttpTest(); - _httpRequester = new HttpClientHttpRequester(); + _httpClient = new Mock(); + _httpRequester = new HttpClientHttpRequester(_httpClient.Object); } [Fact] @@ -163,7 +164,8 @@ namespace Ocelot.UnitTests.Requester private void ThenTheCorrectQueryStringIsUsed(string expected) { - _httpTest.CallLog[0].Request.RequestUri.Query.ShouldBe(expected); + throw new NotImplementedException(); + //_httpTest.CallLog[0].Request.RequestUri.Query.ShouldBe(expected); } private void GivenTheQueryStringIs(IQueryCollection query) @@ -173,16 +175,18 @@ namespace Ocelot.UnitTests.Requester private void ThenTheCorrectCookiesAreUsed(IRequestCookieCollection cookies) { - var expectedCookies = cookies.Select(x => new KeyValuePair(x.Key, x.Value)); + throw new NotImplementedException(); - foreach (var expectedCookie in expectedCookies) - { - _httpTest - .CallLog[0] - .Request - .Headers - .ShouldContain(x => x.Key == "Cookie" && x.Value.First() == string.Format("{0}={1}", expectedCookie.Key, expectedCookie.Value)); - } + /* var expectedCookies = cookies.Select(x => new KeyValuePair(x.Key, x.Value)); + + foreach (var expectedCookie in expectedCookies) + { + _httpTest + .CallLog[0] + .Request + .Headers + .ShouldContain(x => x.Key == "Cookie" && x.Value.First() == string.Format("{0}={1}", expectedCookie.Key, expectedCookie.Value)); + }*/ } private void GivenTheCookiesAre(IRequestCookieCollection cookies) @@ -192,24 +196,28 @@ namespace Ocelot.UnitTests.Requester private void ThenTheCorrectHeadersAreUsed(IHeaderDictionary headers) { - var expectedHeaders = headers.Select(x => new KeyValuePair(x.Key, x.Value)); + throw new NotImplementedException(); + + /*var expectedHeaders = headers.Select(x => new KeyValuePair(x.Key, x.Value)); foreach (var expectedHeader in expectedHeaders) { _httpTest.CallLog[0].Request.Headers.ShouldContain(x => x.Key == expectedHeader.Key && x.Value.First() == expectedHeader.Value[0]); - } + }*/ } private void ThenTheCorrectContentHeadersAreUsed(IHeaderDictionary headers) { - var expectedHeaders = headers.Select(x => new KeyValuePair(x.Key, x.Value)); + throw new NotImplementedException(); + + /*var expectedHeaders = headers.Select(x => new KeyValuePair(x.Key, x.Value)); foreach (var expectedHeader in expectedHeaders) { _httpTest.CallLog[0].Request.Content.Headers.ShouldContain(x => x.Key == expectedHeader.Key && x.Value.First() == expectedHeader.Value[0] ); - } + }*/ } private void GivenTheHttpHeadersAre(IHeaderDictionary headers) @@ -234,15 +242,22 @@ namespace Ocelot.UnitTests.Requester private void GivenTheDownstreamServerReturns(HttpStatusCode statusCode) { - _httpTest.RespondWith(_content != null ? _content.ReadAsStringAsync().Result : string.Empty, (int)statusCode); + _httpClient + .Setup(x => x.SendAsync(It.IsAny())) + .ReturnsAsync(new HttpResponseMessage() + { + StatusCode = statusCode, + Content = _content != null ? _content : null + + }); + /* _httpTest + .RespondWith(_content != null ? _content.ReadAsStringAsync().Result : string.Empty, (int)statusCode);*/ } private void WhenIMakeARequest() { _result = _httpRequester - .GetResponse(_httpMethod, _downstreamUrl, - _content != null ? _content.ReadAsStreamAsync().Result : Stream.Null, - _headers, _cookies, _query, _contentType).Result; + .GetResponse(new HttpRequestMessage()).Result; } private void ThenTheFollowingIsReturned(HttpStatusCode expected) @@ -252,22 +267,23 @@ namespace Ocelot.UnitTests.Requester private void ThenTheDownstreamServerIsCalledCorrectly() { - _httpTest.ShouldHaveCalled(_downstreamUrl); + throw new NotImplementedException(); + + //_httpTest.ShouldHaveCalled(_downstreamUrl); } private void ThenTheCorrectHttpMethodIsUsed(HttpMethod expected) { - _httpTest.CallLog[0].Request.Method.ShouldBe(expected); + throw new NotImplementedException(); + + //_httpTest.CallLog[0].Request.Method.ShouldBe(expected); } private void ThenTheCorrectContentIsUsed(HttpContent content) { - _httpTest.CallLog[0].Response.Content.ReadAsStringAsync().Result.ShouldBe(content.ReadAsStringAsync().Result); - } + throw new NotImplementedException(); - public void Dispose() - { - _httpTest.Dispose(); + //_httpTest.CallLog[0].Response.Content.ReadAsStringAsync().Result.ShouldBe(content.ReadAsStringAsync().Result); } } }