ripping out flurl...sorry flurl

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<HttpResponseMessage> DeleteAsync(string requestUri)
+        {
+            return await _httpClient.DeleteAsync(requestUri);
+        }
+
+        public async Task<HttpResponseMessage> DeleteAsync(Uri requestUri)
+        {
+            return await _httpClient.DeleteAsync(requestUri);
+        }
+
+        public async Task<HttpResponseMessage> DeleteAsync(Uri requestUri, CancellationToken cancellationToken)
+        {
+            return await _httpClient.DeleteAsync(requestUri, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> DeleteAsync(string requestUri, CancellationToken cancellationToken)
+        {
+            return await _httpClient.DeleteAsync(requestUri, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(string requestUri)
+        {
+            return await _httpClient.GetAsync(requestUri);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(Uri requestUri)
+        {
+            return await _httpClient.GetAsync(requestUri);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(string requestUri, HttpCompletionOption completionOption)
+        {
+            return await _httpClient.GetAsync(requestUri, completionOption);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(string requestUri, CancellationToken cancellationToken)
+        {
+            return await _httpClient.GetAsync(requestUri, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption)
+        {
+            return await _httpClient.GetAsync(requestUri, completionOption);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(Uri requestUri, CancellationToken cancellationToken)
+        {
+            return await _httpClient.GetAsync(requestUri, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(string requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken)
+        {
+            return await _httpClient.GetAsync(requestUri, completionOption, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken)
+        {
+            return await _httpClient.GetAsync(requestUri, completionOption, cancellationToken);
+        }
+
+        public async Task<byte[]> GetByteArrayAsync(string requestUri)
+        {
+            return await _httpClient.GetByteArrayAsync(requestUri);
+        }
+
+        public async Task<byte[]> GetByteArrayAsync(Uri requestUri)
+        {
+            return await _httpClient.GetByteArrayAsync(requestUri);
+        }
+
+        public async Task<Stream> GetStreamAsync(string requestUri)
+        {
+            return await _httpClient.GetStreamAsync(requestUri);
+        }
+
+        public async Task<Stream> GetStreamAsync(Uri requestUri)
+        {
+            return await _httpClient.GetStreamAsync(requestUri);
+        }
+
+        public async Task<string> GetStringAsync(string requestUri)
+        {
+            return await _httpClient.GetStringAsync(requestUri);
+        }
+
+        public async Task<string> GetStringAsync(Uri requestUri)
+        {
+            return await _httpClient.GetStringAsync(requestUri);
+        }
+
+        public async Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content)
+        {
+            return await _httpClient.PostAsync(requestUri, content);
+        }
+
+        public async Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent content)
+        {
+            return await _httpClient.PostAsync(requestUri, content);
+        }
+
+        public async Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content, CancellationToken cancellationToken)
+        {
+            return await _httpClient.PostAsync(requestUri, content, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken)
+        {
+            return await _httpClient.PostAsync(requestUri, content, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> PutAsync(string requestUri, HttpContent content)
+        {
+            return await _httpClient.PutAsync(requestUri, content);
+        }
+
+        public async Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent content)
+        {
+            return await _httpClient.PutAsync(requestUri, content);
+        }
+
+        public async Task<HttpResponseMessage> PutAsync(string requestUri, HttpContent content, CancellationToken cancellationToken)
+        {
+            return await _httpClient.PutAsync(requestUri, content, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken)
+        {
+            return await _httpClient.PutAsync(requestUri, content, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request)
+        {
+            return await _httpClient.SendAsync(request);
+        }
+
+        public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption)
+        {
+            return await _httpClient.SendAsync(request, completionOption);
+        }
+
+        public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            return await _httpClient.SendAsync(request, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken)
+        {
+            return await _httpClient.SendAsync(request, completionOption, cancellationToken);
+        }
+
+        public void Dispose(bool disposing)
+        {
+            if (!disposing)
+            {
+                _httpClient.Dispose();
+            }
+        }
+    }
+}

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<HttpResponseMessage> DeleteAsync(string requestUri);
+        Task<HttpResponseMessage> DeleteAsync(Uri requestUri);
+        Task<HttpResponseMessage> DeleteAsync(Uri requestUri, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> DeleteAsync(string requestUri, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> GetAsync(string requestUri);
+        Task<HttpResponseMessage> GetAsync(Uri requestUri);
+        Task<HttpResponseMessage> GetAsync(string requestUri, HttpCompletionOption completionOption);
+        Task<HttpResponseMessage> GetAsync(string requestUri, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption);
+        Task<HttpResponseMessage> GetAsync(Uri requestUri, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> GetAsync(string requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken);
+        Task<byte[]> GetByteArrayAsync(string requestUri);
+        Task<byte[]> GetByteArrayAsync(Uri requestUri);
+        Task<Stream> GetStreamAsync(string requestUri);
+        Task<Stream> GetStreamAsync(Uri requestUri);
+        Task<string> GetStringAsync(string requestUri);
+        Task<string> GetStringAsync(Uri requestUri);
+        Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content);
+        Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent content);
+        Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> PutAsync(string requestUri, HttpContent content);
+        Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent content);
+        Task<HttpResponseMessage> PutAsync(string requestUri, HttpContent content, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> SendAsync(HttpRequestMessage request);
+        Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption);
+        Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken);
+        void Dispose(bool disposing);
+    }
+}

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

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;
+
+        }
+    }
+}

src/Ocelot.Library/Infrastructure/Requester/HttpClientHttpRequester.cs

@@ -1,53 +1,22 @@
-using System.IO;
+using System.Net.Http;
-using System.Net.Http;
-using System.Net.Http.Headers;
 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<HttpResponseMessage> GetResponse(
+        private readonly IHttpClient _httpClient;
-            string httpMethod, 
-            string downstreamUrl, 
-            Stream content,
-            IHeaderDictionary headers,
-            IRequestCookieCollection cookies,
-            IQueryCollection queryString,
-            string contentType)
-        {
-            var method = new HttpMethod(httpMethod);
-            var streamContent = new StreamContent(content);
 
-            if (!string.IsNullOrEmpty(contentType))
+        public HttpClientHttpRequester(IHttpClient httpClient)
         {
-                var splitCt = contentType.Split(';');
+            _httpClient = httpClient;
-                var cT = splitCt[0];
-                streamContent.Headers.ContentType = new MediaTypeHeaderValue(cT);
         }
 
-            if (headers != null)
+        public async Task<HttpResponseMessage> GetResponse(HttpRequestMessage httpRequestMessage)
         {
-                headers.Remove("Content-Type");
+            return await _httpClient.SendAsync(httpRequestMessage);
-            }
-
-            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);
         }
     }
 }

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<HttpResponseMessage> GetResponse(
+        Task<HttpResponseMessage> GetResponse(HttpRequestMessage httpRequestMessage);
-            string httpMethod, 
-            string downstreamUrl, 
-            Stream content, 
-            IHeaderDictionary headers, 
-            IRequestCookieCollection cookies,
-            IQueryCollection queryString,
-            string contentType);
     }
 }

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,10 +39,13 @@ namespace Ocelot.Library.Middleware
                 return;
             }
 
