Made changes based on PR comments. Also added lots more tests!

2025-06-19 01:58:15 +08:00 · 2017-04-19 20:12:08 +01:00
parent 878eacf1db
commit 80e728aa00
9 changed files with 478 additions and 44 deletions
--- a/test/Ocelot.UnitTests/Request/DownstreamRequestInitialiserMiddlewareTests.cs
+++ b/test/Ocelot.UnitTests/Request/DownstreamRequestInitialiserMiddlewareTests.cs
@ -0,0 +1,142 @@
+namespace Ocelot.UnitTests.Request
+{
+    using System.Net.Http;
+    using Microsoft.AspNetCore.Http;
+    using Moq;
+    using Ocelot.Logging;
+    using Ocelot.Request.Mapper;
+    using Ocelot.Request.Middleware;
+    using Ocelot.Infrastructure.RequestData;
+    using TestStack.BDDfy;
+    using Xunit;
+    using Ocelot.Responses;
+
+    public class DownstreamRequestInitialiserMiddlewareTests
+    {
+        readonly DownstreamRequestInitialiserMiddleware _middleware;
+
+        readonly Mock<HttpContext> _httpContext;
+
+        readonly Mock<HttpRequest> _httpRequest;
+
+        readonly Mock<RequestDelegate> _next;
+
+        readonly Mock<IRequestMapper> _requestMapper;
+
+        readonly Mock<IRequestScopedDataRepository> _repo;
+
+        readonly Mock<IOcelotLoggerFactory> _loggerFactory;
+
+        readonly Mock<IOcelotLogger> _logger;
+
+        Response<HttpRequestMessage> _mappedRequest;
+
+        public DownstreamRequestInitialiserMiddlewareTests()
+        {
+
+            _httpContext = new Mock<HttpContext>();
+            _httpRequest = new Mock<HttpRequest>();
+            _requestMapper = new Mock<IRequestMapper>();
+            _repo = new Mock<IRequestScopedDataRepository>();
+            _next = new Mock<RequestDelegate>();
+            _logger = new Mock<IOcelotLogger>();
+
+            _loggerFactory = new Mock<IOcelotLoggerFactory>();
+            _loggerFactory
+                .Setup(lf => lf.CreateLogger<DownstreamRequestInitialiserMiddleware>())
+                .Returns(_logger.Object);
+
+            _middleware = new DownstreamRequestInitialiserMiddleware(
+                _next.Object, 
+                _loggerFactory.Object, 
+                _repo.Object, 
+                _requestMapper.Object);
+        }
+
+        [Fact]
+        public void Should_handle_valid_httpRequest()
+        {
+            this.Given(_ => GivenTheHttpContextContainsARequest())
+                .And(_ => GivenTheMapperWillReturnAMappedRequest())
+                .When(_ => WhenTheMiddlewareIsInvoked())
+                .Then(_ => ThenTheContexRequestIsMappedToADownstreamRequest())
+                .And(_ => ThenTheDownstreamRequestIsStored())
+                .And(_ => ThenTheNextMiddlewareIsInvoked())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void Should_handle_mapping_failure()
+        {
+            this.Given(_ => GivenTheHttpContextContainsARequest())
+                .And(_ => GivenTheMapperWillReturnAnError())
+                .When(_ => WhenTheMiddlewareIsInvoked())
+                .And(_ => ThenTheDownstreamRequestIsNotStored())
+                .And(_ => ThenAPipelineErrorIsStored())
+                .And(_ => ThenTheNextMiddlewareIsNotInvoked())
+                .BDDfy();
+        }
+
+        private void GivenTheHttpContextContainsARequest()
+        {
+            _httpContext
+                .Setup(hc => hc.Request)
+                .Returns(_httpRequest.Object);
+        }
+
+        private void GivenTheMapperWillReturnAMappedRequest()
+        {
+            _mappedRequest = new OkResponse<HttpRequestMessage>(new HttpRequestMessage());
+
+            _requestMapper
+                .Setup(rm => rm.Map(It.IsAny<HttpRequest>()))
+                .ReturnsAsync(_mappedRequest);
+        }
+
+        private void GivenTheMapperWillReturnAnError()
+        {
+            _mappedRequest = new ErrorResponse<HttpRequestMessage>(new UnmappableRequestError(new System.Exception("boooom!")));
+
+            _requestMapper
+                .Setup(rm => rm.Map(It.IsAny<HttpRequest>()))
+                .ReturnsAsync(_mappedRequest);
+        }
+
+        private void WhenTheMiddlewareIsInvoked()
+        {
+           _middleware.Invoke(_httpContext.Object).GetAwaiter().GetResult();
+        }
+
+        private void ThenTheContexRequestIsMappedToADownstreamRequest()
+        {
+            _requestMapper.Verify(rm => rm.Map(_httpRequest.Object), Times.Once);
+        }
+
+        private void ThenTheDownstreamRequestIsStored()
+        {
+            _repo.Verify(r => r.Add("DownstreamRequest", _mappedRequest.Data), Times.Once);
+        }
+
+        private void ThenTheDownstreamRequestIsNotStored()
+        {
+            _repo.Verify(r => r.Add("DownstreamRequest", It.IsAny<HttpRequestMessage>()), Times.Never);
+        }
+
+        private void ThenAPipelineErrorIsStored()
+        {
+            _repo.Verify(r => r.Add("OcelotMiddlewareError", true), Times.Once);
+            _repo.Verify(r => r.Add("OcelotMiddlewareErrors", _mappedRequest.Errors), Times.Once);
+        }
+
+        private void ThenTheNextMiddlewareIsInvoked()
+        {
+            _next.Verify(n => n(_httpContext.Object), Times.Once);
+        }
+
+        private void ThenTheNextMiddlewareIsNotInvoked()
+        {
+            _next.Verify(n => n(It.IsAny<HttpContext>()), Times.Never);
+        }
+
+    }
+}