TASK-015: wire test-request fallback through http_request_impl

create_test_request now allocates the impl_ and stores headers/footers/
cookies/args/querystring/auth/requestor/tls flags on it, instead of on
http_request directly. The MHD-touching accessors in http_request_impl
(get_connection_value, get_headerlike_values, populate_args, fetch_user_pass,
has_tls_session) and in http_request (get_querystring, get_digested_user,
get_requestor) now branch on connection_ == nullptr to read from the
local maps when running through the test-request path.

Also adds a string_body::get_content() helper used by the new
create_test_request unit suite, friend-grants create_test_request access
to http_request::impl_, and ships the create_test_request unit binary
from the autotools build.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: etr

src/Makefile.am

@@ -19,12 +19,12 @@
 AM_CPPFLAGS = -I../ -I$(srcdir)/httpserver/ -DHTTPSERVER_COMPILATION
 METASOURCES = AUTO
 lib_LTLIBRARIES = libhttpserver.la
-libhttpserver_la_SOURCES = string_utilities.cpp webserver.cpp http_utils.cpp file_info.cpp http_request.cpp http_response.cpp http_resource.cpp create_webserver.cpp detail/http_endpoint.cpp detail/body.cpp
+libhttpserver_la_SOURCES = string_utilities.cpp webserver.cpp http_utils.cpp file_info.cpp http_request.cpp http_response.cpp http_resource.cpp create_webserver.cpp create_test_request.cpp detail/http_endpoint.cpp detail/body.cpp
 # noinst_HEADERS: shipped in the tarball but NEVER installed under $prefix/include.
 # Detail headers (httpserver/detail/*.hpp) live here so they cannot leak to
 # downstream consumers — the public surface comes in through <httpserver.hpp>.
 noinst_HEADERS = httpserver/string_utilities.hpp httpserver/detail/modded_request.hpp httpserver/detail/http_endpoint.hpp httpserver/detail/body.hpp httpserver/detail/webserver_impl.hpp httpserver/detail/http_request_impl.hpp gettext.h
-nobase_include_HEADERS = httpserver.hpp httpserver/body_kind.hpp httpserver/constants.hpp httpserver/create_webserver.hpp httpserver/webserver.hpp httpserver/http_utils.hpp httpserver/file_info.hpp httpserver/http_request.hpp httpserver/http_response.hpp httpserver/http_resource.hpp httpserver/feature_unavailable.hpp httpserver/iovec_entry.hpp httpserver/http_arg_value.hpp httpserver/http_method.hpp
+nobase_include_HEADERS = httpserver.hpp httpserver/body_kind.hpp httpserver/constants.hpp httpserver/create_webserver.hpp httpserver/create_test_request.hpp httpserver/webserver.hpp httpserver/http_utils.hpp httpserver/file_info.hpp httpserver/http_request.hpp httpserver/http_response.hpp httpserver/http_resource.hpp httpserver/feature_unavailable.hpp httpserver/iovec_entry.hpp httpserver/http_arg_value.hpp httpserver/http_method.hpp
 
 if HAVE_WEBSOCKET
 libhttpserver_la_SOURCES += websocket_handler.cpp

src/create_test_request.cpp

@@ -20,7 +20,9 @@
 */
 
 #include "httpserver/create_test_request.hpp"
+#include "httpserver/detail/http_request_impl.hpp"
 
+#include <memory>
 #include <string>
 #include <utility>
 
