#include "framework.h" #include #include #include #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 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* 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* 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* 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 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* 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(); 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* 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* 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* 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 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* 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* 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("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(); 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* 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* 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* 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* raw = mock.get(); raw->expect_status(Method::kGet, "/v1/ping", 200, "pong"); auto reporter = std::make_shared(); 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* 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* raw = mock.get(); raw->expect_status(Method::kPost, "/upload", 200, "stored"); Client client(std::move(mock)); auto reader = std::make_shared("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(); }