Moved common middleare test setup into a base class

test/Ocelot.UnitTests/Responder/HttpContextResponderTests.cs

@@ -0,0 +1,98 @@
+using Microsoft.AspNetCore.Http;
+using Moq;
+using Ocelot.Headers;
+using Ocelot.Responder;
+using Shouldly;
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using TestStack.BDDfy;
+using Xunit;
+using System.IO;
+using System.Net;
+using System.Threading.Tasks;
+
+namespace Ocelot.UnitTests.Responder
+{
+    public class HttpContextResponderTests
+    {
+        readonly HttpContextResponder _responder;
+
+        readonly Mock<IRemoveOutputHeaders> _removeOutputHeaders;
+
+        HttpContext _httpContext;
+
+        HttpResponseMessage _httpResponseMessage;
+
+        public HttpContextResponderTests()
+        {
+            _removeOutputHeaders = new Mock<IRemoveOutputHeaders>();
+            _httpContext = new DefaultHttpContext();
+            _httpResponseMessage = new HttpResponseMessage();
+            _httpResponseMessage.Content = new MyHttpContent();
+            _responder = new HttpContextResponder(_removeOutputHeaders.Object);
+        }
+
+        [Fact]
+        public void DoSomething()
+        {
+            this.Given(_ => GivenTheHttpResponseMessageHasHeader("abc","123"))
+                .And(_ => GivenTheHttpResponseMessageHasHeader("def", new[] { "456", "789" }))
+                .And(_ => GivenTheContextResponseHasHeader("abc", "123"))
+                .When(_ => WhenWeSetTheResponseOnAnHttpContext())
+                .Then(_ => ThenSupportedHeadersAreAddedToTheContextResponse())
+                .And(_ => ThenUnsupportedHeadersAreNotAddedToTheResponse())
+                .BDDfy();
+        }
+
+
+        private void GivenTheHttpResponseMessageHasHeader(string name, string value)
+        {
+            _httpResponseMessage.Headers.Add(name, value);
+        }
+
+        private void GivenTheHttpResponseMessageHasHeader(string name, IEnumerable<string> values)
+        {
+            _httpResponseMessage.Headers.Add(name, values);
+        }
+
+        private void GivenTheContextResponseHasHeader(string name, string value)
+        {
+            _httpContext.Response.Headers.Add(name, value);
+        }
+
+        private void WhenWeSetTheResponseOnAnHttpContext()
+        {
+            _responder.SetResponseOnHttpContext(_httpContext, _httpResponseMessage).GetAwaiter().GetResult();
+        }
+
+        private void ThenSupportedHeadersAreAddedToTheContextResponse()
+        {
+            _httpContext.Response.Headers.Count.ShouldBe(2);
+            _httpContext.Response.Headers.ShouldContain(h => h.Key == "abc" && h.Value == "123");
+            _httpContext.Response.Headers.ShouldContain(h => h.Key == "def" && h.Value == "456, 789");
+        }
+
+        private void ThenUnsupportedHeadersAreNotAddedToTheResponse()
+        {
+            _removeOutputHeaders.Verify(roh => roh.Remove(_httpResponseMessage.Headers), Times.Once);
+        }
+
+
+        class MyHttpContent : HttpContent
+        {
+            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
+            {
+                return Task.CompletedTask;
+            }
+
+            protected override bool TryComputeLength(out long length)
+            {
+                length = 0;
+                return true;
+            }
+        }
+
+    }
+}

test/Ocelot.UnitTests/Responder/ResponderMiddlewareTests.cs

@@ -1,11 +1,6 @@
-using System;
-using System.IO;
-using System.Net.Http;
+using System.Net.Http;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.TestHost;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
 using Moq;
 using Ocelot.Infrastructure.RequestData;
 using Ocelot.Logging;
@@ -14,77 +9,109 @@ using Ocelot.Responder.Middleware;
 using Ocelot.Responses;
 using TestStack.BDDfy;
 using Xunit;
