#include <memory>

#include <string>

#include <utility>

#include "./httpserver.hpp"

#include "./httpserver/detail/webserver_impl.hpp"

#include "./littletest.hpp"

namespace ht = httpserver;

namespace {

class noop_resource : public ht::http_resource {

};

ht::detail::webserver_impl& impl_of(ht::webserver& ws) {

return *ht::webserver_test_access::impl(ws);

}

ht::http_response noop_handler(const ht::http_request&) {

return ht::http_response(ht::http_response::string("ok"));

}

} // namespace

LT_BEGIN_SUITE(routing_regression_suite)

void set_up() {}

void tear_down() {}

LT_END_SUITE(routing_regression_suite)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

exact_path_hits_exact_tier_with_full_methods)

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_path("/exact", std::make_shared<noop_resource>());

auto r = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/exact"));

LT_CHECK(r.found);

LT_CHECK(r.tier == ht::detail::webserver_impl::tier_hit::exact);

// register_path → method_set is "all methods set" (matches v1

// semantics: class-derived resources serve every method the class

// is configured to render).

LT_CHECK(r.entry.methods == ht::method_set{}.set_all());

LT_CHECK(!r.entry.is_prefix);

LT_END_AUTO_TEST(exact_path_hits_exact_tier_with_full_methods)

LT_BEGIN_AUTO_TEST(routing_regression_suite, exact_path_root_only)

// Mirrors http_endpoint_root_only — root-only registration should be

// exact-tier and only match the root, not arbitrary paths.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_path("/", std::make_shared<noop_resource>());

auto root = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/"));

LT_CHECK(root.found);

LT_CHECK(root.tier == ht::detail::webserver_impl::tier_hit::exact);

auto sub = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/foo"));

LT_CHECK(!sub.found);

LT_CHECK(sub.tier == ht::detail::webserver_impl::tier_hit::none);

LT_END_AUTO_TEST(exact_path_root_only)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

exact_path_normalization_aliases)

// Mirrors basic_suite::duplicate_endpoints — v1 normalizes "OK",

// "/OK", "/OK/", "OK/" to the same canonical key. The v2 lookup

// path must agree.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_path("/ok", std::make_shared<noop_resource>());

// The segment trie's exact tier stores the canonical form. Both

// /ok and /ok/ should resolve.

auto a = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/ok"));

LT_CHECK(a.found);

auto b = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/ok/"));

LT_CHECK(b.found);

LT_END_AUTO_TEST(exact_path_normalization_aliases)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

parameterized_single_segment_captures)

// Mirrors basic_suite::regex_matching_arg via the on_get lambda

// surface. The route is GET-only, so methods should

// contain GET and NOT contain POST. The radix tier carries the

// capture for {id}.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.on_get("/users/{id}", noop_handler);

auto r = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/users/42"));

LT_CHECK(r.found);

LT_CHECK(r.tier == ht::detail::webserver_impl::tier_hit::radix);

LT_CHECK(r.entry.methods.contains(ht::http_method::get));

LT_CHECK(!r.entry.methods.contains(ht::http_method::post));

LT_CHECK_EQ(r.captured_params.size(),

static_cast<std::size_t>(1));

LT_CHECK_EQ(r.captured_params[0].first, std::string("id"));

LT_CHECK_EQ(r.captured_params[0].second, std::string("42"));

LT_END_AUTO_TEST(parameterized_single_segment_captures)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

parameterized_multiple_segments_capture_in_order)

// Mirrors http_endpoint_suite::http_endpoint_multiple_params via

// the v2 lookup. The two {name} segments come out in the order

// they appear in the registered pattern.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_path("/a/{x}/b/{y}/c",

std::make_shared<noop_resource>());

auto r = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/a/1/b/2/c"));

LT_CHECK(r.found);

LT_CHECK(r.tier == ht::detail::webserver_impl::tier_hit::radix);

LT_CHECK_EQ(r.captured_params.size(),

static_cast<std::size_t>(2));

LT_CHECK_EQ(r.captured_params[0].first, std::string("x"));

LT_CHECK_EQ(r.captured_params[0].second, std::string("1"));

