// Discovery engine: deterministic local tests. The documents under // fixtures/ are REAL Discovery documents saved verbatim from Google on // 2026-10-25 (never edited); the engine's behavior against all 310 // reachable documents is checked by tools/check_discovery_directory.py. // MockTransport only records what the engine sends; no Google reply is // scripted to prove a behavior. #include #include #include "framework.h" #include "clients/transports/mock_transport.h" #include "google/credentials.h" #include "google/discovery/caps.h" #include "google/discovery/engine.h" #include "google/discovery/validate.h" using namespace molo::google; using namespace molo::google::discovery; using HttpMethod = molo::clients::Method; using molo::clients::body::Json; using molo::clients::transports::MockTransport; namespace { const char* kFixtures = "tests/src/google/discovery/fixtures"; // Counts fetches so cache behavior is observable. struct CountingSource : DocumentSource { FileDocumentSource inner{kFixtures}; int fetches = 0; std::string fetch(const std::string& url, std::size_t max) override { ++fetches; return inner.fetch(url, max); } }; struct Rig { MockTransport* mock; std::shared_ptr client; std::shared_ptr catalog; std::unique_ptr engine; Rig(bool key, bool oauth) { auto t = std::make_unique(); mock = t.get(); client = std::make_shared(std::move(t), key ? Credentials::api_key("KEYVALUE") : nullptr, oauth ? Credentials::bearer("TOKENVALUE") : nullptr); catalog = std::make_shared(std::make_shared(kFixtures)); engine = std::make_unique(client, catalog); } // Answers the next request to `path` so the request can be inspected. void accept(HttpMethod m, const std::string& path) { molo::clients::HeaderMap h; h.set("Content-Type", "application/json"); mock->expect_response(m, path, molo::clients::ClientResponse(200, h, "{}")); } }; template bool invalid(F&& f, const std::string& needle = "") { try { f(); } catch (const GoogleError& e) { return e.http_status() == 400 && e.status() == "INVALID_ARGUMENT" && e.message().find(needle) != std::string::npos; } return false; } Json obj(std::initializer_list> kv) { Json o = Json::object(); for (const auto& [k, v] : kv) o.set(k, v); return o; } // A minimal but structurally real document, for shapes no fixture holds. Json doc_with(const Json& methods, const std::string& root = "https://x.googleapis.com/") { Json d = obj({{"kind", Json("discovery#restDescription")}, {"protocol", Json("rest")}, {"id", Json("x:v1")}, {"name", Json("x")}, {"version", Json("v1")}, {"rootUrl", Json(root)}, {"servicePath", Json("")}, {"schemas", Json::object()}}); d.set("methods", methods); return d; } Json method(const std::string& id, const std::string& verb, const std::string& path, const Json& params = Json::object()) { return obj({{"id", Json(id)}, {"httpMethod", Json(verb)}, {"path", Json(path)}, {"parameters", params}}); } const Method& m_of(const Api& a, const char* id) { const Method* m = a.find(id); if (!m) FAIL(std::string("missing method ") + id); return *m; } } // namespace TEST(discovery, caps_are_hard_ceilings) { static_assert(DiscoveryCaps::kMaxPages <= 50); static_assert(DiscoveryCaps::kMaxDocBytes >= 6419010, "must hold compute v1"); static_assert(DiscoveryCaps::kMinRefetch.count() >= 60); ASSERT_EQ(DiscoveryCaps::kMaxItems, std::size_t{10000}); } TEST(discovery, directory_lists_preferred_and_finds_versions) { CountingSource src; Directory d = Directory::parse(src.fetch(kDirectoryUrl, 1 << 20)); ASSERT_EQ(d.items().size(), std::size_t{6}); ASSERT_EQ(d.find("workflows")->version, std::string("v1")); ASSERT_EQ(d.find("workflows", "v1beta")->id, std::string("workflows:v1beta")); ASSERT_TRUE(d.find("workflows", "v9") == nullptr); ASSERT_TRUE(d.find("nope") == nullptr); ASSERT_EQ(d.search("WORK", 10).size(), std::size_t{1}); // preferred only ASSERT_EQ(d.search("work", 10, false).size(), std::size_t{2}); ASSERT_EQ(d.search("", 2).size(), std::size_t{2}); } TEST(discovery, directory_rejects_hostile_items) { ASSERT_THROW(Directory::parse("{}"), GoogleError); ASSERT_THROW(Directory::parse("not json"), GoogleError); std::string evil = R"({"kind":"discovery#directoryList","items":[{"id":"a:v1","name":"a","version":"v1","discoveryRestUrl":"https://evil.example/doc"}]})"; ASSERT_THROW(Directory::parse(evil), GoogleError); } TEST(discovery, host_allowlist) { ASSERT_TRUE(is_google_host_url("https://tasks.googleapis.com/")); ASSERT_TRUE(is_google_host_url("https://workflows.us-central1.rep.googleapis.com/")); ASSERT_FALSE(is_google_host_url("http://tasks.googleapis.com/")); ASSERT_FALSE(is_google_host_url("https://googleapis.com/")); ASSERT_FALSE(is_google_host_url("https://evilgoogleapis.com/")); ASSERT_FALSE(is_google_host_url("https://x.googleapis.com.evil.example/")); ASSERT_FALSE(is_google_host_url("https://user@x.googleapis.com/")); ASSERT_FALSE(is_google_host_url("https://x.googleapis.com:8443/")); } TEST(discovery, http_source_refuses_foreign_hosts_before_traffic) { auto t = std::make_unique(); MockTransport* mock = t.get(); HttpDocumentSource src(std::move(t)); ASSERT_TRUE(invalid([&] { src.fetch("https://evil.example/x", 1000); }, "googleapis.com")); ASSERT_EQ(mock->send_count(), std::size_t{0}); } TEST(discovery, parses_real_documents) { Rig r(true, true); auto tasks = r.catalog->api("tasks"); ASSERT_EQ(tasks->id(), std::string("tasks:v1")); ASSERT_EQ(tasks->methods().size(), std::size_t{14}); const Method& list = m_of(*tasks, "tasks.tasks.list"); ASSERT_TRUE(tasks->is_pageable(list)); ASSERT_EQ(tasks->items_key(list), std::string("items")); ASSERT_TRUE(list.needs_oauth()); ASSERT_TRUE(list.support == Support::kFull); auto wf = r.catalog->api("workflows:v1"); ASSERT_TRUE(wf->endpoints().size() > 10); ASSERT_TRUE(wf->is_operation_schema("Operation")); ASSERT_EQ(wf->operation_getters().size(), std::size_t{1}); } TEST(discovery, classifies_limited_shapes_from_real_documents) { Rig r(true, true); auto gm = r.catalog->api("groupsmigration"); const Method& ins = m_of(*gm, "groupsmigration.archive.insert"); ASSERT_TRUE(ins.support == Support::kLimited); ASSERT_TRUE(ins.media.supported && ins.media.simple); auto ad = r.catalog->api("admob"); ASSERT_TRUE(m_of(*ad, "admob.accounts.mediationReport.generate").support == Support::kLimited); ASSERT_TRUE(m_of(*ad, "admob.accounts.get").support == Support::kFull); // streamingType NONE } TEST(discovery, classifies_rejected_shapes) { Json bidi = method("x.a", "POST", "v1/a"); bidi.set("streamingType", Json("BIDI")); Json objp = method("x.b", "GET", "v1/b", obj({{"ext", obj({{"type", Json("object")}, {"location", Json("query")}})}})); Json noparam = method("x.c", "GET", "v1/{id}/c"); Json head = method("x.d", "HEAD", "v1/d"); Api a = Api::parse(doc_with(obj({{"a", bidi}, {"b", objp}, {"c", noparam}, {"d", head}}))); for (const char* id : {"x.a", "x.b", "x.c", "x.d"}) { ASSERT_TRUE(m_of(a, id).support == Support::kRejected); ASSERT_FALSE(m_of(a, id).notes.empty()); } CallArgs args; ASSERT_TRUE(invalid([&] { Planner::plan(a, m_of(a, "x.a"), args); }, "cannot be called")); } TEST(discovery, document_validation_rejects_untrusted_shapes) { ASSERT_THROW(Api::parse(doc_with(Json::object(), "https://evil.example/")), GoogleError); ASSERT_THROW(Api::parse(doc_with(Json::object(), "http://x.googleapis.com/")), GoogleError); Json d = doc_with(Json::object()); d.set("kind", Json("other")); ASSERT_THROW(Api::parse(d), GoogleError); Json ep = doc_with(Json::object()); Json row = obj({{"location", Json("l")}, {"endpointUrl", Json("https://evil.example/")}}); Json rows = Json::array(); rows.push(row); ep.set("endpoints", rows); ASSERT_THROW(Api::parse(ep), GoogleError); } TEST(discovery, plan_builds_the_url_and_picks_credentials) { Rig r(true, true); CallArgs a; a.params.set("name", Json("sites/example.com")); PreparedCall p = r.engine->plan("abusiveexperiencereport", "abusiveexperiencereport.sites.get", a); ASSERT_EQ(p.endpoint.base_url, std::string("https://abusiveexperiencereport.googleapis.com")); ASSERT_EQ(p.path, std::string("/v1/sites/example.com")); ASSERT_TRUE(p.endpoint.prefer_key); // no scopes declared: the key a.auth = AuthMode::kOAuth; ASSERT_FALSE(r.engine->plan("abusiveexperiencereport", "abusiveexperiencereport.sites.get", a).endpoint.prefer_key); CallArgs t; t.params.set("tasklist", Json("L1")); ASSERT_FALSE(r.engine->plan("tasks", "tasks.tasks.list", t).endpoint.prefer_key); // scoped: OAuth t.auth = AuthMode::kKey; ASSERT_TRUE(r.engine->plan("tasks", "tasks.tasks.list", t).endpoint.prefer_key); ASSERT_THROW(auth_mode_from("magic"), GoogleError); ASSERT_TRUE(auth_mode_from("") == AuthMode::kAuto); } TEST(discovery, path_values_are_encoded_and_reserved_expansion_keeps_slashes) { Rig r(true, true); CallArgs t; t.params.set("tasklist", Json("a b/c?x")); ASSERT_EQ(r.engine->plan("tasks", "tasks.tasks.list", t).path, std::string("/tasks/v1/lists/a%20b%2Fc%3Fx/tasks")); CallArgs w; w.params.set("name", Json("projects/p1/locations/us-central1/workflows/w 1")); ASSERT_EQ(r.engine->plan("workflows", "workflows.projects.locations.workflows.get", w).path, std::string("/v1/projects/p1/locations/us-central1/workflows/w%201")); } TEST(discovery, dot_segments_and_patterns_are_rejected) { Rig r(true, true); CallArgs t; t.params.set("tasklist", Json("..")); ASSERT_TRUE(invalid([&] { r.engine->plan("tasks", "tasks.tasks.list", t); }, "dot segment")); CallArgs w; w.params.set("name", Json("projects/p/../x")); ASSERT_TRUE(invalid([&] { r.engine->plan("workflows", "workflows.projects.locations.workflows.get", w); })); w.params.set("name", Json("nonsense")); ASSERT_TRUE(invalid([&] { r.engine->plan("workflows", "workflows.projects.locations.workflows.get", w); }, "does not match")); } TEST(discovery, parameter_validation_before_traffic) { Rig r(true, true); CallArgs t; t.params.set("tasklist", Json("L1")); ASSERT_TRUE(invalid([&] { r.engine->plan("tasks", "tasks.tasks.list", CallArgs{}); }, "required parameter tasklist")); t.params.set("nope", Json(1)); ASSERT_TRUE(invalid([&] { r.engine->plan("tasks", "tasks.tasks.list", t); }, "no parameter 'nope'")); t.params = obj({{"tasklist", Json("L1")}, {"maxResults", Json("abc")}}); ASSERT_TRUE(invalid([&] { r.engine->plan("tasks", "tasks.tasks.list", t); }, "integer")); t.params = obj({{"tasklist", Json("L1")}, {"showCompleted", Json("yes")}}); ASSERT_TRUE(invalid([&] { r.engine->plan("tasks", "tasks.tasks.list", t); }, "true or false")); t.params = obj({{"tasklist", Json("L1")}, {"maxResults", Json(20)}, {"showCompleted", Json(true)}, {"dueMin", Json("2026-10-25T10:00:00Z")}}); PreparedCall p = r.engine->plan("tasks", "tasks.tasks.list", t); ASSERT_EQ(p.path, std::string("/tasks/v1/lists/L1/tasks?dueMin=2026-10-25T10%3A00%3A00Z&maxResults=20&showCompleted=true")); ASSERT_EQ(r.mock->send_count(), std::size_t{0}); } TEST(discovery, reserved_global_parameters_are_refused) { Rig r(true, true); for (const char* name : {"key", "access_token", "oauth_token", "alt", "callback", "uploadType"}) { CallArgs a; a.params = obj({{"tasklist", Json("L1")}, {name, Json("x")}}); ASSERT_TRUE(invalid([&] { r.engine->plan("tasks", "tasks.tasks.list", a); }, name)); } CallArgs ok; ok.params = obj({{"tasklist", Json("L1")}, {"fields", Json("items(id)")}, {"quotaUser", Json("u")}}); ASSERT_TRUE(r.engine->plan("tasks", "tasks.tasks.list", ok).path.find("fields=items%28id%29") != std::string::npos); } TEST(discovery, repeated_enum_and_range_checks) { Param rep; rep.name = "r"; rep.type = "string"; rep.location = "query"; rep.repeated = true; rep.enum_values = {"A", "B"}; ASSERT_TRUE(invalid([&] { ParamValidator::values(rep, Json::object()); }, "scalar")); Json arr = Json::array(); arr.push(Json("A")); arr.push(Json("B")); ASSERT_EQ(ParamValidator::values(rep, arr).size(), std::size_t{2}); ASSERT_EQ(ParamValidator::values(rep, Json("A")).size(), std::size_t{1}); arr.push(Json("C")); ASSERT_TRUE(invalid([&] { ParamValidator::values(rep, arr); }, "enum")); Json many = Json::array(); rep.enum_values.clear(); for (int i = 0; i < 101; ++i) many.push(Json("v")); ASSERT_TRUE(invalid([&] { ParamValidator::values(rep, many); }, "more than")); Param n; n.name = "n"; n.type = "integer"; n.format = "int32"; n.location = "query"; n.minimum = 1; n.maximum = 100; ASSERT_EQ(ParamValidator::values(n, Json(50))[0], std::string("50")); ASSERT_TRUE(invalid([&] { ParamValidator::values(n, Json(0)); }, "minimum")); ASSERT_TRUE(invalid([&] { ParamValidator::values(n, Json(101)); }, "maximum")); ASSERT_TRUE(invalid([&] { ParamValidator::values(n, Json(1.5)); }, "integer")); Param big; big.name = "b"; big.type = "string"; big.format = "int64"; big.location = "query"; ASSERT_EQ(ParamValidator::values(big, Json("9007199254740993"))[0], std::string("9007199254740993")); ASSERT_TRUE(invalid([&] { ParamValidator::values(big, Json("1x")); }, "64-bit")); Param s; s.name = "s"; s.type = "string"; s.location = "query"; ASSERT_TRUE(invalid([&] { ParamValidator::values(s, Json(std::string(2049, 'a'))); }, "cap")); ASSERT_TRUE(invalid([&] { ParamValidator::values(s, Json("a\nb")); }, "control")); ASSERT_TRUE(invalid([&] { ParamValidator::values(s, Json()); }, "null")); } TEST(discovery, repeated_parameter_from_a_real_document) { Rig r(true, true); CallArgs a; a.params = obj({{"name", Json("projects/p1")}}); Json types = Json::array(); types.push(Json("a")); types.push(Json("b")); a.params.set("extraLocationTypes", types); PreparedCall p = r.engine->plan("workflows", "workflows.projects.locations.list", a); ASSERT_EQ(p.path, std::string("/v1/projects/p1/locations?extraLocationTypes=a&extraLocationTypes=b")); } TEST(discovery, body_is_validated_against_the_schema) { Rig r(true, true); auto make = [&](Json body) { CallArgs a; a.params = obj({{"parent", Json("projects/p1/locations/us-central1")}, {"workflowId", Json("w1")}}); a.body = std::move(body); return r.engine->plan("workflows", "workflows.projects.locations.workflows.create", a); }; PreparedCall ok = make(obj({{"description", Json("d")}, {"labels", obj({{"k", Json("v")}})}, {"callLogLevel", Json("LOG_ALL_CALLS")}})); ASSERT_TRUE(ok.has_body); ASSERT_TRUE(ok.http == HttpMethod::kPost); ASSERT_TRUE(ok.operation); ASSERT_TRUE(invalid([&] { make(obj({{"bogus", Json(1)}})); }, "no property bogus")); ASSERT_TRUE(invalid([&] { make(obj({{"description", Json(5)}})); }, "must be a string")); ASSERT_TRUE(invalid([&] { make(obj({{"callLogLevel", Json("LOUD")}})); }, "enum")); ASSERT_TRUE(invalid([&] { make(obj({{"labels", obj({{"k", Json(1)}})}})); }, "/labels/k")); ASSERT_TRUE(invalid([&] { make(Json("text")); }, "must be an object")); Json deep = Json::object(); ASSERT_TRUE(make(deep).has_body); // empty body is {} and valid } TEST(discovery, body_rules_follow_the_method_declaration) { Rig r(true, true); CallArgs g; g.params = obj({{"name", Json("projects/p1/locations/us-central1/workflows/w")}}); g.body = obj({}); ASSERT_TRUE(invalid([&] { r.engine->plan("workflows", "workflows.projects.locations.workflows.get", g); }, "no request body")); CallArgs c; c.params = obj({{"tasklist", Json("L1")}}); PreparedCall clear = r.engine->plan("tasks", "tasks.tasks.clear", c); // POST without a request schema ASSERT_TRUE(clear.has_body); ASSERT_EQ(clear.body.dump(), std::string("{}")); } TEST(discovery, regional_endpoints_come_from_the_document) { Rig r(true, true); CallArgs a; a.params = obj({{"name", Json("projects/p1/locations/us-central1/workflows/w")}}); a.location = "us-central1"; PreparedCall p = r.engine->plan("workflows", "workflows.projects.locations.workflows.get", a); ASSERT_EQ(p.endpoint.base_url, std::string("https://workflows.us-central1.rep.googleapis.com")); a.location = "mars-north1"; ASSERT_TRUE(invalid([&] { r.engine->plan("workflows", "workflows.projects.locations.workflows.get", a); }, "no endpoint for location")); CallArgs t; t.params = obj({{"tasklist", Json("L")}}); t.location = "us-central1"; ASSERT_TRUE(invalid([&] { r.engine->plan("tasks", "tasks.tasks.list", t); }, "no regional endpoints")); } TEST(discovery, paging_arguments_are_checked_before_traffic) { Rig r(true, true); CallArgs a; a.params = obj({{"name", Json("sites/example.com")}}); a.max_pages = 3; ASSERT_TRUE(invalid([&] { r.engine->call("abusiveexperiencereport", "abusiveexperiencereport.sites.get", a); }, "not pageable")); a.max_pages = 0; ASSERT_TRUE(invalid([&] { r.engine->call("abusiveexperiencereport", "abusiveexperiencereport.sites.get", a); }, "max_pages")); a.max_pages = DiscoveryCaps::kMaxPages + 1; ASSERT_TRUE(invalid([&] { r.engine->call("abusiveexperiencereport", "abusiveexperiencereport.sites.get", a); }, "max_pages")); ASSERT_EQ(r.mock->send_count(), std::size_t{0}); } TEST(discovery, unknown_api_and_method_are_named) { Rig r(true, true); try { r.engine->plan("nosuchapi", "x.y", CallArgs{}); FAIL("expected throw"); } catch (const GoogleError& e) { ASSERT_EQ(e.http_status(), 404); } try { r.engine->plan("tasks", "tasks.nope", CallArgs{}); FAIL("expected throw"); } catch (const GoogleError& e) { ASSERT_EQ(e.http_status(), 404); } ASSERT_TRUE(invalid([&] { r.engine->plan("../etc", "x", CallArgs{}); }, "name or name:version")); } TEST(discovery, no_credential_is_503_after_validation) { Rig r(false, false); CallArgs a; a.params = obj({{"tasklist", Json("L1")}}); try { r.engine->call("tasks", "tasks.tasks.list", a); FAIL("expected throw"); } catch (const NotConfiguredError& e) { ASSERT_EQ(e.http_status(), 503); } ASSERT_TRUE(invalid([&] { r.engine->call("tasks", "tasks.tasks.list", CallArgs{}); }, "required")); ASSERT_EQ(r.mock->send_count(), std::size_t{0}); } TEST(discovery, call_sends_the_planned_request_with_the_chosen_credential) { Rig r(true, true); r.accept(HttpMethod::kPost, "/tasks/v1/lists/L1/tasks"); CallArgs a; a.params = obj({{"tasklist", Json("L1")}}); a.body = obj({{"title", Json("write tests")}}); CallResult res = r.engine->call("tasks", "tasks.tasks.insert", a); ASSERT_EQ(res.pages, std::size_t{1}); auto seen = r.mock->seen(); ASSERT_EQ(seen.size(), std::size_t{1}); ASSERT_EQ(seen[0].method, std::string("POST")); ASSERT_EQ(seen[0].body, std::string("{\"title\":\"write tests\"}")); ASSERT_EQ(seen[0].headers.get("Authorization").value_or(""), std::string("Bearer TOKENVALUE")); Rig k(true, true); k.accept(HttpMethod::kGet, "/v1/sites/example.com"); CallArgs g; g.params = obj({{"name", Json("sites/example.com")}}); k.engine->call("abusiveexperiencereport", "abusiveexperiencereport.sites.get", g); ASSERT_EQ(k.mock->seen()[0].headers.get("x-goog-api-key").value_or(""), std::string("KEYVALUE")); } TEST(discovery, catalog_caches_expires_and_honors_the_refetch_floor) { auto src = std::make_shared(); auto now = std::make_shared( std::chrono::steady_clock::time_point{} + std::chrono::hours(1000)); Catalog cat(src, [now] { return *now; }); cat.api("tasks"); ASSERT_EQ(src->fetches, 2); // directory + document cat.api("tasks"); cat.api("tasks:v1"); ASSERT_EQ(src->fetches, 2); ASSERT_EQ(cat.stats().cached, std::size_t{1}); // forgetting inside the floor still serves the cached document cat.forget("tasks"); *now += std::chrono::seconds(30); cat.api("tasks"); ASSERT_EQ(src->fetches, 2); // past the floor the forgotten document is fetched again *now += std::chrono::seconds(31); cat.api("tasks"); ASSERT_EQ(src->fetches, 3); // past the max age, directory and document are both refetched *now += DiscoveryCaps::kMaxAge + std::chrono::seconds(1); cat.api("tasks"); ASSERT_EQ(src->fetches, 5); } TEST(discovery, catalog_rejects_a_document_that_is_not_the_one_listed) { struct Swap : DocumentSource { FileDocumentSource inner{kFixtures}; std::string fetch(const std::string& url, std::size_t max) override { if (url.find("tasks") != std::string::npos && url.find("directory") == std::string::npos && url != kDirectoryUrl) return inner.fetch("https://workflows.googleapis.com/$discovery/rest?version=v1", max); return inner.fetch(url, max); } }; Catalog cat(std::make_shared()); ASSERT_THROW(cat.api("tasks"), GoogleError); } TEST(discovery, list_and_describe_report_the_declaration) { Rig r(true, true); Json apis = r.engine->list_apis("task", 10); ASSERT_EQ(apis.as_array().size(), std::size_t{1}); Json ms = r.engine->list_methods("tasks", "tasks.tasks.", 3); ASSERT_EQ(ms.find("methods")->as_array().size(), std::size_t{3}); ASSERT_TRUE(ms.find("truncated")->as_bool()); Json d = r.engine->describe("tasks", "tasks.tasks.list"); ASSERT_TRUE(d.find("pageable")->as_bool()); ASSERT_EQ(d.find("itemsKey")->as_string(), std::string("items")); Json wf = r.engine->describe("workflows", "workflows.projects.locations.workflows.delete"); ASSERT_TRUE(wf.find("operation")->as_bool()); }