+using Microsoft.AspNetCore.Builder;
+using Shouldly;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using System.Collections.Generic;
+using Ocelot.Errors;
+using System.Net;
+using Ocelot.Headers;
 
 namespace Ocelot.UnitTests.Responder
 {
-    public class ResponderMiddlewareTests : IDisposable
+    public class ResponderMiddlewareTests : ServerHostedMiddlewareTest
     {
-        private readonly Mock<IHttpResponder> _responder;
+        private readonly IHttpResponder _responder;
         private readonly Mock<IRequestScopedDataRepository> _scopedRepository;
         private readonly Mock<IErrorsToHttpStatusCodeMapper> _codeMapper;
-        private readonly string _url;
-        private readonly TestServer _server;
-        private readonly HttpClient _client;
-        private HttpResponseMessage _result;
+        private readonly Mock<IRemoveOutputHeaders> _outputHeaderRemover;
+        private HttpStatusCode _httpStatusFromController;
+        private string _contentFromController;
+
         private OkResponse<HttpResponseMessage> _response;
+        private List<Error> _pipelineErrors;
 
         public ResponderMiddlewareTests()
         {
-            _url = "http://localhost:51879";
-            _responder = new Mock<IHttpResponder>();
+            _outputHeaderRemover = new Mock<IRemoveOutputHeaders>();
+            _responder = new HttpContextResponder(_outputHeaderRemover.Object);
             _scopedRepository = new Mock<IRequestScopedDataRepository>();
             _codeMapper = new Mock<IErrorsToHttpStatusCodeMapper>();
-            var builder = new WebHostBuilder()
-              .ConfigureServices(x =>
-              {
-                  x.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
-                  x.AddLogging();
-                  x.AddSingleton(_codeMapper.Object);
-                  x.AddSingleton(_responder.Object);
-                  x.AddSingleton(_scopedRepository.Object);
-              })
-              .UseUrls(_url)
-              .UseKestrel()
-              .UseContentRoot(Directory.GetCurrentDirectory())
-              .UseIISIntegration()
-              .UseUrls(_url)
-              .Configure(app =>
-              {
-                  app.UseResponderMiddleware();
-              });
 
-            _server = new TestServer(builder);
-            _client = _server.CreateClient();
+            GivenTheTestServerIsConfigured();
         }
 
         [Fact]
-        public void should_not_return_any_errors()
+        public void PipelineErrors()
         {
-            this.Given(x => x.GivenTheHttpResponseMessageIs(new HttpResponseMessage()))
+            var responseMessage = new HttpResponseMessage(System.Net.HttpStatusCode.Continue);
+
+            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())
                 .BDDfy();
         }
 
+        protected override void GivenTheTestServerServicesAreConfigured(IServiceCollection services)
+        {
+            services.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
+            services.AddLogging();
+            services.AddSingleton(_codeMapper.Object);
+            services.AddSingleton(_responder);
+            services.AddSingleton(_scopedRepository.Object);
+        }
+
+        protected override void GivenTheTestServerPipelineIsConfigured(IApplicationBuilder app)
+        {
+            app.UseResponderMiddleware();
+            app.Run(SetControllerResponse);
+        }
+
+        private async Task SetControllerResponse(HttpContext context)
+        {
+            _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>(It.IsAny<string>()))
-                .Returns(new OkResponse<bool>(false));
+                .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 ThenThereAreNoErrors()
-        {
-            //todo a better assert?
-        }
-
-        private void WhenICallTheMiddleware()
-        {
-            _result = _client.GetAsync(_url).Result;
-        }
-
-        private void GivenTheHttpResponseMessageIs(HttpResponseMessage response)
+        private void GivenTheIncomingHttpResponseMessageIs(HttpResponseMessage response)
         {
             _response = new OkResponse<HttpResponseMessage>(response);
             _scopedRepository
@@ -92,10 +119,21 @@ namespace Ocelot.UnitTests.Responder
                 .Returns(_response);
         }
 
-        public void Dispose()
+        private void GivenTheErrorWillBeMappedToAnHttpStatus()
         {
-            _client.Dispose();
-            _server.Dispose();
+            _codeMapper.Setup(cm => cm.Map(_pipelineErrors))
+                .Returns((int)HttpStatusCode.InternalServerError);
+        }
+
+        private void ThenThereAreNoErrors()
+        {
+            ResponseMessage.StatusCode.ShouldBe(_httpStatusFromController);
+            ResponseMessage.Content.ReadAsStringAsync().Result.ShouldBe(_contentFromController);
+        }
+
+        private void ThenThereAreErrors()
+        {
+            ResponseMessage.StatusCode.ShouldBe(System.Net.HttpStatusCode.BadRequest);
         }
     }
 }

test/Ocelot.UnitTests/Responder/ResponderMiddlewareTestsV2.cs

@@ -15,6 +15,7 @@ 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;
@@ -22,7 +23,6 @@ namespace Ocelot.UnitTests.Responder
         private readonly Mock<IOcelotLoggerFactory> _loggerFactory;
         private readonly Mock<IOcelotLogger> _logger;
         private readonly Mock<HttpContext> _httpContext;
-        private ResponderMiddleware _middleware;
         private OkResponse<HttpResponseMessage> _response;
         private int _mappedStatusCode;
         private List<Error> _pipelineErrors;