chore: route type tests

Author: vinniefalco

include/boost/http_proto/server/route_handler.hpp

@@ -110,6 +110,45 @@ struct BOOST_HTTP_PROTO_SYMBOL_VISIBLE
     route_params&
     set_body(std::string s);
 
+    /** Read the request body and receive a value.
+
+        This function reads the entire request body into the specified sink.
+        When the read operation completes, the given callback is invoked with
+        the result.
+
+        The @p callback parameter must be a function object with this
+        equivalent signature, where `T` is the type produced by the value sink:
+        @code
+        void ( T&& t );
+        @endcode
+
+        @par Example
+        @code
+        rp.read_body(
+            capy::string_body_sink(),
+            []( std::string s )
+            {
+                // body read successfully
+            });
+        @endcode
+
+        If an error or an exception occurs during the read, it is propagated
+        through the router to the next error or exception handler.
+
+        @param sink The body sink to read into.
+        @param callback The function to call when the read completes.
+        @return The route result, which must be returned immediately
+            from the route handler.
+    */
+    template<
+        class ValueSink,
+        class Callback>
+    auto
+    read_body(
+        ValueSink&& sink,
+        Callback&& callback) ->
+            route_result;
+
 #ifdef BOOST_HTTP_PROTO_HAS_CORO
 
     /** Spawn a coroutine for this route.
@@ -205,6 +244,36 @@ struct BOOST_HTTP_PROTO_SYMBOL_VISIBLE
 
 //-----------------------------------------------
 
+template<
+    class ValueSink,
+    class Callback>
+auto
+route_params::
+read_body(
+    ValueSink&& sink,
+    Callback&& callback) ->
+        route_result
+{
+    (void)callback;
+    /*
+    return suspend(
+    [&](resumer resume)
+    {
+        parser.read_body(
+            std::forward<ValueSink>(sink),
+            [resume, cb = std::forward<Callback>(callback)]
+            (auto&&... args)
+            {
+                cb(std::forward<decltype(args)>(args)...);
+                resume(route_result::next);
+            });
+    });
+    */
+    return route::next;
+}
+
+//-----------------------------------------------
+
 template<class F>
 auto
 route_params::

src/server/router_types.cpp

@@ -21,7 +21,7 @@ const char*
 route_cat_type::
 name() const noexcept
 {
-    return "boost.http";
+    return "boost.http.route";
 }
 
 std::string
@@ -40,12 +40,12 @@ message(
 {
     switch(static_cast<route>(code))
     {
-    case route::close:      return "route::close";
-    case route::complete:   return "route::complete";
-    case route::suspend:     return "route::suspend";
-    case route::next:       return "route::next";
-    case route::next_route: return "route::next_route";
-    case route::send:       return "route::send";
+    case route::close:      return "close";
+    case route::complete:   return "complete";
+    case route::suspend:    return "suspend";
+    case route::next:       return "next";
+    case route::next_route: return "next_route";
+    case route::send:       return "send";
     default:
         return "?";
     }

test/unit/server/router_types.cpp

@@ -18,9 +18,39 @@ namespace http_proto {
 
 struct router_types_test
 {
+    template<typename Error>
+    void
+    check(
+        char const* name,
+        Error ev)
+    {
+        auto const ec = make_error_code(ev);
+        BOOST_TEST(std::string(ec.category().name()) == name);
+        BOOST_TEST(! ec.message().empty());
+        BOOST_TEST(
+            std::addressof(ec.category()) ==
+            std::addressof(make_error_code(ev).category()));
+        BOOST_TEST(ec.category().equivalent(
+            static_cast<typename std::underlying_type<Error>::type>(ev),
+                ec.category().default_error_condition(
+                    static_cast<typename std::underlying_type<Error>::type>(ev))));
+        BOOST_TEST(ec.category().equivalent(ec,
+            static_cast<typename std::underlying_type<Error>::type>(ev)));
+    }
+
     void
     run()
     {
+        {
+            char const* const n = "boost.http.route";
+            check(n, route::close);
+            check(n, route::complete);
+            check(n, route::suspend);
+            check(n, route::next);
+            check(n, route::next_route);
+            check(n, route::send);
+        }
+
         basic_router<route_params_base> r;
         r.add(http_proto::method::post, "/",
             [](route_params_base& rp) ->