check which version of .net framework before creating http handler (#412)

* #405 needto check which version of .net we are using but cannot use compiler directives * #405 started puttig abstraction around static method to get frameworks so we can test this logic * #405 added test for all methods and tidied up tests * #405 made contains as ms docs are wrong, thanks to davidni for the heads up
2025-11-04 23:30:50 +08:00 · 2018-06-20 20:44:38 +01:00
parent b5a827cf70
commit e636cefdb1
12 changed files with 366 additions and 199 deletions
--- a/test/Ocelot.UnitTests/Ocelot.UnitTests.csproj
+++ b/test/Ocelot.UnitTests/Ocelot.UnitTests.csproj
@@ -28,6 +28,15 @@
  <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
  </ItemGroup>

+    <ItemGroup>
+    <None Update="appsettings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="idsrv3test.pfx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.8" />
    <PackageReference Include="Microsoft.AspNetCore.TestHost" Version="2.0.3" />
--- a/test/Ocelot.UnitTests/Request/Creator/DownstreamRequestCreatorTests.cs
+++ b/test/Ocelot.UnitTests/Request/Creator/DownstreamRequestCreatorTests.cs
@@ -0,0 +1,93 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Moq;
+using Ocelot.Infrastructure;
+using Ocelot.Request.Creator;
+using Ocelot.Request.Middleware;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.Request.Creator
+{
+    public class DownstreamRequestCreatorTests
+    {
+        private Mock<IFrameworkDescription> _framework;
+        private DownstreamRequestCreator _downstreamRequestCreator;
+        private HttpRequestMessage _request;
+        private DownstreamRequest _result;
+
+        public DownstreamRequestCreatorTests()
+        {
+            _framework = new Mock<IFrameworkDescription>();
+            _downstreamRequestCreator = new DownstreamRequestCreator(_framework.Object);
+        }
+
+        [Fact]
+        public void should_create_downstream_request()
+        {
+            var request = new HttpRequestMessage(HttpMethod.Get, "http://www.test.com");
+            var content = new StringContent("test");
+            request.Content = content;
+
+            this.Given(_ => GivenTheFrameworkIs(""))
+                .And(_ => GivenTheRequestIs(request))
+                .When(_ => WhenICreate())
+                .Then(_ => ThenTheDownstreamRequestHasABody())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_remove_body_for_http_methods()
+        {
+            var methods = new List<HttpMethod> { HttpMethod.Get, HttpMethod.Head, HttpMethod.Delete, HttpMethod.Trace };
+            var request = new HttpRequestMessage(HttpMethod.Get, "http://www.test.com");
+            var content = new StringContent("test");
+            request.Content = content;
+
+            methods.ForEach(m => {
+                this.Given(_ => GivenTheFrameworkIs(".NET Framework"))
+                    .And(_ => GivenTheRequestIs(request))
+                    .When(_ => WhenICreate())
+                    .Then(_ => ThenTheDownstreamRequestDoesNotHaveABody())
+                    .BDDfy();
+            });
+        }
+
+        private void GivenTheFrameworkIs(string framework)
+        {
+            _framework.Setup(x => x.Get()).Returns(framework);
+        }
+
+        private void GivenTheRequestIs(HttpRequestMessage request)
+        {
+            _request = request;
+        }
+
+        private void WhenICreate()
+        {
+            _result = _downstreamRequestCreator.Create(_request);
+        }
+
+        private async Task ThenTheDownstreamRequestHasABody()
+        {
+            _result.ShouldNotBeNull();
+            _result.Method.ToLower().ShouldBe("get");
+            _result.Scheme.ToLower().ShouldBe("http");
+            _result.Host.ToLower().ShouldBe("www.test.com");
+            var resultContent = await _result.ToHttpRequestMessage().Content.ReadAsStringAsync();
+            resultContent.ShouldBe("test");
+        }
+
+        private void ThenTheDownstreamRequestDoesNotHaveABody()
+        {
+            _result.ShouldNotBeNull();
+            _result.Method.ToLower().ShouldBe("get");
+            _result.Scheme.ToLower().ShouldBe("http");
+            _result.Host.ToLower().ShouldBe("www.test.com");
+            _result.ToHttpRequestMessage().Content.ShouldBeNull();
+        }
+    }
+}
--- a/test/Ocelot.UnitTests/Request/DownstreamRequestInitialiserMiddlewareTests.cs
+++ b/test/Ocelot.UnitTests/Request/DownstreamRequestInitialiserMiddlewareTests.cs
@@ -1,143 +1,146 @@
-using Ocelot.Middleware;
-
-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;
-    using Ocelot.DownstreamRouteFinder.Middleware;
-    using Shouldly;
-
-    public class DownstreamRequestInitialiserMiddlewareTests
-    {
-        readonly DownstreamRequestInitialiserMiddleware _middleware;
-
-        readonly Mock<HttpContext> _httpContext;
-
-        readonly Mock<HttpRequest> _httpRequest;
-
-        readonly Mock<OcelotRequestDelegate> _next;
-
-        readonly Mock<IRequestMapper> _requestMapper;
-
-        readonly Mock<IOcelotLoggerFactory> _loggerFactory;
-
-        readonly Mock<IOcelotLogger> _logger;
-
-        Response<HttpRequestMessage> _mappedRequest;
-        private DownstreamContext _downstreamContext;
-
-        public DownstreamRequestInitialiserMiddlewareTests()
-        {
-            _httpContext = new Mock<HttpContext>();
-            _httpRequest = new Mock<HttpRequest>();
-            _requestMapper = new Mock<IRequestMapper>();
-            _next = new Mock<OcelotRequestDelegate>();
-            _logger = new Mock<IOcelotLogger>();
-
-            _loggerFactory = new Mock<IOcelotLoggerFactory>();
-            _loggerFactory
-                .Setup(lf => lf.CreateLogger<DownstreamRequestInitialiserMiddleware>())
-                .Returns(_logger.Object);
-
-            _middleware = new DownstreamRequestInitialiserMiddleware(
-                _next.Object, 
-                _loggerFactory.Object, 
-                _requestMapper.Object);
-
-            _downstreamContext = new DownstreamContext(_httpContext.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(HttpMethod.Get, "http://www.bbc.co.uk"));
-
-            _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(_downstreamContext).GetAwaiter().GetResult();
-        }
-
-        private void ThenTheContexRequestIsMappedToADownstreamRequest()
-        {
-            _requestMapper.Verify(rm => rm.Map(_httpRequest.Object), Times.Once);
-        }
-
-        private void ThenTheDownstreamRequestIsStored()
-        {
-            _downstreamContext.DownstreamRequest.ShouldNotBeNull();
-        }
-
-        private void ThenTheDownstreamRequestIsNotStored()
-        {
-            _downstreamContext.DownstreamRequest.ShouldBeNull();
-        }
-
-        private void ThenAPipelineErrorIsStored()
-        {
-            _downstreamContext.IsError.ShouldBeTrue();
-            _downstreamContext.Errors.ShouldBe(_mappedRequest.Errors);
-        }
-
-        private void ThenTheNextMiddlewareIsInvoked()
-        {
-            _next.Verify(n => n(_downstreamContext), Times.Once);
-        }
-
-        private void ThenTheNextMiddlewareIsNotInvoked()
-        {
-            _next.Verify(n => n(It.IsAny<DownstreamContext>()), Times.Never);
-        }
-    }
-}
+using Ocelot.Middleware;
+
+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;
+    using Ocelot.DownstreamRouteFinder.Middleware;
+    using Shouldly;
+    using Ocelot.Request.Creator;
+    using Ocelot.Infrastructure;
+
+    public class DownstreamRequestInitialiserMiddlewareTests
+    {
+        readonly DownstreamRequestInitialiserMiddleware _middleware;
+
+        readonly Mock<HttpContext> _httpContext;
+
+        readonly Mock<HttpRequest> _httpRequest;
+
+        readonly Mock<OcelotRequestDelegate> _next;
+
+        readonly Mock<IRequestMapper> _requestMapper;
+
+        readonly Mock<IOcelotLoggerFactory> _loggerFactory;
+
+        readonly Mock<IOcelotLogger> _logger;
+
+        Response<HttpRequestMessage> _mappedRequest;
+        private DownstreamContext _downstreamContext;
+
+        public DownstreamRequestInitialiserMiddlewareTests()
+        {
+            _httpContext = new Mock<HttpContext>();
+            _httpRequest = new Mock<HttpRequest>();
+            _requestMapper = new Mock<IRequestMapper>();
+            _next = new Mock<OcelotRequestDelegate>();
+            _logger = new Mock<IOcelotLogger>();
+
+            _loggerFactory = new Mock<IOcelotLoggerFactory>();
+            _loggerFactory
+                .Setup(lf => lf.CreateLogger<DownstreamRequestInitialiserMiddleware>())
+                .Returns(_logger.Object);
+
+            _middleware = new DownstreamRequestInitialiserMiddleware(
+                _next.Object, 
+                _loggerFactory.Object, 
+                _requestMapper.Object,
+                new DownstreamRequestCreator(new FrameworkDescription()));
+
+            _downstreamContext = new DownstreamContext(_httpContext.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(HttpMethod.Get, "http://www.bbc.co.uk"));
+
+            _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(_downstreamContext).GetAwaiter().GetResult();
+        }
+
+        private void ThenTheContexRequestIsMappedToADownstreamRequest()
+        {
+            _requestMapper.Verify(rm => rm.Map(_httpRequest.Object), Times.Once);
+        }
+
+        private void ThenTheDownstreamRequestIsStored()
+        {
+            _downstreamContext.DownstreamRequest.ShouldNotBeNull();
+        }
+
+        private void ThenTheDownstreamRequestIsNotStored()
+        {
+            _downstreamContext.DownstreamRequest.ShouldBeNull();
+        }
+
+        private void ThenAPipelineErrorIsStored()
+        {
+            _downstreamContext.IsError.ShouldBeTrue();
+            _downstreamContext.Errors.ShouldBe(_mappedRequest.Errors);
+        }
+
+        private void ThenTheNextMiddlewareIsInvoked()
+        {
+            _next.Verify(n => n(_downstreamContext), Times.Once);
+        }
+
+        private void ThenTheNextMiddlewareIsNotInvoked()
+        {
+            _next.Verify(n => n(It.IsAny<DownstreamContext>()), Times.Never);
+        }
+    }
+}
--- a/test/Ocelot.UnitTests/idsrv3test.pfx
+++ b/test/Ocelot.UnitTests/idsrv3test.pfx