Added some basic cache stuff

test/Ocelot.AcceptanceTests/CachingTests.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Threading;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Ocelot.Configuration.File;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.AcceptanceTests
+{
+    public class CachingTests : IDisposable
+    {
+        private IWebHost _builder;
+        private readonly Steps _steps;
+
+        public CachingTests()
+        {
+            _steps = new Steps();
+        }
+
+        [Fact]
+        public void should_return_cached_response()
+        {
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamTemplate = "http://localhost:51879/",
+                            UpstreamTemplate = "/",
+                            UpstreamHttpMethod = "Get",
+                            FileCacheOptions = new FileCacheOptions
+                            {
+                                TtlSeconds = 100
+                            }
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:51879", 200, "Hello from Laura"))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(x => _steps.ThenTheResponseBodyShouldBe("Hello from Laura"))
+                .Given(x => x.GivenTheServiceNowReturns("http://localhost:51879", 200, "Hello from Tom"))
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(x => _steps.ThenTheResponseBodyShouldBe("Hello from Laura"))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_not_return_cached_response_as_ttl_expires()
+        {
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamTemplate = "http://localhost:51879/",
+                            UpstreamTemplate = "/",
+                            UpstreamHttpMethod = "Get",
+                            FileCacheOptions = new FileCacheOptions
+                            {
+                                TtlSeconds = 1
+                            }
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:51879", 200, "Hello from Laura"))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(x => _steps.ThenTheResponseBodyShouldBe("Hello from Laura"))
+                .Given(x => x.GivenTheServiceNowReturns("http://localhost:51879", 200, "Hello from Tom"))
+                .And(x => x.GivenTheCacheExpires())
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(x => _steps.ThenTheResponseBodyShouldBe("Hello from Tom"))
+                .BDDfy();
+        }
+
+        private void GivenTheCacheExpires()
+        {
+            Thread.Sleep(1000);
+        }
+
+        private void GivenTheServiceNowReturns(string url, int statusCode, string responseBody)
+        {
+            _builder.Dispose();
+            GivenThereIsAServiceRunningOn(url, statusCode, responseBody);
+        }
+
+        private void GivenThereIsAServiceRunningOn(string url, int statusCode, string responseBody)
+        {
+            _builder = new WebHostBuilder()
+                .UseUrls(url)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .UseUrls(url)
+                .Configure(app =>
+                {
+                    app.Run(async context =>
+                    {
+                        context.Response.StatusCode = statusCode;
+                        await context.Response.WriteAsync(responseBody);
+                    });
+                })
+                .Build();
+
+            _builder.Start();
+        }
+
+        public void Dispose()
+        {
+            _builder?.Dispose();
+            _steps.Dispose();
+        }
+    }
+}

test/Ocelot.AcceptanceTests/CustomMiddlewareTests.cs

@@ -2,15 +2,12 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Net;
-using System.Net.Http;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.DependencyInjection;
 using Ocelot.Configuration.File;
-using Ocelot.Infrastructure.RequestData;
 using Ocelot.Middleware;
+using Shouldly;
 using TestStack.BDDfy;
 using Xunit;
 
@@ -21,21 +18,160 @@ namespace Ocelot.AcceptanceTests
         private readonly string _configurationPath;
         private IWebHost _builder;
         private readonly Steps _steps;
+        private int _counter;
 
         public CustomMiddlewareTests()
         {
+            _counter = 0;
             _steps = new Steps();;
             _configurationPath = "configuration.json";
         }
 
         [Fact]
-        public void response_should_come_from_pre_authorisation_middleware()
+        public void should_call_pre_query_string_builder_middleware()
+        {
+            var configuration = new OcelotMiddlewareConfiguration
+            {
+                AuthorisationMiddleware = async (ctx, next) =>
+                {
+                    _counter++;
+                    await next.Invoke();
+                }
+            };
+
+            var fileConfiguration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamTemplate = "http://localhost:41879/",
+                            UpstreamTemplate = "/",
+                            UpstreamHttpMethod = "Get",
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:41879", 200))
+                .And(x => _steps.GivenThereIsAConfiguration(fileConfiguration, _configurationPath))
+                .And(x => _steps.GivenOcelotIsRunning(configuration))
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(x => x.ThenTheCounterIs(1))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_call_authorisation_middleware()
+        {
+            var configuration = new OcelotMiddlewareConfiguration
+            {
+                AuthorisationMiddleware = async (ctx, next) =>
+                {
+                    _counter++;
+                    await next.Invoke();
+                }
+            };
+
+            var fileConfiguration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamTemplate = "http://localhost:41879/",
+                            UpstreamTemplate = "/",
+                            UpstreamHttpMethod = "Get",
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:41879", 200))
+                .And(x => _steps.GivenThereIsAConfiguration(fileConfiguration, _configurationPath))
+                .And(x => _steps.GivenOcelotIsRunning(configuration))
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(x => x.ThenTheCounterIs(1))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_call_authentication_middleware()
+        {
+            var configuration = new OcelotMiddlewareConfiguration
+            {
+                AuthenticationMiddleware = async (ctx, next) =>
+                {
+                    _counter++;
+                    await next.Invoke();
+                }
+            };
+
+            var fileConfiguration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamTemplate = "http://localhost:41879/",
+                            UpstreamTemplate = "/",
+                            UpstreamHttpMethod = "Get",
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:41879", 200))
+                .And(x => _steps.GivenThereIsAConfiguration(fileConfiguration, _configurationPath))
+                .And(x => _steps.GivenOcelotIsRunning(configuration))
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(x => x.ThenTheCounterIs(1))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_call_pre_error_middleware()
+        {
+            var configuration = new OcelotMiddlewareConfiguration
+            {
+                PreErrorResponderMiddleware = async (ctx, next) =>
+                {
+                    _counter++;
+                    await next.Invoke();
+                }
+            };
+
+            var fileConfiguration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamTemplate = "http://localhost:41879/",
+                            UpstreamTemplate = "/",
+                            UpstreamHttpMethod = "Get",
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:41879", 200))
+                .And(x => _steps.GivenThereIsAConfiguration(fileConfiguration, _configurationPath))
+                .And(x => _steps.GivenOcelotIsRunning(configuration))
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(x => x.ThenTheCounterIs(1))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_call_pre_authorisation_middleware()
         {
             var configuration = new OcelotMiddlewareConfiguration
             {
                 PreAuthorisationMiddleware = async (ctx, next) =>
                 {
-                    await ctx.Response.WriteAsync("PreHttpResponderMiddleware");
+                    _counter++;
+                    await next.Invoke();
                 }
             };
 
@@ -57,18 +193,19 @@ namespace Ocelot.AcceptanceTests
                 .And(x => _steps.GivenOcelotIsRunning(configuration))
                 .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
                 .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
-                .And(x => _steps.ThenTheResponseBodyShouldBe("PreHttpResponderMiddleware"))
+                .And(x => x.ThenTheCounterIs(1))
                 .BDDfy();
         }
 
         [Fact]
-        public void response_should_come_from_pre_http_authentication_middleware()
+        public void should_call_pre_http_authentication_middleware()
         {
             var configuration = new OcelotMiddlewareConfiguration
             {
                 PreAuthenticationMiddleware = async (ctx, next) =>
                 {
-                    await ctx.Response.WriteAsync("PreHttpRequesterMiddleware");
+                    _counter++;
+                    await next.Invoke();
                 }
             };
 
@@ -90,10 +227,15 @@ namespace Ocelot.AcceptanceTests
                 .And(x => _steps.GivenOcelotIsRunning(configuration))
                 .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
                 .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
-                .And(x => _steps.ThenTheResponseBodyShouldBe("PreHttpRequesterMiddleware"))
+                .And(x => x.ThenTheCounterIs(1))
                 .BDDfy();
         }
 
+        private void ThenTheCounterIs(int expected)
+        {
+            _counter.ShouldBe(expected);
+        }
+
         private void GivenThereIsAServiceRunningOn(string url, int statusCode)
         {
             _builder = new WebHostBuilder()

test/Ocelot.AcceptanceTests/Steps.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using CacheManager.Core;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.Extensions.Configuration;
@@ -15,6 +16,7 @@ using Ocelot.DependencyInjection;
 using Ocelot.ManualTest;
 using Ocelot.Middleware;
 using Shouldly;
+using ConfigurationBuilder = Microsoft.Extensions.Configuration.ConfigurationBuilder;
 
 namespace Ocelot.AcceptanceTests
 {
@@ -82,6 +84,16 @@ namespace Ocelot.AcceptanceTests
                 .UseConfiguration(configuration)
                 .ConfigureServices(s =>
                 {
+                    Action<ConfigurationBuilderCachePart> settings = (x) =>
+                    {
+                        x.WithMicrosoftLogging(log =>
+                        {
+                            log.AddConsole(LogLevel.Debug);
+                        })
+                        .WithDictionaryHandle();
+                    };
+
+                    s.AddOcelotOutputCaching(settings);
                     s.AddOcelotFileConfiguration(configuration);
                     s.AddOcelot();
                 })

test/Ocelot.AcceptanceTests/configuration.json

@@ -1 +1 @@
-{"ReRoutes":[{"DownstreamTemplate":"http://localhost:41879/","UpstreamTemplate":"/","UpstreamHttpMethod":"Get","AuthenticationOptions":{"Provider":null,"ProviderRootUrl":null,"ScopeName":null,"RequireHttps":false,"AdditionalScopes":[],"ScopeSecret":null},"AddHeadersToRequest":{},"AddClaimsToRequest":{},"RouteClaimsRequirement":{},"AddQueriesToRequest":{},"RequestIdKey":null}]}
+{"ReRoutes":[{"DownstreamTemplate":"http://localhost:41879/","UpstreamTemplate":"/","UpstreamHttpMethod":"Get","AuthenticationOptions":{"Provider":null,"ProviderRootUrl":null,"ScopeName":null,"RequireHttps":false,"AdditionalScopes":[],"ScopeSecret":null},"AddHeadersToRequest":{},"AddClaimsToRequest":{},"RouteClaimsRequirement":{},"AddQueriesToRequest":{},"RequestIdKey":null,"FileCacheOptions":{"TtlSeconds":0}}]}

test/Ocelot.ManualTest/Startup.cs

@@ -1,10 +1,13 @@
-using Microsoft.AspNetCore.Builder;
+using System;
+using CacheManager.Core;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Ocelot.DependencyInjection;
 using Ocelot.Middleware;
+using ConfigurationBuilder = Microsoft.Extensions.Configuration.ConfigurationBuilder;
 
 namespace Ocelot.ManualTest
 {
@@ -27,6 +30,16 @@ namespace Ocelot.ManualTest
         // This method gets called by the runtime. Use this method to add services to the container.
         public void ConfigureServices(IServiceCollection services)
         {
+            Action<ConfigurationBuilderCachePart> settings = (x) =>
+            {
+                x.WithMicrosoftLogging(log =>
+                {
+                    log.AddConsole(LogLevel.Debug);
+                })
+                .WithDictionaryHandle();
+            };
+
+            services.AddOcelotOutputCaching(settings);
             services.AddOcelotFileConfiguration(Configuration);
             services.AddOcelot();
         }

test/Ocelot.ManualTest/configuration.json

@@ -40,7 +40,8 @@
         {
             "DownstreamTemplate": "http://jsonplaceholder.typicode.com/posts",
             "UpstreamTemplate": "/posts",
-            "UpstreamHttpMethod": "Get"
+            "UpstreamHttpMethod": "Get",
+            "FileCacheOptions": { "TtlSeconds": 15 }
         },
         {
             "DownstreamTemplate": "http://jsonplaceholder.typicode.com/posts/{postId}",

test/Ocelot.UnitTests/Cache/CacheManagerCacheTests.cs

@@ -0,0 +1,77 @@
+using System;
+using CacheManager.Core;
+using Moq;
+using Ocelot.Cache;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.Cache
+{
+    public class CacheManagerCacheTests
+    {
+        private OcelotCacheManagerCache<string> _ocelotOcelotCacheManager;
+        private Mock<ICacheManager<string>> _mockCacheManager;
+        private string _key;
+        private string _value;
+        private string _resultGet;
+        private TimeSpan _ttlSeconds;
+
+        public CacheManagerCacheTests()
+        {
+            _mockCacheManager = new Mock<ICacheManager<string>>();
+            _ocelotOcelotCacheManager = new OcelotCacheManagerCache<string>(_mockCacheManager.Object);
+        }
+        [Fact]
+        public void should_get_from_cache()
+        {
+            this.Given(x => x.GivenTheFollowingIsCached("someKey", "someValue"))
+                .When(x => x.WhenIGetFromTheCache())
+                .Then(x => x.ThenTheResultIs("someValue"))
+                .BDDfy();
+
+        }
+
+        [Fact]
+        public void should_add_to_cache()
+        {
+            this.When(x => x.WhenIAddToTheCache("someKey", "someValue", TimeSpan.FromSeconds(1)))
+                .Then(x => x.ThenTheCacheIsCalledCorrectly())
+                .BDDfy();
+        }
+
+        private void WhenIAddToTheCache(string key, string value, TimeSpan ttlSeconds)
+        {
+            _key = key;
+            _value = value;
+            _ttlSeconds = ttlSeconds;
+
+            _ocelotOcelotCacheManager.Add(_key, _value, _ttlSeconds);
+        }
+
+        private void ThenTheCacheIsCalledCorrectly()
+        {
+            _mockCacheManager
+                .Verify(x => x.Add(It.IsAny<CacheItem<string>>()), Times.Once);
+        }
+
+        private void ThenTheResultIs(string expected)
+        {
+            _resultGet.ShouldBe(expected);
+        }
+
+        private void WhenIGetFromTheCache()
+        {
+            _resultGet = _ocelotOcelotCacheManager.Get(_key);
+        }
+
+        private void GivenTheFollowingIsCached(string key, string value)
+        {
+            _key = key;
+            _value = value;
+            _mockCacheManager
+                .Setup(x => x.Get<string>(It.IsAny<string>()))
+                .Returns(value);
+        }
+    }
+}

test/Ocelot.UnitTests/Cache/OutputCacheMiddlewareTests.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Http;
+using CacheManager.Core;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using Ocelot.Cache;
+using Ocelot.Cache.Middleware;
+using Ocelot.Configuration;
+using Ocelot.Configuration.Builder;
+using Ocelot.DownstreamRouteFinder;
+using Ocelot.DownstreamRouteFinder.UrlMatcher;
+using Ocelot.Infrastructure.RequestData;
+using Ocelot.Responses;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.Cache
+{
+    public class OutputCacheMiddlewareTests
+    {
+        private readonly Mock<IOcelotCache<HttpResponseMessage>> _cacheManager;
+        private readonly Mock<IRequestScopedDataRepository> _scopedRepo;
+
+        private readonly string _url;
+        private readonly TestServer _server;
+        private readonly HttpClient _client;
+        private HttpResponseMessage _result;
+        private HttpResponseMessage _response;
+
+        public OutputCacheMiddlewareTests()
+        {
+            _cacheManager = new Mock<IOcelotCache<HttpResponseMessage>>();
+            _scopedRepo = new Mock<IRequestScopedDataRepository>();
+            _url = "http://localhost:51879";
+            var builder = new WebHostBuilder()
+                .ConfigureServices(x =>
+                {
+                    x.AddLogging();
+                    x.AddSingleton(_cacheManager.Object);
+                    x.AddSingleton(_scopedRepo.Object);
+                })
+                .UseUrls(_url)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .UseUrls(_url)
+                .Configure(app =>
+                {
+                    app.UseOutputCacheMiddleware();
+                });
+
+            _server = new TestServer(builder);
+            _client = _server.CreateClient();
+        }
+
+        [Fact]
+        public void should_returned_cached_item_when_it_is_in_cache()
+        {
+            this.Given(x => x.GivenThereIsACachedResponse(new HttpResponseMessage()))
+                .And(x => x.GivenTheDownstreamRouteIs())
+                .And(x => x.GivenThereIsADownstreamUrl())
+                .When(x => x.WhenICallTheMiddleware())
+                .Then(x => x.ThenTheCacheGetIsCalledCorrectly())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_continue_with_pipeline_and_cache_response()
+        {
+            this.Given(x => x.GivenResponseIsNotCached())
+                .And(x => x.GivenTheDownstreamRouteIs())
+                .And(x => x.GivenThereAreNoErrors())
+                .And(x => x.GivenThereIsADownstreamUrl())
+                .When(x => x.WhenICallTheMiddleware())
+                .Then(x => x.ThenTheCacheAddIsCalledCorrectly())
+                .BDDfy();
+        }
+
+        private void GivenTheDownstreamRouteIs()
+        {
+            var reRoute = new ReRouteBuilder().WithIsCached(true).WithCacheOptions(new CacheOptions(100)).Build();
+            var downstreamRoute = new DownstreamRoute(new List<UrlPathPlaceholderNameAndValue>(), reRoute);
+
+            _scopedRepo
+                .Setup(x => x.Get<DownstreamRoute>(It.IsAny<string>()))
+                .Returns(new OkResponse<DownstreamRoute>(downstreamRoute));
+        }
+
+        private void GivenThereAreNoErrors()
+        {
+            _scopedRepo
+                .Setup(x => x.Get<bool>("OcelotMiddlewareError"))
+                .Returns(new OkResponse<bool>(false));
+        }
+
+        private void GivenThereIsADownstreamUrl()
+        {
+            _scopedRepo
+                .Setup(x => x.Get<string>("DownstreamUrl"))
+                .Returns(new OkResponse<string>("anything"));
+        }
+
+        private void ThenTheCacheGetIsCalledCorrectly()
+        {
+            _cacheManager
+                .Verify(x => x.Get(It.IsAny<string>()), Times.Once);
+        }
+
+        private void ThenTheCacheAddIsCalledCorrectly()
+        {
+            _cacheManager
+                .Verify(x => x.Add(It.IsAny<string>(), It.IsAny<HttpResponseMessage>(), It.IsAny<TimeSpan>()), Times.Once);
+        }
+
+        private void GivenResponseIsNotCached()
+        {
+            _scopedRepo
+                .Setup(x => x.Get<HttpResponseMessage>("HttpResponseMessage"))
+                .Returns(new OkResponse<HttpResponseMessage>(new HttpResponseMessage()));
+        }
+
+        private void GivenThereIsACachedResponse(HttpResponseMessage response)
+        {
+            _response = response;
+            _cacheManager
+              .Setup(x => x.Get(It.IsAny<string>()))
+              .Returns(_response);
+        }
+
+        private void WhenICallTheMiddleware()
+        {
+            _result = _client.GetAsync(_url).Result;
+        }
+    }
+}

test/Ocelot.UnitTests/Errors/GobalErrorHandlerTests.cs

@@ -1,83 +0,0 @@
-/*
-using System;
-using System.IO;
-using System.Net.Http;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.AspNetCore.TestHost;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-using Moq;
-using Ocelot.Middleware;
-using Ocelot.RequestId.Provider;
-using TestStack.BDDfy;
-using Xunit;
-
-namespace Ocelot.UnitTests.Errors
-{
-    public class GobalErrorHandlerTests
-    {
-        private readonly Mock<ILoggerFactory> _loggerFactory;
-        private readonly Mock<ILogger<ExceptionHandlerMiddleware>> _logger;
-        private readonly Mock<IRequestIdProvider> _requestIdProvider;
-        private readonly string _url;
-        private readonly TestServer _server;
-        private readonly HttpClient _client;
-        private HttpResponseMessage _result;
-
-        public GobalErrorHandlerTests()
-        {
-            _url = "http://localhost:51879";
-            _logger = new Mock<ILogger<ExceptionHandlerMiddleware>>();
-            _loggerFactory = new Mock<ILoggerFactory>();
-            _requestIdProvider = new Mock<IRequestIdProvider>();
-            var builder = new WebHostBuilder()
-                .ConfigureServices(x =>
-                {
-                    x.AddSingleton(_requestIdProvider.Object);
-                    x.AddSingleton(_loggerFactory.Object);
-                })
-                .UseUrls(_url)
-                .UseKestrel()
-                .UseContentRoot(Directory.GetCurrentDirectory())
-                .UseIISIntegration()
-                .UseUrls(_url)
-                .Configure(app =>
-                {
-                    app.UseExceptionHandlerMiddleware();
-
-                    app.Run(x =>
-                    {
-                        throw new Exception("BLAM");
-                    });
-                });
-
-            _loggerFactory
-                .Setup(x => x.CreateLogger<ExceptionHandlerMiddleware>())
-                .Returns(_logger.Object);
-
-            _server = new TestServer(builder);
-            _client = _server.CreateClient();
-        }
-
-        [Fact]
-        public void should_catch_exception_and_log()
-        {
-            this.When(x => x.WhenICallTheMiddleware())
-                .And(x => x.TheLoggerIsCalledCorrectly())
-                .BDDfy();
-        }
-
-        private void TheLoggerIsCalledCorrectly()
-        {
-            _logger
-                .Verify(x => x.LogError(It.IsAny<EventId>(), It.IsAny<string>(), It.IsAny<Exception>()), Times.Once);
-        }
-
-        private void WhenICallTheMiddleware()
-        {
-            _result = _client.GetAsync(_url).Result;
-        }
-    }
-}
-*/

test/Ocelot.UnitTests/Infrastructure/ClaimParserTests.cs

@@ -4,7 +4,6 @@ namespace Ocelot.UnitTests.Infrastructure
 {
     using System.Collections.Generic;
     using System.Security.Claims;
-    using Errors;
     using Ocelot.Infrastructure.Claims.Parser;
     using Responses;
     using Shouldly;

test/Ocelot.UnitTests/Requester/HttpRequesterMiddlewareTests.cs

@@ -27,19 +27,16 @@ namespace Ocelot.UnitTests.Requester
         private HttpResponseMessage _result;
         private OkResponse<HttpResponseMessage> _response;
         private OkResponse<Ocelot.Request.Request> _request;
-        private readonly Mock<IHttpResponder> _responder;
 
         public HttpRequesterMiddlewareTests()
         {
             _url = "http://localhost:51879";
             _requester = new Mock<IHttpRequester>();
             _scopedRepository = new Mock<IRequestScopedDataRepository>();
-            _responder = new Mock<IHttpResponder>();
 
             var builder = new WebHostBuilder()
               .ConfigureServices(x =>
               {
-                  x.AddSingleton(_responder.Object);
                   x.AddSingleton(_requester.Object);
                   x.AddSingleton(_scopedRepository.Object);
               })
@@ -62,9 +59,9 @@ namespace Ocelot.UnitTests.Requester
         {
             this.Given(x => x.GivenTheRequestIs(new Ocelot.Request.Request(new HttpRequestMessage(),new CookieContainer())))
                 .And(x => x.GivenTheRequesterReturns(new HttpResponseMessage()))
-                .And(x => x.GivenTheResponderReturns())
+                .And(x => x.GivenTheScopedRepoReturns())
                 .When(x => x.WhenICallTheMiddleware())
-                .Then(x => x.ThenTheResponderIsCalledCorrectly())
+                .Then(x => x.ThenTheScopedRepoIsCalledCorrectly())
                 .BDDfy();
         }
 
@@ -76,17 +73,17 @@ namespace Ocelot.UnitTests.Requester
                 .ReturnsAsync(_response);
         }
 
-        private void GivenTheResponderReturns()
+        private void GivenTheScopedRepoReturns()
         {
-            _responder
-                .Setup(x => x.SetResponseOnHttpContext(It.IsAny<HttpContext>(), _response.Data))
-                .ReturnsAsync(new OkResponse());
+            _scopedRepository
+                .Setup(x => x.Add(It.IsAny<string>(), _response.Data))
+                .Returns(new OkResponse());
         }
 
-        private void ThenTheResponderIsCalledCorrectly()
+        private void ThenTheScopedRepoIsCalledCorrectly()
         {
-            _responder
-                .Verify(x => x.SetResponseOnHttpContext(It.IsAny<HttpContext>(), _response.Data), Times.Once());
+            _scopedRepository
+                .Verify(x => x.Add("HttpResponseMessage", _response.Data), Times.Once());
         }
 
         private void WhenICallTheMiddleware()

test/Ocelot.UnitTests/Responder/HttpErrorResponderMiddlewareTests.cs

@@ -59,11 +59,19 @@ namespace Ocelot.UnitTests.Responder
         {
             this.Given(x => x.GivenTheHttpResponseMessageIs(new HttpResponseMessage()))
                 .And(x => x.GivenThereAreNoPipelineErrors())
+                .And(x => x.GivenTheResponderReturns())
                 .When(x => x.WhenICallTheMiddleware())
                 .Then(x => x.ThenThereAreNoErrors())
                 .BDDfy();
         }
 
+        private void GivenTheResponderReturns()
+        {
+            _responder
+                .Setup(x => x.SetResponseOnHttpContext(It.IsAny<HttpContext>(), It.IsAny<HttpResponseMessage>()))
+                .ReturnsAsync(new OkResponse());
+        }
+
         private void GivenThereAreNoPipelineErrors()
         {
             _scopedRepository