@@ -29,40 +31,44 @@ namespace httpserver {
 http_request create_test_request::build() {
     http_request req;
 
+    // Allocate an impl for this test request (connection_ stays null,
+    // indicating the test-request path to all MHD-touching accessors).
+    req.impl_ = std::make_unique<detail::http_request_impl>();
+
     req.set_method(_method);
     req.set_path(_path);
     req.set_version(_version);
     req.set_content(_content);
 
-    req.headers_local = std::move(_headers);
-    req.footers_local = std::move(_footers);
-    req.cookies_local = std::move(_cookies);
+    req.impl_->headers_local = std::move(_headers);
+    req.impl_->footers_local = std::move(_footers);
+    req.impl_->cookies_local = std::move(_cookies);
 
     for (auto& [key, values] : _args) {
         for (auto& value : values) {
-            req.cache->unescaped_args[key].push_back(std::move(value));
+            req.impl_->unescaped_args[key].push_back(std::move(value));
         }
     }
-    req.cache->args_populated = true;
+    req.impl_->args_populated = true;
 
     if (!_querystring.empty()) {
-        req.cache->querystring = std::move(_querystring);
+        req.impl_->querystring = std::move(_querystring);
     }
 
 #ifdef HAVE_BAUTH
-    req.cache->username = std::move(_user);
-    req.cache->password = std::move(_pass);
+    req.impl_->username = std::move(_user);
+    req.impl_->password = std::move(_pass);
 #endif  // HAVE_BAUTH
 
 #ifdef HAVE_DAUTH
-    req.cache->digested_user = std::move(_digested_user);
+    req.impl_->digested_user = std::move(_digested_user);
 #endif  // HAVE_DAUTH
 
-    req.cache->requestor_ip = std::move(_requestor);
-    req.requestor_port_local = _requestor_port;
+    req.impl_->requestor_ip = std::move(_requestor);
+    req.impl_->requestor_port_local = _requestor_port;
 
 #ifdef HAVE_GNUTLS
-    req.tls_enabled_local = _tls_enabled;
+    req.impl_->tls_enabled_local = _tls_enabled;
 #endif  // HAVE_GNUTLS
 
     return req;

src/http_request.cpp

@@ -133,6 +133,23 @@ struct arguments_accumulator {
 namespace detail {
 
 std::string_view http_request_impl::get_connection_value(std::string_view key, MHD_ValueKind kind) const {
+    // Test-request path: connection_ is null, fall back to local storage.
+    if (connection_ == nullptr) {
+        const auto* map = [&]() -> const http::header_map* {
+            switch (kind) {
+                case MHD_HEADER_KIND: return &headers_local;
+                case MHD_FOOTER_KIND: return &footers_local;
+                case MHD_COOKIE_KIND: return &cookies_local;
+                default:             return nullptr;
+            }
+        }();
+        if (map != nullptr) {
+            auto it = map->find(std::string(key));
+            if (it != map->end()) return it->second;
+        }
+        return http_request::EMPTY;
+    }
+
     const char* header_c = MHD_lookup_connection_value(connection_, kind, key.data());
 
     if (header_c == nullptr) return http_request::EMPTY;
@@ -153,6 +170,24 @@ MHD_Result http_request_impl::build_request_header(void* cls, MHD_ValueKind kind
 http::header_view_map http_request_impl::get_headerlike_values(MHD_ValueKind kind) const {
     http::header_view_map headers;
 
+    // Test-request path: connection_ is null, build view map from local storage.
+    if (connection_ == nullptr) {
+        const auto* map = [&]() -> const http::header_map* {
+            switch (kind) {
+                case MHD_HEADER_KIND: return &headers_local;
+                case MHD_FOOTER_KIND: return &footers_local;
+                case MHD_COOKIE_KIND: return &cookies_local;
+                default:             return nullptr;
+            }
+        }();
+        if (map != nullptr) {
+            for (const auto& [k, v] : *map) {
+                headers[k] = v;
+            }
+        }
+        return headers;
+    }
+
     MHD_get_connection_values(connection_, kind, &http_request_impl::build_request_header,
                               reinterpret_cast<void*>(&headers));
 
@@ -197,6 +232,11 @@ void http_request_impl::populate_args() const {
     if (args_populated) {
         return;
     }
+    // Test-request path: connection_ is null, args already set directly.
+    if (connection_ == nullptr) {
+        args_populated = true;
+        return;
+    }
     arguments_accumulator aa;
     aa.unescaper = unescaper_;
     aa.arguments = &unescaped_args;
@@ -252,6 +292,10 @@ void http_request_impl::grow_last_arg(const std::string& key, const std::string&
 
 #ifdef HAVE_BAUTH
 void http_request_impl::fetch_user_pass() const {
+    // Test-request path: connection_ is null, credentials already set.
+    if (connection_ == nullptr) {
+        return;
+    }
     struct MHD_BasicAuthInfo* info = MHD_basic_auth_get_username_password3(connection_);
 
     if (info != nullptr) {
@@ -266,6 +310,10 @@ void http_request_impl::fetch_user_pass() const {
 
 #ifdef HAVE_GNUTLS
 bool http_request_impl::has_tls_session() const {
+    // Test-request path: connection_ is null, return the local flag.
+    if (connection_ == nullptr) {
+        return tls_enabled_local;
+    }
     const MHD_ConnectionInfo* conninfo = MHD_get_connection_info(connection_, MHD_CONNECTION_INFO_GNUTLS_SESSION);
     return (conninfo != nullptr);
 }
@@ -514,6 +562,8 @@ http_arg_value http_request::get_arg(std::string_view key) const {
 }
 
 std::string_view http_request::get_arg_flat(std::string_view key) const {
+    impl_->populate_args();
+
     auto const it = impl_->unescaped_args.find(key);
 
     if (it != impl_->unescaped_args.end()) {
@@ -558,6 +608,11 @@ std::string_view http_request::get_querystring() const {
         return impl_->querystring;
     }
 
+    // Test-request path: connection_ is null, querystring already set (or empty).
+    if (impl_->connection_ == nullptr) {
+        return impl_->querystring;
+    }
+
     MHD_get_connection_values(impl_->connection_, MHD_GET_ARGUMENT_KIND,
                               &detail::http_request_impl::build_request_querystring,
                               reinterpret_cast<void*>(&impl_->querystring));
@@ -589,6 +644,11 @@ std::string_view http_request::get_digested_user() const {
         return impl_->digested_user;
     }
 
+    // Test-request path: connection_ is null, digested_user already set.
+    if (impl_->connection_ == nullptr) {
+        return impl_->digested_user;
+    }
+
     struct MHD_DigestAuthUsernameInfo* info = MHD_digest_auth_get_username3(impl_->connection_);
 
     impl_->digested_user = EMPTY;
@@ -657,15 +717,33 @@ std::string_view http_request::get_requestor() const {
         return impl_->requestor_ip;
     }
 
+    // Test-request path: connection_ is null, requestor_ip already set.
+    if (impl_->connection_ == nullptr) {
+        return impl_->requestor_ip;
+    }
+
     const MHD_ConnectionInfo* conninfo = MHD_get_connection_info(impl_->connection_, MHD_CONNECTION_INFO_CLIENT_ADDRESS);
 
+    if (conninfo == nullptr) {
+        return EMPTY;
+    }
+
     impl_->requestor_ip = http::get_ip_str(conninfo->client_addr);
     return impl_->requestor_ip;
 }
 
 uint16_t http_request::get_requestor_port() const {
+    // Test-request path: connection_ is null, use local port.
+    if (impl_->connection_ == nullptr) {
+        return impl_->requestor_port_local;
+    }
+
     const MHD_ConnectionInfo* conninfo = MHD_get_connection_info(impl_->connection_, MHD_CONNECTION_INFO_CLIENT_ADDRESS);
 
+    if (conninfo == nullptr) {
+        return 0;
+    }
+
     return http::get_port(conninfo->client_addr);
 }
 

src/httpserver/detail/body.hpp

@@ -139,6 +139,11 @@ class string_body final : public body {
         ::new (dst) string_body(std::move(*this));
     }
 
+    /// Returns the body string. Primarily for tests.
+    [[nodiscard]] const std::string& get_content() const noexcept {
+        return content_;
+    }
+
  private:
     std::string content_;
 };

src/httpserver/detail/http_request_impl.hpp

@@ -92,6 +92,18 @@ class http_request_impl {
     file_cleanup_callback_ptr file_cleanup_callback_ = nullptr;
     std::map<std::string, std::map<std::string, http::file_info>> files_;
 
+    // --- test-request local storage ---
+    // When connection_ is null (create_test_request path), get_header /
+    // get_footer / get_cookie / get_headerlike_values / get_requestor_port /
+    // has_tls_session fall back to these instead of calling MHD APIs.
+    http::header_map headers_local;
+    http::header_map footers_local;
+    http::header_map cookies_local;
+    uint16_t requestor_port_local = 0;
+#ifdef HAVE_GNUTLS
+    bool tls_enabled_local = false;
+#endif  // HAVE_GNUTLS
+
     // --- lazy caches (formerly the http_request_data_cache struct) ---
     // All marked mutable: const accessors lazily populate them.
 #ifdef HAVE_BAUTH

src/httpserver/http_request.hpp

@@ -472,6 +472,7 @@ class http_request {
      friend class webserver;
      friend class detail::webserver_impl;  // TASK-014: PIMPL dispatch path
      friend struct detail::modded_request;
+     friend class create_test_request;    // TASK-015: test builder accesses impl_
 };
 
 std::ostream &operator<< (std::ostream &os, const http_request &r);

test/Makefile.am

@@ -26,7 +26,7 @@ LDADD += -lcurl
 
 AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/src/httpserver/ -DHTTPSERVER_COMPILATION
 METASOURCES = AUTO
-check_PROGRAMS = basic file_upload http_utils threaded nodelay string_utilities http_endpoint ban_system ws_start_stop authentication deferred http_resource http_response create_webserver new_response_types daemon_info uri_log feature_unavailable header_hygiene_iovec header_hygiene iovec_entry http_method constants body http_response_sbo http_response_factories webserver_pimpl http_request_pimpl
+check_PROGRAMS = basic file_upload http_utils threaded nodelay string_utilities http_endpoint ban_system ws_start_stop authentication deferred http_resource http_response create_webserver new_response_types daemon_info uri_log feature_unavailable header_hygiene_iovec header_hygiene iovec_entry http_method constants body http_response_sbo http_response_factories webserver_pimpl http_request_pimpl create_test_request
 
 MOSTLYCLEANFILES = *.gcda *.gcno *.gcov
 
@@ -109,6 +109,13 @@ webserver_pimpl_LDADD =
 http_request_pimpl_SOURCES = unit/http_request_pimpl_test.cpp
 http_request_pimpl_LDADD =
 
+# create_test_request: TASK-015 functional tests for the create_test_request
+# builder and the http_request public API on test-constructed requests. Wires
+# up headers/footers/cookies/args/querystring/requestor/auth via impl_ local
+# maps rather than a live MHD_Connection*.
+create_test_request_SOURCES = unit/create_test_request_test.cpp
+create_test_request_LDADD = $(LDADD) -lmicrohttpd
+
 noinst_HEADERS = littletest.hpp
 AM_CXXFLAGS += -Wall -fPIC -Wno-overloaded-virtual
 

test/unit/create_test_request_test.cpp

@@ -22,14 +22,32 @@
 #include <string>
 
 #include "./httpserver.hpp"
+#include "httpserver/create_test_request.hpp"
+#include "httpserver/detail/body.hpp"
 #include "./littletest.hpp"
 
 using httpserver::create_test_request;
 using httpserver::http_request;
 using httpserver::http_resource;
 using httpserver::http_response;
-using httpserver::string_response;
-using httpserver::file_response;
+
+// Test-only accessor for http_response internals (same pattern as
+// http_response_sbo_test.cpp and http_response_factories_test.cpp).
+namespace httpserver {
+struct http_response_sbo_test_access {
+    static bool body_inline(http_response& r) noexcept {
+        return r.body_inline_;
+    }
+    static httpserver::detail::body* body_ptr(http_response& r) noexcept {
+        return r.body_;
+    }
+    static body_kind kind(http_response& r) noexcept { return r.kind_; }
+};
+}  // namespace httpserver
+
+namespace {
+using SBO = httpserver::http_response_sbo_test_access;
+}  // namespace
 
 LT_BEGIN_SUITE(create_test_request_suite)
     void set_up() {
@@ -195,7 +213,7 @@ class greeting_resource : public http_resource {
     std::shared_ptr<http_response> render_GET(const http_request& req) override {
         std::string name(req.get_arg_flat("name"));
         if (name.empty()) name = "World";
-        return std::make_shared<string_response>("Hello, " + name);
+        return std::make_shared<http_response>(http_response::string("Hello, " + name));
     }
 };
 
@@ -206,23 +224,16 @@ LT_BEGIN_AUTO_TEST(create_test_request_suite, render_with_test_request)
         .arg("name", "Alice")
         .build();
     auto resp = resource.render_GET(req);
-    auto* sr = dynamic_cast<string_response*>(resp.get());
-    LT_ASSERT(sr != nullptr);
-    LT_CHECK_EQ(std::string(sr->get_content()), std::string("Hello, Alice"));
+    LT_ASSERT(resp != nullptr);
+    // Verify the response body kind is string.
+    LT_CHECK_EQ(static_cast<int>(resp->kind()),
+                static_cast<int>(httpserver::body_kind::string));
+    // Verify the response body content reflects the arg.
+    auto* sb = dynamic_cast<httpserver::detail::string_body*>(SBO::body_ptr(*resp));
+    LT_ASSERT(sb != nullptr);
+    LT_CHECK_EQ(sb->get_content(), std::string("Hello, Alice"));
 LT_END_AUTO_TEST(render_with_test_request)
 
-// Test string_response get_content
-LT_BEGIN_AUTO_TEST(create_test_request_suite, string_response_get_content)
-    string_response resp("test body", 200);
-    LT_CHECK_EQ(std::string(resp.get_content()), std::string("test body"));
-LT_END_AUTO_TEST(string_response_get_content)
-
-// Test file_response get_filename
-LT_BEGIN_AUTO_TEST(create_test_request_suite, file_response_get_filename)
-    file_response resp("/tmp/test.txt", 200);
-    LT_CHECK_EQ(std::string(resp.get_filename()), std::string("/tmp/test.txt"));
-LT_END_AUTO_TEST(file_response_get_filename)
-
 // Test full chain of all builder methods
 LT_BEGIN_AUTO_TEST(create_test_request_suite, full_chain)
     auto req = create_test_request()
@@ -237,8 +248,10 @@ LT_BEGIN_AUTO_TEST(create_test_request_suite, full_chain)
         .arg("key1", "val1")
         .arg("key2", "val2")
         .querystring("?key1=val1&key2=val2")
+#ifdef HAVE_BAUTH
         .user("testuser")
         .pass("testpass")
+#endif
         .requestor("10.0.0.1")
         .requestor_port(9090)
         .build();
@@ -254,8 +267,10 @@ LT_BEGIN_AUTO_TEST(create_test_request_suite, full_chain)
     LT_CHECK_EQ(std::string(req.get_arg_flat("key1")), std::string("val1"));
     LT_CHECK_EQ(std::string(req.get_arg_flat("key2")), std::string("val2"));
     LT_CHECK_EQ(std::string(req.get_querystring()), std::string("?key1=val1&key2=val2"));
+#ifdef HAVE_BAUTH
     LT_CHECK_EQ(std::string(req.get_user()), std::string("testuser"));
     LT_CHECK_EQ(std::string(req.get_pass()), std::string("testpass"));
+#endif
     LT_CHECK_EQ(std::string(req.get_requestor()), std::string("10.0.0.1"));
     LT_CHECK_EQ(req.get_requestor_port(), static_cast<uint16_t>(9090));
 LT_END_AUTO_TEST(full_chain)