Create separate HEAD routes instead of forwarding to GET route handler

Sources/Vapor/Responder/DefaultResponder.swift

@@ -31,6 +31,27 @@ internal struct DefaultResponder: Responder {
                     return true
                 }
             }
+
+            // If the route isn't explicitly a HEAD route,
+            // and it's made up solely of .constant components,
+            // register a HEAD route with the same path
+            if route.method != .HEAD &&
+                route.path.allSatisfy({ component in
+                    if case .constant(_) = component { return true }
+                    return false
+            }) {
+                let headRoute = Route(
+                    method: .HEAD,
+                    path: cached.route.path,
+                    responder: middleware.makeResponder(chainingTo: HeadResponder()),
+                    requestType: cached.route.requestType,
+                    responseType: cached.route.responseType)
+
+                let headCachedRoute = CachedRoute(route: headRoute, responder: middleware.makeResponder(chainingTo: HeadResponder()))
+
+                router.register(headCachedRoute, at: [.constant(HTTPMethod.HEAD.string)] + path)
+            }
+
             router.register(cached, at: [.constant(route.method.string)] + path)
         }
         self.router = router
@@ -69,7 +90,17 @@ internal struct DefaultResponder: Responder {
             .split(separator: "/")
             .map(String.init)
 
+        // If it's a HEAD request and a HEAD route exists, return that route...
+        if request.method == .HEAD, let route = self.router.route(
+            path: [HTTPMethod.HEAD.string] + pathComponents,
+            parameters: &request.parameters
+        ) {
+            return route
+        }
+
+        // ...otherwise forward HEAD requests to GET route
         let method = (request.method == .HEAD) ? .GET : request.method
+
         return self.router.route(
             path: [method.string] + pathComponents,
             parameters: &request.parameters
@@ -114,6 +145,12 @@ internal struct DefaultResponder: Responder {
     }
 }
 
+private struct HeadResponder: Responder {
+    func respond(to request: Request) -> EventLoopFuture<Response> {
+        request.eventLoop.makeSucceededFuture(.init(status: .ok))
+    }
+}
+
 private struct NotFoundResponder: Responder {
     func respond(to request: Request) -> EventLoopFuture<Response> {
         request.eventLoop.makeFailedFuture(RouteNotFound())

Tests/VaporTests/RouteTests.swift

@@ -220,22 +220,56 @@ final class RouteTests: XCTestCase {
         }
     }
 
-    func testHeadRequest() throws {
+    func testHeadRequestWithConstantPathReturnsOK() throws {
         let app = Application(.testing)
         defer { app.shutdown() }
 
         app.get("hello") { req -> String in
-            XCTAssertEqual(req.method, .HEAD)
             return "hi"
         }
 
         try app.testable(method: .running).test(.HEAD, "/hello") { res in
+            XCTAssertEqual(res.status, .ok)
+            XCTAssertEqual(res.headers.first(name: .contentLength), "0")
+            XCTAssertEqual(res.body.readableBytes, 0)
+        }
+    }
+
+    func testHeadRequestWithParameterForwardedToGet() throws {
+        let app = Application(.testing)
+        defer { app.shutdown() }
+
+        app.get("hello", ":name") { req -> String in
+            XCTAssertEqual(req.method, .HEAD)
+            return "hi"
+        }
+
+        try app.testable(method: .running).test(.HEAD, "/hello/joe") { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssertEqual(res.headers.first(name: .contentLength), "2")
             XCTAssertEqual(res.body.readableBytes, 0)
         }
     }
 
+    func testExplicitHeadRouteHandlerOverridesGeneratedHandler() throws {
+        let app = Application(.testing)
+        defer { app.shutdown() }
+
+        app.get("hello") { req -> Response in
+            return Response(status: .badRequest)
+        }
+
+        app.on(.HEAD, "hello") { req -> Response in
+            return Response(status: .found)
+        }
+
+        try app.testable(method: .running).test(.HEAD, "/hello") { res in
+            XCTAssertEqual(res.status, .found)
+            XCTAssertEqual(res.headers.first(name: .contentLength), "0")
+            XCTAssertEqual(res.body.readableBytes, 0)
+        }
+    }
+
     func testInvalidCookie() throws {
         let app = Application(.testing)
         defer { app.shutdown() }