Refactor ExceptionHandlerMiddleware tests to use base class.

test/Ocelot.UnitTests/Errors/ExceptionHandlerMiddlewareTests.cs

@@ -1,125 +1,87 @@
+namespace Ocelot.UnitTests.Errors
+{
     using System;
-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.TestHost;
     using Microsoft.Extensions.DependencyInjection;
-using Moq;
     using Ocelot.Errors.Middleware;
-using Ocelot.Infrastructure.RequestData;
     using Ocelot.Logging;
     using Shouldly;
     using TestStack.BDDfy;
     using Xunit;
-using System.Threading.Tasks;
+    using Microsoft.AspNetCore.Http;
 
-namespace Ocelot.UnitTests.Errors
+    public class ExceptionHandlerMiddlewareTests : ServerHostedMiddlewareTest
     {
-    public class ExceptionHandlerMiddlewareTests
-    {
-        private readonly Mock<IRequestScopedDataRepository> _scopedRepository;
-        private readonly string _url;
-        private TestServer _server;
-        private HttpClient _client;
-        private HttpResponseMessage _result;
+        bool _shouldThrowAnException = false;
 
         public ExceptionHandlerMiddlewareTests()
         {
-            _url = "http://localhost:52879";
-            _scopedRepository = new Mock<IRequestScopedDataRepository>();
+            GivenTheTestServerIsConfigured();
         }
         
         [Fact]
-        public void should_call_next_middleware()
+        public void NoDownstreamException()
         {
-            this.Given(_ => GivenASuccessfulRequest())
-                .When(_ => WhenIMakeTheRequest())
+            this.Given(_ => GivenAnExceptionWillNotBeThrownDownstream())
+                .When(_ => WhenICallTheMiddleware())
                 .Then(_ => ThenTheResponseIsOk())
                 .BDDfy();
         }
 
         [Fact]
-        public void should_call_return_error()
+        public void DownstreamException()
         {
-            this.Given(_ => GivenAnError())
-                .When(_ => WhenIMakeTheRequest())
+            this.Given(_ => GivenAnExceptionWillBeThrownDownstream())
+                .When(_ => WhenICallTheMiddleware())
                 .Then(_ => ThenTheResponseIsError())
                 .BDDfy();
         }
 
-        private void GivenAnError()
+        protected override void GivenTheTestServerServicesAreConfigured(IServiceCollection services)
         {
-            var builder = new WebHostBuilder()
-              .ConfigureServices(x =>
-              {
-                  x.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
-                  x.AddLogging();
-                  x.AddSingleton(_scopedRepository.Object);
-              })
-              .UseUrls(_url)
-              .UseKestrel()
-              .UseContentRoot(Directory.GetCurrentDirectory())
-              .UseIISIntegration()
-              .UseUrls(_url)
-              .Configure(app =>
+            services.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
+            services.AddLogging();
+            services.AddSingleton(ScopedRepository.Object);
+        }
+
+        protected override void GivenTheTestServerPipelineIsConfigured(IApplicationBuilder app)
         {
             app.UseExceptionHandlerMiddleware();
-                  app.Use(async (context, next) =>
+            app.Run(DownstreamExceptionSimulator);
+        }
+
+        private async Task DownstreamExceptionSimulator(HttpContext context)
         {
             await Task.CompletedTask;
-                      throw new Exception("BOOM");
-                  });
-              });
 
-            _server = new TestServer(builder);
-            _client = _server.CreateClient();
+            if (_shouldThrowAnException)
+            {
+                throw new Exception("BOOM");
+            }
+
+            context.Response.StatusCode = (int)HttpStatusCode.OK;
+        }
+
+        private void GivenAnExceptionWillNotBeThrownDownstream()
+        {
+            _shouldThrowAnException = false;
+        }
+
+        private void GivenAnExceptionWillBeThrownDownstream()
+        {
+            _shouldThrowAnException = true;
         }
 
         private void ThenTheResponseIsOk()
         {
-            _result.StatusCode.ShouldBe(HttpStatusCode.OK);
+            ResponseMessage.StatusCode.ShouldBe(HttpStatusCode.OK);
         }
 
         private void ThenTheResponseIsError()
         {
-            _result.StatusCode.ShouldBe(HttpStatusCode.InternalServerError);
-        }
-
-        private void WhenIMakeTheRequest()
-        {
-            _result = _client.GetAsync("/").Result;
-        }
-
-        private void GivenASuccessfulRequest()
-        {
-            var builder = new WebHostBuilder()
-              .ConfigureServices(x =>
-              {
-                  x.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
-                  x.AddLogging();
-                  x.AddSingleton(_scopedRepository.Object);
-              })
-              .UseUrls(_url)
-              .UseKestrel()
-              .UseContentRoot(Directory.GetCurrentDirectory())
-              .UseIISIntegration()
-              .UseUrls(_url)
-              .Configure(app =>
-              {
-                  app.UseExceptionHandlerMiddleware();
-                  app.Run(async context =>
-                    {
-                        await Task.CompletedTask;
-                        context.Response.StatusCode = 200;
-                    });
-              });
-
-            _server = new TestServer(builder);
-            _client = _server.CreateClient();
-        }
-
-
+            ResponseMessage.StatusCode.ShouldBe(HttpStatusCode.InternalServerError);
+        }
     }
 }