more http_worker tests for unhandled routes

Author: vinniefalco

test/unit/server/http_worker.cpp

@@ -75,10 +75,72 @@ struct http_worker_test
             status::ok, R"({"ok":true})");
     }
 
+    void
+    testRouteOutcomes()
+    {
+        // route_next: handler declines, path has
+        // a route so router returns 405
+        check(GET, "/x", h_next,
+            status::method_not_allowed);
+
+        // route_next_route: skip route, path has
+        // a route so router returns 405
+        check(GET, "/x", h_next_route,
+            status::method_not_allowed);
+
+        // route_next via middleware -> 404
+        {
+            test_router r;
+            r.use(h_next);
+            check(r, GET, "/x",
+                status::not_found);
+        }
+
+        // route_close: session ends, no response
+        {
+            test_router r;
+            r.add(GET, "/bye", h_close);
+            auto raw = exchange_raw(r, GET, "/bye");
+            BOOST_TEST(raw.empty());
+        }
+
+        // route_error: handler fails -> 500
+        check(GET, "/err",
+            h_error(http::error::bad_content_length),
+            status::internal_server_error);
+
+        // Empty router -> 404
+        {
+            test_router r;
+            check(r, GET, "/anything",
+                status::not_found);
+        }
+
+        // route_next falls through to second handler
+        {
+            test_router r;
+            r.route("/x")
+                .add(GET, h_next)
+                .add(GET, h_text("ok"));
+            check(r, GET, "/x",
+                status::ok, "ok");
+        }
+
+        // route_next_route skips entire first route
+        {
+            test_router r;
+            r.add(GET, "/x", h_next_route);
+            r.add(GET, "/x", h_text("second"));
+            check(r, GET, "/x",
+                status::ok, "second");
+        }
+    }
+
     void
     run()
     {
         testBasicRoute();
+        testRouteOutcomes();
     }
 };
 

test/unit/server/test_worker.hpp

@@ -99,6 +99,29 @@ struct test_worker
         };
     }
 
+    /** Handler that returns route_next (decline). */
+    static auto
+    h_next(route_params&) -> route_task
+    { co_return route_next; }
+
+    /** Handler that returns route_next_route. */
+    static auto
+    h_next_route(route_params&) -> route_task
+    { co_return route_next_route; }
+
+    /** Handler that returns route_close. */
+    static auto
+    h_close(route_params&) -> route_task
+    { co_return route_close; }
+
+    /** Handler that returns route_error. */
+    static auto
+    h_error(system::error_code ec)
+    {
+        return [ec](route_params&) -> route_task
+        { co_return route_error(ec); };
+    }
+
     /** Handler that sends 200 with text body and
         a custom Content-Type.
     */
@@ -192,6 +215,42 @@ struct test_worker
     // Run one request/response exchange
     //--------------------------------------------
 
+    /** Run a raw request and return the raw
+        bytes written by the worker.
+    */
+    static std::string
+    exchange_raw(
+        test_router const& r,
+        std::string_view request)
+    {
+        auto [client, server] =
+            capy::test::make_stream_pair();
+
+        http_worker w(
+            server,
+            test_router(r),
+            pcfg(),
+            scfg());
+
+        client.provide(request);
+        client.close();
+
+        capy::test::run_blocking()(
+            w.do_http_session());
+
+        return std::string(client.data());
+    }
+
+    static std::string
+    exchange_raw(
+        test_router const& r,
+        http::method m,
+        std::string_view path)
+    {
+        return exchange_raw(r,
+            make_request(m, path));
+    }
+
     /** Run a raw request through a worker and
         return the parsed response.
     */