Files
moloapp/tests/src/clients/test_client_mock.cpp
T
retoor 3c4334cec9 feat: implement MoloApp plans 01-15 with integration
Full C++23 framework tree: runtime, observability, security,
data, app, realtime, supervisor, clients, CLI, example plus
enterprise tenancy, audit, operability, governance,
supplychain. Postgres via docker compose for tests.
2026-10-23 18:20:04 +02:00

376 lines
13 KiB
C++

#include "framework.h"
#include <chrono>
#include <memory>
#include <vector>
#include "clients/auth.h"
#include "clients/client.h"
#include "clients/transports/mock_transport.h"
using namespace molo::clients;
using molo::clients::transports::MockTransport;
namespace {
struct RecordingReporter : Reporter {
std::vector<RequestSpan> spans;
void on_request(const RequestSpan& span) override { spans.push_back(span); }
};
ClientResponse text_response(int status, const std::string& body) {
HeaderMap headers;
headers.set("Content-Type", "text/plain");
return ClientResponse(status, std::move(headers), body);
}
} // namespace
TEST(client, verbs_over_mock) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
mock->expect_status(Method::kGet, "/v1/users", 200, "[]",
"application/json");
mock->expect_status(Method::kPost, "/v1/users", 201, "{}",
"application/json");
Client client(std::move(mock));
ClientResponse list = client.get_blocking("http://api.test/v1/users");
ASSERT_EQ(list.status(), 200);
ASSERT_EQ(list.body(), "[]");
ClientResponse created =
client.post_blocking("http://api.test/v1/users", "{}", "application/json");
ASSERT_EQ(created.status(), 201);
raw->verify();
ASSERT_EQ(raw->send_count(), 2u);
}
TEST(client, template_and_predicates) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
transports::MockExpectation exp;
exp.method = Method::kGet;
exp.path = "/v1/users/{id}";
exp.required_headers["X-Tenant"] = "acme";
exp.response = text_response(200, "user");
raw->expect(std::move(exp));
Client client(std::move(mock));
ClientRequest req = ClientRequest::get("http://api.test/v1/users/42");
req.header("X-Tenant", "acme");
ASSERT_EQ(client.send_blocking(std::move(req)).status(), 200);
raw->verify();
}
TEST(client, request_helpers_and_json) {
ClientRequest req = ClientRequest::post("http://h/x");
body::Json doc = body::Json::object();
doc.set("a", body::Json(1));
req.json(doc);
ASSERT_EQ(req.headers().get_or("Content-Type", ""), "application/json");
ASSERT_TRUE(req.body_bytes().find("\"a\":1") != std::string::npos);
ClientRequest form = ClientRequest::post("http://h/f");
body::UrlEncodedForm fields;
fields.add("k", "v");
form.form(fields);
ASSERT_EQ(form.body_bytes(), "k=v");
}
TEST(client, connect_error_retries_then_succeeds) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
raw->expect_error(Method::kGet, "/flaky",
std::make_exception_ptr(TimeoutError(TimeoutPhase::kConnect)));
raw->expect_status(Method::kGet, "/flaky", 200, "ok");
ClientConfig config;
std::vector<std::chrono::milliseconds> sleeps;
config.sleeper = [&](std::chrono::milliseconds ms) { sleeps.push_back(ms); };
Client client(std::move(mock), config);
ClientResponse resp = client.get_blocking("http://h/flaky");
ASSERT_EQ(resp.status(), 200);
ASSERT_EQ(resp.attempts(), 2);
ASSERT_EQ(sleeps.size(), 1u);
ASSERT_EQ(client.stats().retries, 1u);
raw->verify();
}
TEST(client, retryable_status_matrix) {
for (int status : {429, 502, 503, 504}) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
raw->expect_status(Method::kGet, "/r", status, "bad");
raw->expect_status(Method::kGet, "/r", 200, "good");
ClientConfig config;
config.sleeper = [](std::chrono::milliseconds) {};
Client client(std::move(mock), config);
ClientResponse resp = client.get_blocking("http://h/r");
ASSERT_EQ(resp.status(), 200);
ASSERT_EQ(resp.attempts(), 2);
raw->verify();
}
// Non-retryable status passes through untouched.
auto mock = std::make_unique<MockTransport>();
mock->expect_status(Method::kGet, "/r", 500, "bad");
Client client(std::move(mock));
ASSERT_EQ(client.get_blocking("http://h/r").attempts(), 1);
}
TEST(client, post_not_retried_without_idempotency) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
raw->expect_status(Method::kPost, "/orders", 503, "busy");
ClientConfig config;
config.sleeper = [](std::chrono::milliseconds) {};
Client client(std::move(mock), config);
ClientResponse resp = client.post_blocking("http://h/orders", "{}");
ASSERT_EQ(resp.status(), 503);
ASSERT_EQ(resp.attempts(), 1);
ASSERT_EQ(raw->send_count(), 1u);
raw->verify();
}
TEST(client, post_retried_with_idempotency_key) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
raw->expect_status(Method::kPost, "/orders", 503, "busy");
raw->expect_status(Method::kPost, "/orders", 200, "done");
ClientConfig config;
config.sleeper = [](std::chrono::milliseconds) {};
Client client(std::move(mock), config);
ClientRequest req = ClientRequest::post("http://h/orders");
req.json_text("{}");
req.idempotency_key("key-123");
ClientResponse resp = client.send_blocking(std::move(req));
ASSERT_EQ(resp.status(), 200);
ASSERT_EQ(resp.attempts(), 2);
raw->verify();
// The key was actually sent.
auto seen = raw->seen();
ASSERT_EQ(seen.size(), 2u);
ASSERT_EQ(seen[0].headers.get_or("Idempotency-Key", ""), "key-123");
}
TEST(client, retry_after_honored) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
HeaderMap headers;
headers.set("Content-Type", "text/plain");
headers.set("Retry-After", "2");
transports::MockExpectation exp;
exp.method = Method::kGet;
exp.path = "/limited";
exp.response = ClientResponse(429, headers, "slow down");
raw->expect(std::move(exp));
raw->expect_status(Method::kGet, "/limited", 200, "ok");
ClientConfig config;
std::vector<std::chrono::milliseconds> sleeps;
config.sleeper = [&](std::chrono::milliseconds ms) { sleeps.push_back(ms); };
Client client(std::move(mock), config);
ASSERT_EQ(client.get_blocking("http://h/limited").status(), 200);
ASSERT_EQ(sleeps.size(), 1u);
ASSERT_EQ(sleeps[0].count(), 2000);
raw->verify();
}
TEST(client, retry_after_capped) {
ASSERT_EQ(RetryPolicy::parse_retry_after("120")->count(), 5000);
ASSERT_TRUE(!RetryPolicy::parse_retry_after("garbage").has_value());
ASSERT_TRUE(!RetryPolicy::parse_retry_after("").has_value());
// HTTP-date in the past yields zero delay.
auto past =
RetryPolicy::parse_retry_after("Wed, 21 Oct 2015 07:28:00 GMT");
ASSERT_TRUE(past.has_value());
ASSERT_EQ(past->count(), 0);
}
TEST(client, backoff_bounds) {
RetryPolicy::set_test_seed(42);
RetryPolicy policy;
for (int i = 0; i < 50; ++i) {
auto d1 = policy.backoff_for(1);
ASSERT_TRUE(d1.count() >= 0 && d1.count() <= 200);
auto d3 = policy.backoff_for(3);
ASSERT_TRUE(d3.count() >= 0 && d3.count() <= 800);
auto d30 = policy.backoff_for(30);
ASSERT_TRUE(d30.count() >= 0 && d30.count() <= 5000);
}
RetryPolicy::set_test_seed(-1);
}
TEST(client, redirect_follow_relative) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
HeaderMap headers;
headers.set("Location", "/v1/target");
transports::MockExpectation exp;
exp.method = Method::kGet;
exp.path = "/v1/start";
exp.response = ClientResponse(302, headers, "");
raw->expect(std::move(exp));
raw->expect_status(Method::kGet, "/v1/target", 200, "there");
Client client(std::move(mock));
ClientResponse resp = client.get_blocking("http://h/v1/start");
ASSERT_EQ(resp.status(), 200);
ASSERT_EQ(resp.body(), "there");
ASSERT_EQ(client.stats().redirect_hops, 1u);
raw->verify();
}
TEST(client, redirect_strips_auth_cross_host) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
HeaderMap headers;
headers.set("Location", "http://other.test/v1/target");
transports::MockExpectation exp;
exp.method = Method::kGet;
exp.path = "/v1/start";
exp.response = ClientResponse(302, headers, "");
raw->expect(std::move(exp));
raw->expect_status(Method::kGet, "/v1/target", 200, "there");
ClientConfig config;
config.auth = std::make_shared<BearerAuth>("secret");
Client client(std::move(mock), config);
ASSERT_EQ(client.get_blocking("http://h/v1/start").status(), 200);
auto seen = raw->seen();
ASSERT_EQ(seen.size(), 2u);
ASSERT_EQ(seen[0].headers.get_or("Authorization", ""), "Bearer secret");
ASSERT_FALSE(seen[1].headers.has("Authorization"));
raw->verify();
}
TEST(client, redirect_loop_bounded) {
auto mock = std::make_unique<MockTransport>();
HeaderMap headers;
headers.set("Location", "/loop");
for (int i = 0; i < 6; ++i) {
transports::MockExpectation exp;
exp.method = Method::kGet;
exp.path = "/loop";
exp.response = ClientResponse(302, headers, "");
mock->expect(std::move(exp));
}
Client client(std::move(mock));
ASSERT_THROW(client.get_blocking("http://h/loop"), RedirectError);
}
TEST(client, post_redirect_not_followed) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
HeaderMap headers;
headers.set("Location", "/elsewhere");
transports::MockExpectation exp;
exp.method = Method::kPost;
exp.path = "/submit";
exp.response = ClientResponse(302, headers, "");
raw->expect(std::move(exp));
Client client(std::move(mock));
ClientResponse resp = client.post_blocking("http://h/submit", "x");
ASSERT_EQ(resp.status(), 302);
ASSERT_EQ(raw->send_count(), 1u);
raw->verify();
}
TEST(client, cookie_jar_roundtrip) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
HeaderMap login_headers;
login_headers.set("Content-Type", "text/plain");
login_headers.add("Set-Cookie", "session=abc; Path=/; HttpOnly");
transports::MockExpectation login;
login.method = Method::kPost;
login.path = "/login";
login.response = ClientResponse(200, login_headers, "ok");
raw->expect(std::move(login));
transports::MockExpectation me;
me.method = Method::kGet;
me.path = "/me";
me.required_headers["Cookie"] = "session=abc";
me.response = text_response(200, "me");
raw->expect(std::move(me));
Client client(std::move(mock));
ASSERT_EQ(client.post_blocking("http://h/login", "").status(), 200);
ASSERT_EQ(client.get_blocking("http://h/me").body(), "me");
ASSERT_EQ(client.jar().size(), 1u);
raw->verify();
}
TEST(client, secure_cookie_not_sent_over_http) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
HeaderMap login_headers;
login_headers.add("Set-Cookie", "s=1; Secure; Path=/");
transports::MockExpectation login;
login.method = Method::kGet;
login.path = "/login";
login.response = ClientResponse(200, login_headers, "ok");
raw->expect(std::move(login));
transports::MockExpectation next;
next.method = Method::kGet;
next.path = "/next";
next.predicate = [](const ClientRequest& req) {
return !req.headers().has("Cookie");
};
next.response = text_response(200, "ok");
raw->expect(std::move(next));
Client client(std::move(mock));
client.get_blocking("http://h/login");
client.get_blocking("http://h/next");
raw->verify();
}
TEST(client, auth_basic_and_apikey) {
BasicAuth basic("user", "pass");
ClientRequest req = ClientRequest::get("http://h/x");
basic.apply(req);
ASSERT_EQ(req.headers().get_or("Authorization", ""),
"Basic dXNlcjpwYXNz");
ApiKeyAuth key("k", "X-Api-Key");
ClientRequest req2 = ClientRequest::get("http://h/x");
key.apply(req2);
ASSERT_EQ(req2.headers().get_or("X-Api-Key", ""), "k");
ApiKeyAuth query_key("k", "X-Api-Key", "api_key");
ClientRequest req3 = ClientRequest::get("http://h/x");
query_key.apply(req3);
ASSERT_TRUE(req3.url().target().find("api_key=k") != std::string::npos);
}
TEST(client, base_url_and_reporter) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
raw->expect_status(Method::kGet, "/v1/ping", 200, "pong");
auto reporter = std::make_shared<RecordingReporter>();
ClientConfig config;
config.base_url = "http://api.test";
config.reporter = reporter;
Client client(std::move(mock), config);
ClientResponse resp = client.get_blocking("/v1/ping");
ASSERT_EQ(resp.body(), "pong");
ASSERT_EQ(reporter->spans.size(), 1u);
ASSERT_EQ(reporter->spans[0].status, 200);
ASSERT_EQ(reporter->spans[0].method, "GET");
ASSERT_EQ(client.stats().requests, 1u);
ASSERT_EQ(client.stats().responses_2xx, 1u);
raw->verify();
}
TEST(client, unmatched_and_unconsumed) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
raw->expect_status(Method::kGet, "/known", 200, "x");
Client client(std::move(mock));
ASSERT_THROW(client.get_blocking("http://h/unknown"),
transports::MockError);
ASSERT_THROW(raw->verify(), transports::MockError);
}
TEST(client, stream_upload_mock) {
auto mock = std::make_unique<MockTransport>();
MockTransport* raw = mock.get();
raw->expect_status(Method::kPost, "/upload", 200, "stored");
Client client(std::move(mock));
auto reader = std::make_shared<body::StringReader>("chunked-data");
ClientRequest req = ClientRequest::post("http://h/upload");
req.stream(reader, std::nullopt, "application/octet-stream");
ASSERT_TRUE(req.is_stream_body());
ASSERT_EQ(client.send_blocking(std::move(req)).status(), 200);
raw->verify();
}