LT_CHECK_EQ(r.captured_params[1].first, std::string("y"));

LT_CHECK_EQ(r.captured_params[1].second, std::string("2"));

LT_END_AUTO_TEST(parameterized_multiple_segments_capture_in_order)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

parameterized_with_custom_regex_enforced_in_radix_tier)

// Mirrors basic_suite::regex_matching_arg_custom. v1 used the

// http_endpoint compiled-regex map to enforce per-segment

// constraints; the v2 radix tier now does the same in-line via

// segment_trie_node::wildcard_constraint_, restoring v1 parity. A

// matching segment resolves in the radix tier (and captures

// under the bare name); a non-matching segment misses the

// wildcard slot and falls through to 404.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_path("/items/{id|([0-9]+)}",

std::make_shared<noop_resource>());

auto hit = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/items/42"));

LT_CHECK(hit.found);

LT_CHECK(hit.tier == ht::detail::webserver_impl::tier_hit::radix);

auto non_numeric = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/items/abc"));

LT_CHECK(!non_numeric.found);

LT_END_AUTO_TEST(parameterized_with_custom_regex_enforced_in_radix_tier)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

prefix_serves_bare_and_subpaths)

// Mirrors basic_suite::family_endpoints. A prefix registration

// serves both the bare path and arbitrary subpaths under it.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_prefix("/static", std::make_shared<noop_resource>());

auto bare = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/static"));

LT_CHECK(bare.found);

LT_CHECK(bare.tier == ht::detail::webserver_impl::tier_hit::radix);

LT_CHECK(bare.entry.is_prefix);

auto sub = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/static/foo/bar"));

LT_CHECK(sub.found);

LT_CHECK(sub.tier == ht::detail::webserver_impl::tier_hit::radix);

LT_CHECK(sub.entry.is_prefix);

LT_END_AUTO_TEST(prefix_serves_bare_and_subpaths)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

prefix_then_more_specific_exact_shadows)

// Mirrors the "exact shadows prefix on the exact path, prefix

// serves the rest" precedence relied on by family-style routes

// with carve-outs.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

auto prefix_res = std::make_shared<noop_resource>();

auto exact_res = std::make_shared<noop_resource>();

ws.register_prefix("/static", prefix_res);

ws.register_path("/static/index", exact_res);

// /static/index — exact wins.

auto idx = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/static/index"));

LT_CHECK(idx.found);

LT_CHECK(idx.tier == ht::detail::webserver_impl::tier_hit::exact);

LT_CHECK(!idx.entry.is_prefix);

// /static/foo — radix tier serves it as a prefix subpath.

auto foo = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/static/foo"));

LT_CHECK(foo.found);

LT_CHECK(foo.tier == ht::detail::webserver_impl::tier_hit::radix);

LT_CHECK(foo.entry.is_prefix);

LT_END_AUTO_TEST(prefix_then_more_specific_exact_shadows)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

regex_route_with_metachars_hits_regex_tier)

// Mirrors basic_suite::regex_matching. A path with regex

// metacharacters and no {name} params goes through the regex

// tier under the default regex_checking=true.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_path("/api/v[0-9]+",

std::make_shared<noop_resource>());

auto r = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/api/v1"));

LT_CHECK(r.found);

LT_CHECK(r.tier == ht::detail::webserver_impl::tier_hit::regex);

LT_END_AUTO_TEST(regex_route_with_metachars_hits_regex_tier)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

register_then_unregister_then_lookup_misses)

// Mirrors basic_suite::register_unregister via the v2 lookup.

// After unregister_path, lookup_v2 must miss (tier_hit::none) so

// future dispatch will 404.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_path("/ephemeral", std::make_shared<noop_resource>());

auto before = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/ephemeral"));

LT_CHECK(before.found);

ws.unregister_path("/ephemeral");

auto after = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/ephemeral"));

LT_CHECK(!after.found);

LT_CHECK(after.tier ==

ht::detail::webserver_impl::tier_hit::none);

LT_END_AUTO_TEST(register_then_unregister_then_lookup_misses)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

prefix_register_then_unregister_then_lookup_misses)

// Symmetric pin for the prefix half of register/unregister — the

