Added some basic cache stuff

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