554 lines
22 KiB
C++
554 lines
22 KiB
C++
#include <doctest/doctest.h>
|
|
|
|
#include <cstring>
|
|
#include <string>
|
|
|
|
#include "api_url_parser.hpp"
|
|
|
|
// Helper to convert string to mutable buffer for testing
|
|
std::string make_mutable_copy(const std::string &url) {
|
|
return url; // Return copy that can be modified
|
|
}
|
|
|
|
TEST_CASE("ApiUrlParser routing") {
|
|
SUBCASE("Static GET routes") {
|
|
auto url = make_mutable_copy("/v1/version");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetVersion);
|
|
|
|
url = make_mutable_copy("/v1/subscribe");
|
|
result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetSubscribe);
|
|
|
|
url = make_mutable_copy("/metrics");
|
|
result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetMetrics);
|
|
|
|
url = make_mutable_copy("/ok");
|
|
result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetOk);
|
|
}
|
|
|
|
SUBCASE("Static POST routes") {
|
|
auto url = make_mutable_copy("/v1/commit");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("POST", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::PostCommit);
|
|
}
|
|
|
|
SUBCASE("Not found") {
|
|
auto url = make_mutable_copy("/unknown/route");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::NotFound);
|
|
|
|
url = make_mutable_copy("/v1/version");
|
|
result = ApiUrlParser::parse("DELETE", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::NotFound);
|
|
}
|
|
}
|
|
|
|
TEST_CASE("ApiUrlParser with query strings") {
|
|
SUBCASE("Simple query string") {
|
|
auto url = make_mutable_copy("/v1/status?request_id=123");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetStatus);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"123");
|
|
}
|
|
|
|
SUBCASE("Multiple query parameters") {
|
|
auto url = make_mutable_copy("/v1/status?request_id=abc&min_version=42");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetStatus);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"abc");
|
|
REQUIRE(match.params[static_cast<int>(ApiParameterKey::MinVersion)]
|
|
.has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::MinVersion)].value() ==
|
|
"42");
|
|
}
|
|
|
|
SUBCASE("Unknown parameters are ignored") {
|
|
auto url = make_mutable_copy("/v1/version?foo=bar&baz=quux");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetVersion);
|
|
CHECK_FALSE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
}
|
|
}
|
|
|
|
TEST_CASE("ApiUrlParser with URL parameters") {
|
|
SUBCASE("PUT retention policy") {
|
|
auto url = make_mutable_copy("/v1/retention/my-policy");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("PUT", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::PutRetention);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::PolicyId)].value() ==
|
|
"my-policy");
|
|
}
|
|
|
|
SUBCASE("DELETE retention policy") {
|
|
auto url = make_mutable_copy("/v1/retention/another-policy");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("DELETE", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::DeleteRetention);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::PolicyId)].value() ==
|
|
"another-policy");
|
|
}
|
|
|
|
SUBCASE("GET retention policy") {
|
|
auto url = make_mutable_copy("/v1/retention/get-this");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetRetention);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::PolicyId)].value() ==
|
|
"get-this");
|
|
}
|
|
|
|
SUBCASE("GET all retention policies (no ID)") {
|
|
auto url = make_mutable_copy("/v1/retention");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetRetention);
|
|
CHECK_FALSE(
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value());
|
|
}
|
|
}
|
|
|
|
TEST_CASE("ApiUrlParser with URL and query parameters") {
|
|
auto url = make_mutable_copy("/v1/retention/p1?request_id=abc123");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("DELETE", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::DeleteRetention);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::PolicyId)].value() ==
|
|
"p1");
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"abc123");
|
|
}
|
|
|
|
TEST_CASE("ApiUrlParser URL decoding") {
|
|
SUBCASE("Path segment percent-decoding") {
|
|
auto url = make_mutable_copy("/v1/retention/my%2Dpolicy");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("PUT", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::PutRetention);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::PolicyId)].value() ==
|
|
"my-policy");
|
|
}
|
|
|
|
SUBCASE("Query parameter form decoding (+ to space)") {
|
|
auto url = make_mutable_copy("/v1/status?request_id=hello+world");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetStatus);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"hello world");
|
|
}
|
|
|
|
SUBCASE("Query parameter percent-decoding") {
|
|
auto url = make_mutable_copy("/v1/status?request_id=hello%20world");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetStatus);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"hello world");
|
|
}
|
|
|
|
SUBCASE("Base64-like sequences in query parameters") {
|
|
auto url = make_mutable_copy("/v1/status?request_id=YWJj%3D");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetStatus);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"YWJj=");
|
|
}
|
|
|
|
SUBCASE("Mixed encoding in path and query") {
|
|
auto url = make_mutable_copy(
|
|
"/v1/retention/my%2Dpolicy?request_id=hello+world%21");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("DELETE", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::DeleteRetention);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::PolicyId)].value() ==
|
|
"my-policy");
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"hello world!");
|
|
}
|
|
}
|
|
|
|
TEST_CASE("ApiUrlParser malformed encoding") {
|
|
SUBCASE("Incomplete percent sequence in path") {
|
|
auto url = make_mutable_copy("/v1/retention/bad%2");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("PUT", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::MalformedEncoding);
|
|
}
|
|
|
|
SUBCASE("Invalid hex digits in path") {
|
|
auto url = make_mutable_copy("/v1/retention/bad%ZZ");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("PUT", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::MalformedEncoding);
|
|
}
|
|
|
|
SUBCASE("Incomplete percent sequence in query") {
|
|
auto url = make_mutable_copy("/v1/status?request_id=bad%2");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::MalformedEncoding);
|
|
}
|
|
|
|
SUBCASE("Invalid hex digits in query") {
|
|
auto url = make_mutable_copy("/v1/status?request_id=bad%GG");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::MalformedEncoding);
|
|
}
|
|
|
|
SUBCASE("Percent at end of path") {
|
|
auto url = make_mutable_copy("/v1/retention/bad%");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("PUT", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::MalformedEncoding);
|
|
}
|
|
|
|
SUBCASE("Percent at end of query") {
|
|
auto url = make_mutable_copy("/v1/status?request_id=bad%");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::MalformedEncoding);
|
|
}
|
|
}
|
|
|
|
TEST_CASE("ApiUrlParser edge cases and bugs") {
|
|
SUBCASE("Bug: Path boundary error - /v1/retention/ with trailing slash") {
|
|
// BUG: Code checks length > 13 but substrings at 14, causing off-by-one
|
|
auto url = make_mutable_copy(
|
|
"/v1/retention/"); // length 14, exactly the boundary case
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetRetention);
|
|
// This should NOT set PolicyId since it's empty, but current code might
|
|
// have issues
|
|
CHECK_FALSE(
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value());
|
|
}
|
|
|
|
SUBCASE("Bug: Empty URL handling") {
|
|
auto url = make_mutable_copy("");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::NotFound);
|
|
}
|
|
|
|
SUBCASE("Bug: Query-only URL") {
|
|
auto url = make_mutable_copy("?request_id=123");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::NotFound);
|
|
// Should still parse query parameters
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"123");
|
|
}
|
|
|
|
SUBCASE("Bug: Consecutive delimiters in query string") {
|
|
auto url =
|
|
make_mutable_copy("/v1/status?&&request_id=123&&min_version=42&&");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetStatus);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"123");
|
|
REQUIRE(match.params[static_cast<int>(ApiParameterKey::MinVersion)]
|
|
.has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::MinVersion)].value() ==
|
|
"42");
|
|
}
|
|
|
|
SUBCASE("Bug: Parameter without value (should be skipped)") {
|
|
auto url = make_mutable_copy("/v1/status?debug&request_id=123");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetStatus);
|
|
// debug parameter should be ignored since it has no value
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"123");
|
|
}
|
|
|
|
SUBCASE("Bug: Empty parameter value") {
|
|
auto url = make_mutable_copy("/v1/status?request_id=");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetStatus);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"");
|
|
}
|
|
|
|
SUBCASE("Edge: Exact length boundary for retention path") {
|
|
// Test the exact boundary condition: "/v1/retention" is 13 chars
|
|
auto url = make_mutable_copy("/v1/retention"); // exactly 13 characters
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetRetention);
|
|
CHECK_FALSE(
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value());
|
|
}
|
|
|
|
SUBCASE("Edge: Minimum valid policy ID") {
|
|
// Test one character after the boundary
|
|
auto url =
|
|
make_mutable_copy("/v1/retention/a"); // 15 chars total, policy_id = "a"
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetRetention);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::PolicyId)].value() ==
|
|
"a");
|
|
}
|
|
}
|
|
|
|
TEST_CASE("ApiUrlParser specific bug reproduction") {
|
|
SUBCASE("Reproduction: Path boundary math error") {
|
|
// The bug: code checks length > 13 but substrings at 14
|
|
// "/v1/retention" = 13 chars, "/v1/retention/" = 14 chars
|
|
// This test should demonstrate undefined behavior or wrong results
|
|
|
|
auto url = make_mutable_copy("/v1/retention/");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
|
|
// Expected behavior: should match GetRetention but NOT set PolicyId
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetRetention);
|
|
|
|
// The bug: may incorrectly extract empty string or cause buffer read error
|
|
// Let's see what actually happens
|
|
if (match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value()) {
|
|
auto policy_id =
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].value();
|
|
CHECK(policy_id.empty()); // Should be empty if set at all
|
|
}
|
|
}
|
|
|
|
SUBCASE("Reproduction: Query parsing with edge cases") {
|
|
// Test parameter parsing with multiple edge conditions
|
|
auto url = make_mutable_copy(
|
|
"/v1/status?=empty_key&no_value&request_id=&min_version=42&=");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetStatus);
|
|
|
|
// Should handle empty values correctly
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"");
|
|
|
|
REQUIRE(match.params[static_cast<int>(ApiParameterKey::MinVersion)]
|
|
.has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::MinVersion)].value() ==
|
|
"42");
|
|
}
|
|
|
|
SUBCASE("Reproduction: Very long input stress test") {
|
|
// Test potential integer overflow or performance issues
|
|
std::string long_policy_id(1000, 'x'); // 1000 character policy ID
|
|
auto url = make_mutable_copy("/v1/retention/" + long_policy_id +
|
|
"?request_id=" + std::string(500, 'y'));
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetRetention);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::PolicyId)].value() ==
|
|
long_policy_id);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
std::string(500, 'y'));
|
|
}
|
|
|
|
SUBCASE("Reproduction: Zero-length edge case") {
|
|
char empty_buffer[1] = {0};
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", empty_buffer, 0, match);
|
|
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::NotFound);
|
|
}
|
|
|
|
SUBCASE("Reproduction: Null buffer edge case") {
|
|
// This might cause undefined behavior if not handled properly
|
|
RouteMatch match;
|
|
char single_char = '/';
|
|
auto result = ApiUrlParser::parse("GET", &single_char, 1, match);
|
|
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::NotFound);
|
|
}
|
|
|
|
SUBCASE("BUG: Query parser pos increment overflow") {
|
|
// BUG: pos += pair_end + 1 can go beyond buffer bounds
|
|
// When pair_end == query_length - pos (no & found), pos becomes
|
|
// query_length + 1
|
|
auto url = make_mutable_copy("/v1/status?no_ampersand_at_end");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
|
|
// This should not crash or have undefined behavior
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetStatus);
|
|
// Parameter should be ignored since it's not a known key
|
|
}
|
|
|
|
SUBCASE("BUG: String view with potentially negative length cast") {
|
|
// BUG: decoded_value_length is int but gets cast to size_t for string_view
|
|
// If decode function returned negative (which it can), this could wrap
|
|
// around
|
|
|
|
// We can't easily trigger the decode function to return -1 through normal
|
|
// parsing since that's caught earlier, but this tests the edge case
|
|
// handling
|
|
auto url = make_mutable_copy("/v1/status?request_id=normal_value");
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
|
|
CHECK(result == ParseResult::Success);
|
|
REQUIRE(
|
|
match.params[static_cast<int>(ApiParameterKey::RequestId)].has_value());
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::RequestId)].value() ==
|
|
"normal_value");
|
|
}
|
|
|
|
SUBCASE("BUG: Array bounds - PolicyId path extraction edge case") {
|
|
// Test the boundary condition more precisely
|
|
// "/v1/retention" = 13 chars, checking length > 13, substr(14)
|
|
auto url = make_mutable_copy("/v1/retention/"); // exactly 14 chars
|
|
RouteMatch match;
|
|
auto result = ApiUrlParser::parse("GET", url.data(),
|
|
static_cast<int>(url.size()), match);
|
|
|
|
CHECK(result == ParseResult::Success);
|
|
CHECK(match.route == HttpRoute::GetRetention);
|
|
|
|
// path.length() = 14, so > 13 is true
|
|
// path.substr(14) should return empty string_view
|
|
// The bug would be if this crashes or returns invalid data
|
|
if (match.params[static_cast<int>(ApiParameterKey::PolicyId)].has_value()) {
|
|
CHECK(match.params[static_cast<int>(ApiParameterKey::PolicyId)]
|
|
.value()
|
|
.empty());
|
|
}
|
|
}
|
|
} |