// v2 radix-tier prefix node must come out cleanly.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_prefix("/scratch", std::make_shared<noop_resource>());

auto before = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/scratch/anything"));

LT_CHECK(before.found);

ws.unregister_prefix("/scratch");

auto after = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/scratch/anything"));

LT_CHECK(!after.found);

LT_END_AUTO_TEST(prefix_register_then_unregister_then_lookup_misses)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

register_exact_after_prefix_throws_collision)

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_prefix("/admin", std::make_shared<noop_resource>());

bool threw = false;

try {

ws.on_get("/admin", noop_handler);

} catch (const std::invalid_argument&) {

threw = true;

}

LT_CHECK(threw);

// Original prefix entry must remain intact (atomicity contract).

// Verify via observable behaviour: /admin/anything resolves (prefix

// semantics) and /admin also resolves (the prefix terminates here).

auto r = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/admin/anything"));

LT_CHECK(r.found);

// Bare path also resolves via prefix.

auto r2 = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/admin"));

LT_CHECK(r2.found);

LT_END_AUTO_TEST(register_exact_after_prefix_throws_collision)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

register_prefix_after_exact_throws_collision)

// Symmetric inverse: on_get first, then register_prefix on the

// same path. The prefix call is the one that must throw.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.on_get("/admin", noop_handler);

bool threw = false;

try {

ws.register_prefix("/admin", std::make_shared<noop_resource>());

} catch (const std::invalid_argument&) {

threw = true;

}

LT_CHECK(threw);

// Original exact entry must remain intact: the bare path still

// resolves (observable behaviour — exact match exists).

auto r = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/admin"));

LT_CHECK(r.found);

// And the failed prefix registration must NOT have planted a

// prefix terminus — /admin/sub must miss (exact semantics preserved).

auto sub = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/admin/sub"));

LT_CHECK(!sub.found);

LT_END_AUTO_TEST(register_prefix_after_exact_throws_collision)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

register_path_after_prefix_throws_collision)

// Class-based exact after class-based prefix on the same path.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_prefix("/static", std::make_shared<noop_resource>());

bool threw = false;

try {

ws.register_path("/static", std::make_shared<noop_resource>());

} catch (const std::invalid_argument&) {

threw = true;

}

LT_CHECK(threw);

// Original prefix entry must remain intact: /static/x resolves

// (prefix semantics — deeper path matches), and /static itself also

// resolves (the prefix terminus is anchored here).

auto r = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/static/x"));

LT_CHECK(r.found);

auto r2 = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/static"));

LT_CHECK(r2.found);

LT_END_AUTO_TEST(register_path_after_prefix_throws_collision)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

register_prefix_after_path_throws_collision)

// Class-based prefix after class-based exact on the same path.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_path("/static", std::make_shared<noop_resource>());

bool threw = false;

try {

ws.register_prefix("/static", std::make_shared<noop_resource>());

} catch (const std::invalid_argument&) {

threw = true;

}

LT_CHECK(threw);

// Original exact entry must remain intact: /static resolves, but

// /static/sub does NOT (exact semantics — no deeper path matches).

auto r = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/static"));

LT_CHECK(r.found);

auto sub = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/static/sub"));

LT_CHECK(!sub.found);

LT_END_AUTO_TEST(register_prefix_after_path_throws_collision)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

parameterized_exact_after_parameterized_prefix_throws_collision)

// Parameterized path lands in the radix tier on BOTH calls. The

// collision is between an exact_terminus_ and a prefix_terminus_

// on the exact same radix node.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_prefix("/users/{id}",

std::make_shared<noop_resource>());

bool threw = false;

try {

ws.on_get("/users/{id}", noop_handler);

} catch (const std::invalid_argument&) {

threw = true;

}

LT_CHECK(threw);

// The original prefix entry must still match a deeper path

// (observable behaviour: /users/42/profile resolves via prefix).

auto r = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/users/42/profile"));

LT_CHECK(r.found);

// The exact node itself also resolves (prefix captures /users/42 and

// any extension).

auto r2 = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/users/42"));

LT_CHECK(r2.found);

