#464 (#477)

* #464 added code to request mapper to not automatically add content type and content length headers, .net will automatically try and add these headers in a few circumstances but this solves the 464 issue

* #464 use seek instead of read on body check for websockets tests

* #464 ran out of inodes on linux, looks like reloadonchange causes this

samples/OcelotEureka/ApiGateway/Program.cs

@@ -22,7 +22,7 @@
                         .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
                         .AddJsonFile("appsettings.json", true, true)
                         .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", true, true)
-                        .AddJsonFile("ocelot.json")
+                        .AddJsonFile("ocelot.json", false, false)
                         .AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>

samples/OcelotGraphQL/Program.cs

@@ -106,7 +106,7 @@ namespace OcelotGraphQL
                         .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
                         .AddJsonFile("appsettings.json", true, true)
                         .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", true, true)
-                        .AddJsonFile("ocelot.json")
+                        .AddJsonFile("ocelot.json", false, false)
                         .AddEnvironmentVariables();
                 })
                 .ConfigureServices(s => {

samples/OcelotServiceFabric/src/OcelotApplicationApiGateway/WebCommunicationListener.cs

@@ -59,7 +59,6 @@ namespace OcelotApplicationApiGateway
             {
                 this.webHost = new WebHostBuilder()
                .UseKestrel()
-               //.UseStartup<Startup>()
                .UseUrls(this.listeningAddress)
                 .ConfigureAppConfiguration((hostingContext, config) =>
                 {
@@ -67,7 +66,7 @@ namespace OcelotApplicationApiGateway
                         .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
                         .AddJsonFile("appsettings.json", true, true)
                         .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", true, true)
-                        .AddJsonFile("ocelot.json")
+                        .AddJsonFile("ocelot.json", false, false)
                         .AddEnvironmentVariables();
                 })
                .ConfigureLogging((hostingContext, logging) =>

src/Ocelot/DependencyInjection/ConfigurationBuilderExtensions.cs

@@ -71,7 +71,7 @@ namespace Ocelot.DependencyInjection
 
             File.WriteAllText("ocelot.json", json);
 
-            builder.AddJsonFile("ocelot.json");
+            builder.AddJsonFile("ocelot.json", false, false);
 
             return builder;
         }

src/Ocelot/Request/Mapper/IRequestMapper.cs

@@ -7,6 +7,6 @@
 
     public interface IRequestMapper
     {
-        Task<Response<HttpRequestMessage>> Map(HttpRequest request);
+        Response<HttpRequestMessage> Map(HttpRequest request);
     }
 }

src/Ocelot/Request/Mapper/RequestMapper.cs

@@ -15,13 +15,13 @@
     {
         private readonly string[] _unsupportedHeaders = { "host" };
 
-        public async Task<Response<HttpRequestMessage>> Map(HttpRequest request)
+        public Response<HttpRequestMessage> Map(HttpRequest request)
         {
             try
             {
                 var requestMessage = new HttpRequestMessage()
                 {
-                    Content = await MapContent(request),
+                    Content = MapContent(request),
                     Method = MapMethod(request),
                     RequestUri = MapUri(request)
                 };
@@ -36,17 +36,20 @@
             }
         }
 
-        private async Task<HttpContent> MapContent(HttpRequest request)
+        private HttpContent MapContent(HttpRequest request)
         {
-            if (request.Body == null)
+            if (request.Body == null || (request.Body.CanSeek && request.Body.Length <= 0)) 
             {
                 return null;
             }
 
-            var content = new ByteArrayContent(await ToByteArray(request.Body));
+            var content = new StreamContent(request.Body);
 
-            content.Headers
+            if(!string.IsNullOrEmpty(request.ContentType))
-                .TryAddWithoutValidation("Content-Type", new[] {request.ContentType});
+            {
+                content.Headers
+                    .TryAddWithoutValidation("Content-Type", new[] {request.ContentType});
+            }
 
             AddHeaderIfExistsOnRequest("Content-Language", content, request);
             AddHeaderIfExistsOnRequest("Content-Location", content, request);
@@ -88,18 +91,6 @@
             }
         }
 
-        private async Task<byte[]> ToByteArray(Stream stream)
-        {
-            using (stream)
-            {
-                using (var memStream = new MemoryStream())
-                {
-                    await stream.CopyToAsync(memStream);
-                    return memStream.ToArray();
-                }
-            }
-        }
-
         private bool IsSupportedHeader(KeyValuePair<string, StringValues> header)
         {
             return !_unsupportedHeaders.Contains(header.Key.ToLower());

src/Ocelot/Request/Middleware/DownstreamRequestInitialiserMiddleware.cs

@@ -27,7 +27,7 @@ namespace Ocelot.Request.Middleware
 
         public async Task Invoke(DownstreamContext context)
         {
-            var downstreamRequest = await _requestMapper.Map(context.HttpContext.Request);
+            var downstreamRequest = _requestMapper.Map(context.HttpContext.Request);
 
             if (downstreamRequest.IsError)
             {

test/Ocelot.AcceptanceTests/ContentTests.cs

@@ -0,0 +1,190 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Ocelot.Configuration.File;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.AcceptanceTests
+{
+    public class ContentTests : IDisposable
+    {
+        private IWebHost _builder;
+        private readonly Steps _steps;
+        private string _contentType;
+        private long? _contentLength;
+        private bool _contentTypeHeaderExists;
+
+        public ContentTests()
+        {
+            _steps = new Steps();
+        }
+
+        [Fact]
+        public void should_not_add_content_type_or_content_length_headers()
+        {
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamScheme = "http",
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = 51339,
+                                }
+                            },
+                            UpstreamPathTemplate = "/",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:51339", "/", 200, "Hello from Laura"))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(x => _steps.ThenTheResponseBodyShouldBe("Hello from Laura"))
+                .And(x => ThenTheContentTypeShouldBeEmpty())
+                .And(x => ThenTheContentLengthShouldBeEmpty())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_add_content_type_and_content_length_headers()
+        {
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = 51349,
+                                }
+                            },
+                            DownstreamScheme = "http",
+                            UpstreamPathTemplate = "/",
+                            UpstreamHttpMethod = new List<string> { "Post" },
+                        }
+                    }
+            };
+
+            var contentType = "application/json";
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:51349", "/", 201, string.Empty))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .And(x => _steps.GivenThePostHasContent("postContent"))
+                .And(x => _steps.GivenThePostHasContentType(contentType))
+                .When(x => _steps.WhenIPostUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.Created))
+                .And(x => ThenTheContentLengthIs(11))
+                .And(x => ThenTheContentTypeIsIs(contentType))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_add_default_content_type_header()
+        {
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = 51359,
+                                }
+                            },
+                            DownstreamScheme = "http",
+                            UpstreamPathTemplate = "/",
+                            UpstreamHttpMethod = new List<string> { "Post" },
+                        }
+                    }
+            };
+
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:51359", "/", 201, string.Empty))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .And(x => _steps.GivenThePostHasContent("postContent"))
+                .When(x => _steps.WhenIPostUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.Created))
+                .And(x => ThenTheContentLengthIs(11))
+                .And(x => ThenTheContentTypeIsIs("text/plain; charset=utf-8"))
+                .BDDfy();
+        }
+
+        private void ThenTheContentTypeIsIs(string expected)
+        {
+            _contentType.ShouldBe(expected);
+        }
+
+        private void ThenTheContentLengthShouldBeEmpty()
+        {
+            _contentLength.ShouldBeNull();
+        }
+
+        private void ThenTheContentLengthIs(int expected)
+        {
+            _contentLength.ShouldBe(expected);
+        }
+
+        private void ThenTheContentTypeShouldBeEmpty()
+        {
+            _contentType.ShouldBeNullOrEmpty();
+            _contentTypeHeaderExists.ShouldBe(false);
+        }
+
+        private void GivenThereIsAServiceRunningOn(string baseUrl, string basePath, int statusCode, string responseBody)
+        {
+            _builder = new WebHostBuilder()
+                .UseUrls(baseUrl)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .Configure(app =>
+                {
+                    app.UsePathBase(basePath);
+                    app.Run(async context =>
+                    {   
+                        _contentType = context.Request.ContentType;
+                        _contentLength = context.Request.ContentLength;
+                        _contentTypeHeaderExists = context.Request.Headers.TryGetValue("Content-Type", out var value);
+                        context.Response.StatusCode = statusCode;
+                        await context.Response.WriteAsync(responseBody);
+                    });
+                })
+                .Build();
+
+            _builder.Start();
+        }
+        public void Dispose()
+        {
+            _builder?.Dispose();
+            _steps.Dispose();
+        }
+    }
+}

