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.
376 lines
13 KiB
C++
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();
|
|
}
|