Files
moloapp/tests/src/google/discovery/test_discovery.cpp
T
retoorandClaude Sonnet 5.5 4ae0b8ec4b feat(clients): discovery: generic engine for all Google Discovery APIs
Directory and document cache with caps, parameter and body validation before
traffic, path/query/repeated/regional handling, key-or-OAuth choice, paging,
long-running wait, whole-directory checker script, demo at /google/discovery.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 15:03:40 +01:00

503 lines
21 KiB
C++

// 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 <iostream>
#include <memory>
#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<GoogleClient> client;
std::shared_ptr<Catalog> catalog;
std::unique_ptr<Engine> engine;
Rig(bool key, bool oauth) {
auto t = std::make_unique<MockTransport>();
mock = t.get();
client = std::make_shared<GoogleClient>(std::move(t),
key ? Credentials::api_key("KEYVALUE") : nullptr,
oauth ? Credentials::bearer("TOKENVALUE") : nullptr);
catalog = std::make_shared<Catalog>(std::make_shared<FileDocumentSource>(kFixtures));
engine = std::make_unique<Engine>(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 <typename F>
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<std::pair<std::string, Json>> 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>();
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<CountingSource>();
auto now = std::make_shared<std::chrono::steady_clock::time_point>(
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<Swap>());
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());
}