-            var response = await _requester
+            var request = _requestBuilder
-                .GetResponse(context.Request.Method, downstreamUrl.Data, context.Request.Body, 
+              .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(request);
+
             await _responder.CreateResponse(context, response);
 
             await _next.Invoke(context);

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",
+        "YamlDotNet": "3.9.0"
-        "Flurl.Http": "1.0.1"
     },
 
     "frameworks": {

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<IDownstreamRouteFinder, DownstreamRouteFinder>();
             services.AddSingleton<IHttpRequester, HttpClientHttpRequester>();
             services.AddSingleton<IHttpResponder, HttpContextResponder>();
+            services.AddTransient<HttpClient>();
+            services.AddTransient<IHttpClient, HttpClientWrapper>();
+            services.AddSingleton<IRequestBuilder, RequestBuilder>();
 
             // 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<IHttpContextAccessor, HttpContextAccessor>();

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<IHttpClient> _httpClient;
 
         public RequesterTests()
         {
-            _httpTest = new HttpTest();
+            _httpClient = new Mock<IHttpClient>();
-            _httpRequester = new HttpClientHttpRequester();
+            _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,7 +175,9 @@ namespace Ocelot.UnitTests.Requester
 
         private void ThenTheCorrectCookiesAreUsed(IRequestCookieCollection cookies)
         {
-            var expectedCookies = cookies.Select(x => new KeyValuePair<string, string>(x.Key, x.Value));
+            throw new NotImplementedException();
+
+            /* var expectedCookies = cookies.Select(x => new KeyValuePair<string, string>(x.Key, x.Value));
 
              foreach (var expectedCookie in expectedCookies)
              {
@@ -182,7 +186,7 @@ namespace Ocelot.UnitTests.Requester
                      .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<string, string[]>(x.Key, x.Value));
+            throw new NotImplementedException();
+
+            /*var expectedHeaders = headers.Select(x => new KeyValuePair<string, string[]>(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<string, string[]>(x.Key, x.Value));
+            throw new NotImplementedException();
+
+            /*var expectedHeaders = headers.Select(x => new KeyValuePair<string, string[]>(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<HttpRequestMessage>()))
+                .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, 
+                .GetResponse(new HttpRequestMessage()).Result;
-                _content != null ? _content.ReadAsStreamAsync().Result : Stream.Null, 
-                _headers, _cookies, _query, _contentType).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.CallLog[0].Response.Content.ReadAsStringAsync().Result.ShouldBe(content.ReadAsStringAsync().Result);
-        {
-            _httpTest.Dispose();
         }
     }
 }