ripping out flurl...sorry flurl

2025-11-01 06:35:28 +08:00 · 2016-10-06 21:18:12 +01:00
parent 3a18de036d
commit 74a7f5d270
10 changed files with 406 additions and 93 deletions
--- a/src/Ocelot.Library/Infrastructure/HttpClient/HttpClientWrapper.cs
+++ 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<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();
+            }
+        }
+    }
+}
--- a/src/Ocelot.Library/Infrastructure/HttpClient/IHttpClient.cs
+++ 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<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);
+    }
+}
--- a/src/Ocelot.Library/Infrastructure/RequestBuilder/IRequestBuilder.cs
+++ 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);
+    }
+}
--- a/src/Ocelot.Library/Infrastructure/RequestBuilder/RequestBuilder.cs
+++ 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;
+
+        }
+    }
+}
--- 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<HttpResponseMessage> GetResponse(
-            string httpMethod, 
-            string downstreamUrl, 
-            Stream content,
-            IHeaderDictionary headers,
-            IRequestCookieCollection cookies,
-            IQueryCollection queryString,
-            string contentType)
-        {
-            var method = new HttpMethod(httpMethod);
-            var streamContent = new StreamContent(content);
+        private readonly IHttpClient _httpClient;

-            if (!string.IsNullOrEmpty(contentType))
+        public HttpClientHttpRequester(IHttpClient httpClient)
        {
-                var splitCt = contentType.Split(';');
-                var cT = splitCt[0];
-                streamContent.Headers.ContentType = new MediaTypeHeaderValue(cT);
+            _httpClient = httpClient;
        }

-            if (headers != null)
+        public async Task<HttpResponseMessage> GetResponse(HttpRequestMessage httpRequestMessage)
        {
-                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);
+            return await _httpClient.SendAsync(httpRequestMessage);
        }
    }
 }
--- 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<HttpResponseMessage> GetResponse(
-            string httpMethod, 
-            string downstreamUrl, 
-            Stream content, 
-            IHeaderDictionary headers, 
-            IRequestCookieCollection cookies,
-            IQueryCollection queryString,
-            string contentType);
+        Task<HttpResponseMessage> GetResponse(HttpRequestMessage httpRequestMessage);
    }
 }
--- 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,10 +39,13 @@ namespace Ocelot.Library.Middleware
                return;
            }

-            var response = await _requester
-                .GetResponse(context.Request.Method, downstreamUrl.Data, context.Request.Body, 
+            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(request);
+
            await _responder.CreateResponse(context, response);

            await _next.Invoke(context);
--- 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": {
--- 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<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>();
--- 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<IHttpClient> _httpClient;

        public RequesterTests()
        {
-            _httpTest = new HttpTest();
-            _httpRequester = new HttpClientHttpRequester();
+            _httpClient = new Mock<IHttpClient>();
+            _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, 
-                _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);
        }
    }
 }