Back out of some of the functional changes to the ResponderMiddleware tests... I'll look at these again once the consolidation changes are merged.

test/Ocelot.UnitTests/Responder/ResponderMiddlewareTests.cs

@@ -1,62 +1,34 @@
 namespace Ocelot.UnitTests.Responder
 {
     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 Moq;
-    using Ocelot.Errors;
-    using Ocelot.Headers;
     using Ocelot.Logging;
     using Ocelot.Responder;
     using Ocelot.Responder.Middleware;
     using Ocelot.Responses;
-    using Shouldly;
-    using System.Collections.Generic;
-    using System.Net;
     using TestStack.BDDfy;
     using Xunit;
 
     public class ResponderMiddlewareTests : ServerHostedMiddlewareTest
     {
-        private readonly IHttpResponder _responder;
+        private readonly Mock<IHttpResponder> _responder;
         private readonly Mock<IErrorsToHttpStatusCodeMapper> _codeMapper;
-        private readonly Mock<IRemoveOutputHeaders> _outputHeaderRemover;
-        private HttpStatusCode _httpStatusFromController;
-        private string _contentFromController;
-
         private OkResponse<HttpResponseMessage> _response;
-        private List<Error> _pipelineErrors;
 
         public ResponderMiddlewareTests()
         {
-            _outputHeaderRemover = new Mock<IRemoveOutputHeaders>();
+            _responder = new Mock<IHttpResponder>();
             _codeMapper = new Mock<IErrorsToHttpStatusCodeMapper>();
 
-            _responder = new HttpContextResponder(_outputHeaderRemover.Object);
-
             GivenTheTestServerIsConfigured();
         }
 
         [Fact]
-        public void PipelineErrors()
+        public void should_not_return_any_errors()
         {
-            var responseMessage = new HttpResponseMessage(System.Net.HttpStatusCode.Continue);
+            this.Given(x => x.GivenTheHttpResponseMessageIs(new HttpResponseMessage()))
-
-            this.Given(x => x.GivenTheIncomingHttpResponseMessageIs(new HttpResponseMessage()))
-                .And(x => x.GivenThereArePipelineErrors())
-                .And(x => x.GivenTheErrorWillBeMappedToAnHttpStatus())
-                .When(x => x.WhenICallTheMiddleware())
-                .Then(x => x.ThenThereAreErrors())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void NoPipelineErrors()
-        {
-            this.Given(x => x.GivenTheIncomingHttpResponseMessageIs(new HttpResponseMessage()))
                 .And(x => x.GivenThereAreNoPipelineErrors())
                 .When(x => x.WhenICallTheMiddleware())
                 .Then(x => x.ThenThereAreNoErrors())
@@ -68,48 +40,16 @@
             services.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
             services.AddLogging();
             services.AddSingleton(_codeMapper.Object);
-            services.AddSingleton(_responder);
+            services.AddSingleton(_responder.Object);
             services.AddSingleton(ScopedRepository.Object);
         }
 
         protected override void GivenTheTestServerPipelineIsConfigured(IApplicationBuilder app)
         {
             app.UseResponderMiddleware();
-            app.Run(SetControllerResponse);
         }
 
-        private async Task SetControllerResponse(HttpContext context)
+        private void GivenTheHttpResponseMessageIs(HttpResponseMessage response)
-        {
-            _httpStatusFromController = HttpStatusCode.OK;
-            _contentFromController = "test response";
-            context.Response.StatusCode = (int)_httpStatusFromController;
-            await context.Response.WriteAsync(_contentFromController);
-        }
-
-        private void GivenThereAreNoPipelineErrors()
-        {
-            GivenThereArePipelineErrors(new List<Error>());
-        }
-
-        private void GivenThereArePipelineErrors()
-        {
-            GivenThereArePipelineErrors(new List<Error>() { new AnyError() });
-        }
-
-        private void GivenThereArePipelineErrors(List<Error> pipelineErrors)
-        {
-            _pipelineErrors = pipelineErrors;
-
-            ScopedRepository
-                .Setup(x => x.Get<bool>("OcelotMiddlewareError"))
-                .Returns(new OkResponse<bool>(_pipelineErrors.Count != 0));
-
-            ScopedRepository
-                .Setup(sr => sr.Get<List<Error>>("OcelotMiddlewareErrors"))
-                .Returns(new OkResponse<List<Error>>(_pipelineErrors));
-        }
-
-        private void GivenTheIncomingHttpResponseMessageIs(HttpResponseMessage response)
         {
             _response = new OkResponse<HttpResponseMessage>(response);
             ScopedRepository
@@ -117,21 +57,16 @@
                 .Returns(_response);
         }
 
-        private void GivenTheErrorWillBeMappedToAnHttpStatus()
+        private void GivenThereAreNoPipelineErrors()
         {
-            _codeMapper.Setup(cm => cm.Map(_pipelineErrors))
+            ScopedRepository
-                .Returns((int)HttpStatusCode.InternalServerError);
+                .Setup(x => x.Get<bool>(It.IsAny<string>()))
+                .Returns(new OkResponse<bool>(false));
         }
 
         private void ThenThereAreNoErrors()
         {
-            ResponseMessage.StatusCode.ShouldBe(_httpStatusFromController);
+            //todo a better assert?
-            ResponseMessage.Content.ReadAsStringAsync().Result.ShouldBe(_contentFromController);
-        }
-
-        private void ThenThereAreErrors()
-        {
-            ResponseMessage.StatusCode.ShouldBe(System.Net.HttpStatusCode.BadRequest);
         }
     }
 }

test/Ocelot.UnitTests/Responder/ResponderMiddlewareTestsV2.cs

@@ -1,140 +0,0 @@
-using System.Collections.Generic;
-using System.Net.Http;
-using Microsoft.AspNetCore.Http;
-using Moq;
-using Ocelot.Infrastructure.RequestData;
-using Ocelot.Errors;
-using Ocelot.Logging;
-using Ocelot.Responder;
-using Ocelot.Responder.Middleware;
-using Ocelot.Responses;
-using TestStack.BDDfy;
-using Xunit;
-
-namespace Ocelot.UnitTests.Responder
-{
-    public class ResponderMiddlewareTestsV2
-    {
-        private readonly ResponderMiddleware _middleware;
-        private readonly Mock<IHttpResponder> _responder;
-        private readonly Mock<IRequestScopedDataRepository> _scopedRepository;
-        private readonly Mock<IErrorsToHttpStatusCodeMapper> _codeMapper;
-        private readonly Mock<RequestDelegate> _next;
-        private readonly Mock<IOcelotLoggerFactory> _loggerFactory;
-        private readonly Mock<IOcelotLogger> _logger;
-        private readonly Mock<HttpContext> _httpContext;
-        private OkResponse<HttpResponseMessage> _response;
-        private int _mappedStatusCode;
-        private List<Error> _pipelineErrors;
-
-        public ResponderMiddlewareTestsV2()
-        {
-            _responder = new Mock<IHttpResponder>();
-            _codeMapper = new Mock<IErrorsToHttpStatusCodeMapper>();
-            _next = new Mock<RequestDelegate>();
-            _logger = new Mock<IOcelotLogger>();
-            _scopedRepository = new Mock<IRequestScopedDataRepository>();
-            _loggerFactory = new Mock<IOcelotLoggerFactory>();
-            _httpContext = new Mock<HttpContext>();
-
-            _loggerFactory
-                .Setup(lf => lf.CreateLogger<ResponderMiddleware>())
-                .Returns(_logger.Object);
-
-            _middleware = new ResponderMiddleware(_next.Object, _responder.Object, _loggerFactory.Object, _scopedRepository.Object, _codeMapper.Object);
-
-            GivenTheHttpResponseMessageIs(new HttpResponseMessage());
-        }
-
-        [Fact]
-        public void NoPipelineErrors()
-        {
-            this.Given(x => x.GivenThereAreNoPipelineErrors())
-                .When(x => x.WhenICallTheMiddleware())
-                .Then(_ => ThenTheNextMiddlewareIsCalled())
-                .And(x => x.ThenThereAreNoErrorsOnTheHttpContext())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void PipelineErrors()
-        {
-            this.Given(_ => GivenThereArePipelineErrors())
-                .And(_ => GivenTheErrorsCanBeMappedToAStatusCode())
-                .When(_ => WhenICallTheMiddleware())
-                .Then(_ => ThenTheNextMiddlewareIsCalled())
-                .And(x => x.ThenTheErrorsAreLogged())
-                .And(_ => ThenTheErrorsAreMappedToAnHttpStatus())
-                .And(_ => ThenAnErrorResponseIsSetOnTheHttpContext())
-                .BDDfy();
-        }
-
-        private void GivenTheHttpResponseMessageIs(HttpResponseMessage response)
-        {
-            _response = new OkResponse<HttpResponseMessage>(response);
-            _scopedRepository
-                .Setup(x => x.Get<HttpResponseMessage>(It.IsAny<string>()))
-                .Returns(_response);
-        }
-
-        private void GivenThereAreNoPipelineErrors()
-        {
-            GivenThereArePipelineErrors(new List<Error>());
-        }
-
-        private void GivenThereArePipelineErrors()
-        {
-            GivenThereArePipelineErrors(new List<Error>() { new AnyError() });
-        }
-
-        private void GivenThereArePipelineErrors(List<Error> pipelineErrors)
-        {
-            _pipelineErrors = pipelineErrors;
-
-            _scopedRepository
-                .Setup(x => x.Get<bool>("OcelotMiddlewareError"))
-                .Returns(new OkResponse<bool>(_pipelineErrors.Count != 0));
-
-            _scopedRepository
-                .Setup(sr => sr.Get<List<Error>>("OcelotMiddlewareErrors"))
-                .Returns(new OkResponse<List<Error>>(_pipelineErrors));
-        }
-
-        private void GivenTheErrorsCanBeMappedToAStatusCode()
-        {
-            _mappedStatusCode = 500; //TODO: autofixture
-            _codeMapper.Setup(cm => cm.Map(It.IsAny<List<Error>>()))
-            .Returns(_mappedStatusCode);
-        }
-
-        private void WhenICallTheMiddleware()
-        {
-            _middleware.Invoke(_httpContext.Object).GetAwaiter().GetResult();
-        }
-
-        private void ThenTheNextMiddlewareIsCalled()
-        {
-            _next.Verify(n => n(_httpContext.Object), Times.Once);
-        }
-
-        private void ThenTheErrorsAreMappedToAnHttpStatus()
-        {
-            _codeMapper.Verify(cm => cm.Map(_pipelineErrors), Times.Once);
-        }
-
-        private void ThenTheErrorsAreLogged()
-        {
-            _logger.Verify(l => l.LogError($"{_pipelineErrors.Count} pipeline errors found in ResponderMiddleware. Setting error response status code"), Times.Once);
-        }
-
-        private void ThenThereAreNoErrorsOnTheHttpContext()
-        {
-            _responder.Verify(r => r.SetErrorResponseOnContext(It.IsAny<HttpContext>(), It.IsAny<int>()), Times.Never);
-        }
-
-        private void ThenAnErrorResponseIsSetOnTheHttpContext()
-        {
-            _responder.Verify(r => r.SetErrorResponseOnContext(_httpContext.Object, _mappedStatusCode), Times.Once);
-        }
-    }
-}