LT_END_AUTO_TEST(parameterized_exact_after_parameterized_prefix_throws_collision)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

parameterized_prefix_after_parameterized_exact_throws_collision)

// Inverse of the above.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.on_get("/users/{id}", noop_handler);

bool threw = false;

try {

ws.register_prefix("/users/{id}",

std::make_shared<noop_resource>());

} catch (const std::invalid_argument&) {

threw = true;

}

LT_CHECK(threw);

// Original exact entry must remain intact: /users/42 resolves.

auto r = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/users/42"));

LT_CHECK(r.found);

// The failed prefix registration must NOT have planted a prefix

// terminus — /users/42/profile must miss (exact semantics).

auto sub = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/users/42/profile"));

LT_CHECK(!sub.found);

LT_END_AUTO_TEST(parameterized_prefix_after_parameterized_exact_throws_collision)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

on_get_only_method_yields_get_only_method_set)

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.on_get("/g", noop_handler);

// Looking up under GET: found, GET-only mask.

auto r_get = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/g"));

LT_CHECK(r_get.found);

LT_CHECK(r_get.entry.methods.contains(ht::http_method::get));

LT_CHECK(!r_get.entry.methods.contains(ht::http_method::post));

LT_CHECK(!r_get.entry.methods.contains(ht::http_method::put));

// Looking up under POST: lookup_v2 doesn't filter on method (the

// 405 decision lives at the dispatch site per the comment on

// webserver_impl::lookup_v2). The entry still surfaces with its

// GET-only mask so dispatch can compose Allow.

auto r_post = impl_of(ws).lookup_v2(ht::http_method::post,

std::string("/g"));

LT_CHECK(r_post.found);

LT_CHECK(r_post.entry.methods.contains(ht::http_method::get));

LT_CHECK(!r_post.entry.methods.contains(ht::http_method::post));

LT_END_AUTO_TEST(on_get_only_method_yields_get_only_method_set)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

on_get_then_on_post_same_path_merges_methods)

// Mirrors webserver_on_methods_test merge-on-distinct-method

// semantics — two on_* registrations on the same path compose

// into one entry whose method_set carries both bits.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.on_get("/m", noop_handler);

ws.on_post("/m", noop_handler);

auto r = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/m"));

LT_CHECK(r.found);

LT_CHECK(r.entry.methods.contains(ht::http_method::get));

LT_CHECK(r.entry.methods.contains(ht::http_method::post));

LT_CHECK(!r.entry.methods.contains(ht::http_method::put));

LT_END_AUTO_TEST(on_get_then_on_post_same_path_merges_methods)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

overlapping_two_regex_routes_deterministic_first_wins)

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

auto first = std::make_shared<noop_resource>();

auto second = std::make_shared<noop_resource>();

ws.register_path("/foo/{var|([a-z]+)}/", first);

ws.register_path("/{var|([a-z]+)}/bar/", second);

auto r = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/foo/bar/"));

LT_CHECK(r.found);

// The v2 segment trie prefers exact children over wildcard children

// at each node. /foo/{var|([a-z]+)}/ anchors segment 0 on the

// literal "foo" (exact child), so the tree descends there first and

// never tries the wildcard root branch required by the second

// pattern. Structural precedence → first-registered wins here.

// route_entry::handler is now a bare shared_ptr<http_resource>

// (the variant arm was collapsed); read it directly.

LT_CHECK(r.entry.handler != nullptr);

LT_CHECK(r.entry.handler == first);

LT_END_AUTO_TEST(overlapping_two_regex_routes_deterministic_first_wins)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

later_exact_registration_shadows_earlier_regex)

// Mirrors the second half of basic_suite::overlapping_endpoints —

// an exact-tier registration must beat a regex-tier registration

// that also matches the path, because the lookup pipeline checks

// exact before regex.

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

auto rx = std::make_shared<noop_resource>();

auto exact = std::make_shared<noop_resource>();

ws.register_path("/foo/{var|([a-z]+)}/", rx);

ws.register_path("/foo/bar/", exact);

auto r = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/foo/bar/"));

LT_CHECK(r.found);

LT_CHECK(r.tier == ht::detail::webserver_impl::tier_hit::exact);

