Add 405 handler

src/BotwinExtensions.cs

@@ -1,9 +1,11 @@
 namespace Botwin
 {
     using System;
+    using System.Collections.Generic;
     using System.IO;
     using System.Linq;
     using System.Reflection;
+    using System.Threading.Tasks;
     using FluentValidation;
     using Microsoft.AspNetCore.Builder;
     using Microsoft.AspNetCore.Http;
@@ -35,23 +37,58 @@ public static IApplicationBuilder UseBotwin(this IApplicationBuilder builder, Bo
             ApplyGlobalAfterHook(builder, options);
 
             var routeBuilder = new RouteBuilder(builder);
+            var systemRoutes = new List<(string verb, string route)>();
 
             //Create a "startup scope" to resolve modules from
             using (var scope = builder.ApplicationServices.CreateScope())
             {
+                var modules = scope.ServiceProvider.GetServices<BotwinModule>();
+
                 //Get all instances of BotwinModule to fetch and register declared routes
-                foreach (var module in scope.ServiceProvider.GetServices<BotwinModule>())
+                foreach (var module in modules)
                 {
                     var moduleType = module.GetType();
 
                     foreach (var route in module.Routes.Keys)
                     {
                         routeBuilder.MapVerb(route.verb, route.path, CreateRouteHandler(route, moduleType));
+
+                        var strippedPath = route.path.EndsWith("/") ? route.path.Substring(0, route.path.Length - 1) : route.path;
+                        systemRoutes.Add((route.verb, "/" + strippedPath));
                     }
                 }
+
+                builder.UseRouter(routeBuilder.Build());
+
+                return builder.Use((ctx, next) => GetMethodNotAllowedHandler(ctx, next, systemRoutes));
             }
+        }
+
+        /// <summary>
+        /// This method is only called if it's a valid 404 or 405
+        /// </summary>
+        /// <param name="context"></param>
+        /// <param name="next"></param>
+        /// <param name="systemRoutes"></param>
+        /// <returns></returns>
+        private static async Task GetMethodNotAllowedHandler(HttpContext context, Func<Task> next, IEnumerable<(string verb, string route)> systemRoutes)
+        {
+            //Call the final pipeline which gets ASP.Net Core status code, usually a 404 in this case
+            await next();
 
-            return builder.UseRouter(routeBuilder.Build());
+            var strippedPath = context.Request.Path.Value.EndsWith("/") && context.Request.Path.Value.Length > 1
+                ? context.Request.Path.Value.Substring(0, context.Request.Path.Value.Length - 1)
+                : context.Request.Path.Value;
+
+            //ASP.Net Core will set a 405 response to 404. Let's check if it's a valid 404 first otherwise if we know about the route it's most likely a 405
+            if (context.Response.StatusCode == 404 && systemRoutes.Any(x => x.route == strippedPath))
+            {
+                var verbsForPath = systemRoutes.Where(x => x.route == strippedPath).Select(y => y.verb);
+                if (verbsForPath.All(x => x != context.Request.Method))
+                {
+                    context.Response.StatusCode = 405;
+                }
+            }
         }
 
         private static RequestDelegate CreateRouteHandler((string verb, string path) route, Type moduleType)

test/BotwinModuleTests.cs

@@ -16,10 +16,7 @@ public class BotwinModuleTests
         public BotwinModuleTests()
         {
             this.server = new TestServer(new WebHostBuilder()
-                .ConfigureServices(x =>
-                {
-                    x.AddBotwin(typeof(TestModule).GetTypeInfo().Assembly);
-                })
+                .ConfigureServices(x => { x.AddBotwin(typeof(TestModule).GetTypeInfo().Assembly); })
                 .Configure(x => x.UseBotwin())
             );
             this.httpClient = this.server.CreateClient();
@@ -261,5 +258,25 @@ public async Task Should_return_GET_requests_with_parsed_quersytring_with_defaul
             Assert.Equal(200, (int)response.StatusCode);
             Assert.True(body.Contains("Managed to parse default int 69"));
         }
+
+        [Theory]
+        [InlineData("/405test")]
+        [InlineData("/405test/")]
+        [InlineData("/405testwithslash")]
+        [InlineData("/405testwithslash/")]
+        public async Task Should_return_405_if_path_not_found_for_supplied_method(string path)
+        {
+            var response = await this.httpClient.PostAsync(path, new StringContent(""));
+
+            Assert.Equal(405, (int)response.StatusCode);
+        }
+
+        [Fact]
+        public async Task Should_return_404_if_path_not_found()
+        {
+            var response = await this.httpClient.GetAsync("/flibbertygibbert");
+
+            Assert.Equal(404, (int)response.StatusCode);
+        }
     }
 }

test/TestModule.cs

@@ -59,6 +59,9 @@ public TestModule()
                 await ctx.Response.WriteAsync(content);
             });
 
+            this.Get("405test", context => context.Response.WriteAsync("hi"));
+            this.Get("405testwithslash/", context => context.Response.WriteAsync("hi"));
+
             this.Post("/", async (ctx) => { await ctx.Response.WriteAsync("Hello"); });
             this.Put("/", async (ctx) => { await ctx.Response.WriteAsync("Hello"); });
             this.Delete("/", async (ctx) => { await ctx.Response.WriteAsync("Hello"); });