test/Ocelot.AcceptanceTests/Steps.cs

@@ -68,9 +68,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", false, false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureLogging((hostingContext, logging) =>
@@ -126,9 +126,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", false, false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -154,9 +154,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -197,9 +197,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -228,9 +228,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -261,9 +261,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -294,9 +294,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -326,9 +326,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -357,9 +357,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -396,9 +396,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -444,9 +444,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", false, false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -481,9 +481,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -509,9 +509,9 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(s =>
@@ -570,8 +570,8 @@ namespace Ocelot.AcceptanceTests
         {
             var builder = new ConfigurationBuilder()
                 .SetBasePath(Directory.GetCurrentDirectory())
-                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                .AddJsonFile("ocelot.json")
+                .AddJsonFile("ocelot.json", false, false)
                 .AddEnvironmentVariables();
 
             var configuration = builder.Build();
@@ -823,6 +823,11 @@ namespace Ocelot.AcceptanceTests
             _postContent = new StringContent(postcontent);
         }
 
+        public void GivenThePostHasContentType(string postcontent)
+        {
+            _postContent.Headers.ContentType = new MediaTypeHeaderValue(postcontent);
+        }
+
         public void GivenThePostHasGzipContent(object input)
         {
             var json = JsonConvert.SerializeObject(input);

test/Ocelot.AcceptanceTests/WebSocketTests.cs

@@ -341,8 +341,8 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureLogging((hostingContext, logging) =>
@@ -387,8 +387,8 @@ namespace Ocelot.AcceptanceTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureLogging((hostingContext, logging) =>

test/Ocelot.Benchmarks/AllTheThingsBenchmarks.cs

@@ -99,7 +99,7 @@ namespace Ocelot.Benchmarks
                         .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
                         .AddJsonFile("appsettings.json", true, true)
                         .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", true, true)
-                        .AddJsonFile("ocelot.json")
+                        .AddJsonFile("ocelot.json", false, false)
                         .AddEnvironmentVariables();
                 })
                 .ConfigureServices(s => {

test/Ocelot.IntegrationTests/AdministrationTests.cs

@@ -536,9 +536,9 @@ namespace Ocelot.IntegrationTests
                {
                    config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                    var env = hostingContext.HostingEnvironment;
-                   config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                   config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                       .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                       .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                   config.AddJsonFile("ocelot.json");
+                   config.AddJsonFile("ocelot.json", false, false);
                    config.AddEnvironmentVariables();
                })
                .ConfigureServices(x =>
@@ -660,9 +660,9 @@ namespace Ocelot.IntegrationTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", false, false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(x => {
@@ -693,9 +693,9 @@ namespace Ocelot.IntegrationTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", false, false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(x =>
@@ -733,9 +733,9 @@ namespace Ocelot.IntegrationTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", false, false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(x => {

test/Ocelot.IntegrationTests/RaftTests.cs

@@ -446,10 +446,10 @@ namespace Ocelot.IntegrationTests
                     {
                         config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                         var env = hostingContext.HostingEnvironment;
-                        config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                        config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                            .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                            .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                        config.AddJsonFile("ocelot.json");
+                        config.AddJsonFile("ocelot.json", false, false);
-                        config.AddJsonFile("peers.json", optional: true, reloadOnChange: true);
+                        config.AddJsonFile("peers.json", optional: true, reloadOnChange: false);
                         #pragma warning disable CS0618
                         config.AddOcelotBaseUrl(url);
                         #pragma warning restore CS0618

test/Ocelot.IntegrationTests/ThreadSafeHeadersTests.cs

@@ -106,9 +106,9 @@ namespace Ocelot.IntegrationTests
                 {
                     config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                     var env = hostingContext.HostingEnvironment;
-                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
-                    config.AddJsonFile("ocelot.json");
+                    config.AddJsonFile("ocelot.json", false, false);
                     config.AddEnvironmentVariables();
                 })
                 .ConfigureServices(x =>

test/Ocelot.ManualTest/Program.cs

@@ -26,7 +26,7 @@
                         .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
                         .AddJsonFile("appsettings.json", true, true)
                         .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", true, true)
-                        .AddJsonFile("ocelot.json")
+                        .AddJsonFile("ocelot.json", false, false)
                         .AddEnvironmentVariables();
                 })
                 .ConfigureServices(s => {

test/Ocelot.ManualTest/ocelot.json

@@ -8,7 +8,7 @@
         "DownstreamHostAndPorts": [
           {
             "Host": "localhost",
-            "Port": 3000
+            "Port": 5001
           }
         ],
         "QoSOptions": {

test/Ocelot.UnitTests/Request/DownstreamRequestInitialiserMiddlewareTests.cs

@@ -95,7 +95,7 @@ namespace Ocelot.UnitTests.Request
 
             _requestMapper
                 .Setup(rm => rm.Map(It.IsAny<HttpRequest>()))
-                .ReturnsAsync(_mappedRequest);
+                .Returns(_mappedRequest);
         }
 
         private void GivenTheMapperWillReturnAnError()
@@ -104,7 +104,7 @@ namespace Ocelot.UnitTests.Request
 
             _requestMapper
                 .Setup(rm => rm.Map(It.IsAny<HttpRequest>()))
-                .ReturnsAsync(_mappedRequest);
+                .Returns(_mappedRequest);
         }
 
         private void WhenTheMiddlewareIsInvoked()

test/Ocelot.UnitTests/Request/Mapper/RequestMapperTests.cs

@@ -121,7 +121,7 @@
         [Fact]
         public void Should_handle_no_content()
         {
-            this.Given(_ => GivenTheInputRequestHasNoContent())
+            this.Given(_ => GivenTheInputRequestHasNullContent())
                 .And(_ => GivenTheInputRequestHasMethod("GET"))
                 .And(_ => GivenTheInputRequestHasAValidUri())
                 .When(_ => WhenMapped())
@@ -130,6 +130,40 @@
                 .BDDfy();
         }
 
+        [Fact]
+        public void Should_handle_no_content_type()
+        {
+            this.Given(_ => GivenTheInputRequestHasNoContentType())
+                .And(_ => GivenTheInputRequestHasMethod("GET"))
+                .And(_ => GivenTheInputRequestHasAValidUri())
+                .When(_ => WhenMapped())
+                .Then(_ => ThenNoErrorIsReturned())
+                .And(_ => ThenTheMappedRequestHasNoContent())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void Should_handle_no_content_length()
+        {
+            this.Given(_ => GivenTheInputRequestHasNoContentLength())
+                .And(_ => GivenTheInputRequestHasMethod("GET"))
+                .And(_ => GivenTheInputRequestHasAValidUri())
+                .When(_ => WhenMapped())
+                .Then(_ => ThenNoErrorIsReturned())
+                .And(_ => ThenTheMappedRequestHasNoContent())
+                .BDDfy();
+        }
+
+        private void GivenTheInputRequestHasNoContentLength()
+        {
+            _inputRequest.ContentLength = null;
+        }
+
+        private void GivenTheInputRequestHasNoContentType()
+        {
+            _inputRequest.ContentType = null;
+        }
+
         [Fact]
         public void Should_map_content_headers()
         {
@@ -339,14 +373,14 @@
             _inputRequest.Body = new MemoryStream(Encoding.UTF8.GetBytes(content));
         }
 
-        private void GivenTheInputRequestHasNoContent()
+        private void GivenTheInputRequestHasNullContent()
         {
             _inputRequest.Body = null;
         }
 
         private void WhenMapped()
         {
-            _mappedRequest = _requestMapper.Map(_inputRequest).GetAwaiter().GetResult();
+            _mappedRequest = _requestMapper.Map(_inputRequest);
         }
 
         private void ThenNoErrorIsReturned()