LT_CHECK(r.entry.handler != nullptr);

LT_CHECK(r.entry.handler == exact);

LT_END_AUTO_TEST(later_exact_registration_shadows_earlier_regex)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

single_resource_mode_serves_any_subpath)

// Mirrors basic_suite::single_resource_mode — under single_resource

// mode, a single register_prefix("/") catches everything.

ht::webserver ws{ht::create_webserver(8080)

.single_resource()

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

auto only = std::make_shared<noop_resource>();

ws.register_prefix("/", only);

auto root = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/"));

LT_CHECK(root.found);

auto deep = impl_of(ws).lookup_v2(

ht::http_method::get, std::string("/anything/at/all"));

LT_CHECK(deep.found);

LT_CHECK(deep.entry.handler != nullptr);

LT_CHECK(deep.entry.handler == only);

LT_END_AUTO_TEST(single_resource_mode_serves_any_subpath)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

no_regex_checking_treats_metachars_as_literal)

// With regex_checking(false), a path containing regex metacharacters

// is registered as a literal exact path. The classifier must NOT

// route it to the regex tier.

ht::webserver ws{ht::create_webserver(8080)

.regex_checking(false)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_path("/api/v[0-9]+",

std::make_shared<noop_resource>());

// Literal match: hits exact tier.

auto lit = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/api/v[0-9]+"));

LT_CHECK(lit.found);

LT_CHECK(lit.tier == ht::detail::webserver_impl::tier_hit::exact);

// Regex-style probe: misses, because the route is no longer

// interpreted as a regex.

auto miss = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/api/v1"));

LT_CHECK(!miss.found);

LT_END_AUTO_TEST(no_regex_checking_treats_metachars_as_literal)

LT_BEGIN_AUTO_TEST(routing_regression_suite, unregistered_path_yields_miss)

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

// Register an unrelated path so the table is not completely empty,

// reducing the chance this is a vacuous pass.

ws.register_path("/other", std::make_shared<noop_resource>());

auto r = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/never-registered"));

LT_CHECK(!r.found);

LT_CHECK(r.tier == ht::detail::webserver_impl::tier_hit::none);

LT_END_AUTO_TEST(unregistered_path_yields_miss)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

second_lookup_same_path_hits_cache_tier)

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

// Use a parameterized (radix) route: the exact tier bypasses the

// cache (it is a concurrent shared_lock probe), so only the

// genuinely-expensive parameter/regex tiers are memoised.

ws.register_path("/cached/{id}", std::make_shared<noop_resource>());

// First lookup: resolves via the radix tier and populates the cache.

auto cold = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/cached/42"));

LT_CHECK(cold.found);

// First lookup resolves via a tier other than cache.

LT_CHECK(cold.tier != ht::detail::webserver_impl::tier_hit::cache);

// Second lookup for the same path: must come from the LRU cache.

auto warm = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/cached/42"));

LT_CHECK(warm.found);

LT_CHECK(warm.tier == ht::detail::webserver_impl::tier_hit::cache);

LT_END_AUTO_TEST(second_lookup_same_path_hits_cache_tier)

LT_BEGIN_AUTO_TEST(routing_regression_suite,

unregister_invalidates_cache_entry)

ht::webserver ws{ht::create_webserver(8080)

.start_method(ht::http::http_utils::INTERNAL_SELECT)};

ws.register_path("/volatile", std::make_shared<noop_resource>());

// Warm the cache.

auto before = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/volatile"));

LT_CHECK(before.found);

// Remove the registration — must also purge the cached entry.

ws.unregister_path("/volatile");

// A stale cache entry would return found=true with tier_hit::cache;

// correct behavior is a miss.

auto after = impl_of(ws).lookup_v2(ht::http_method::get,

std::string("/volatile"));

LT_CHECK(!after.found);

LT_CHECK(after.tier == ht::detail::webserver_impl::tier_hit::none);

LT_END_AUTO_TEST(unregister_invalidates_cache_entry)

LT_BEGIN_AUTO_TEST_ENV()

AUTORUN_TESTS()

LT_END_AUTO_TEST_ENV()