feat(clients): ops: 20 Google Cloud operations APIs, 418 Discovery-derived calls

Compute, Cloud Run, Functions, GKE, Build, Artifact Registry, IAM, IAM
Credentials, Resource Manager, Service Usage, Logging, Monitoring, Scheduler,
Tasks, Workflows, Eventarc, Billing, Asset, Org Policy. Generated call table
checked against Discovery, validated plans, dry-run default for writes
(enable/disable never live), /google/ops demo routes, live read-only probe.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-25 15:23:56 +01:00
co-authored by Claude Sonnet 5.5
parent 3db67fcf1f
commit 18ec8b720e
46 changed files with 4702 additions and 3 deletions
+127
View File
@@ -0,0 +1,127 @@
// Ops call table invariants. The table is generated from Discovery by
// src/google/ops/tools/gen_calls.py and checked against Discovery by
// tools/check_discovery.py; these tests pin the properties the code relies on.
#include <map>
#include <set>
#include <string>
#include "framework.h"
#include "clients/transports/mock_transport.h"
#include "google/errors.h"
#include "google/ops/calls.h"
#include "google/ops/ops.h"
using namespace molo::google;
using namespace molo::google::ops;
TEST(ops_calls, table_is_large_and_unique) {
ASSERT_TRUE(call_count() >= 400);
std::set<std::string> seen;
for (std::size_t i = 0; i < call_count(); ++i) {
const CallSpec& c = call_table()[i];
ASSERT_TRUE(seen.insert(c.rpc).second);
ASSERT_TRUE(find_call(c.rpc) == &c);
}
}
TEST(ops_calls, every_row_has_a_product_and_consistent_safety) {
for (std::size_t i = 0; i < call_count(); ++i) {
const CallSpec& c = call_table()[i];
product_named(c.product());
std::string http = c.http;
if (http == "DELETE") ASSERT_TRUE(c.safe() == Safety::kDestructive);
// A GET never changes state.
if (http == "GET") ASSERT_TRUE(c.safe() == Safety::kRead);
// Destructive rows are named delete / purge / batchDelete.
if (c.safe() == Safety::kDestructive) {
std::string rpc = c.rpc;
std::string verb = rpc.substr(rpc.rfind('.') + 1);
ASSERT_TRUE(verb.rfind("delete", 0) == 0 || verb == "batchDelete" || verb == "purge");
}
// Bodiless verbs declare no body fields.
if (http == "GET" || http == "DELETE") ASSERT_EQ(std::string(c.body_fields), "");
}
}
TEST(ops_calls, path_parameters_and_shapes) {
for (std::size_t i = 0; i < call_count(); ++i) {
const CallSpec& c = call_table()[i];
std::string path = c.path, shapes = c.path_shapes;
std::size_t params = 0;
for (std::size_t at = path.find('{'); at != std::string::npos; at = path.find('{', at + 1)) ++params;
std::size_t entries = shapes.empty() ? 0 : 1;
for (char ch : shapes) entries += ch == ' ' ? 1 : 0;
ASSERT_EQ(params, entries);
}
}
TEST(ops_calls, list_rows_name_their_items) {
std::size_t lists = 0;
for (std::size_t i = 0; i < call_count(); ++i) {
const CallSpec& c = call_table()[i];
if (c.is_list()) {
++lists;
ASSERT_TRUE(c.safe() == Safety::kRead);
}
}
ASSERT_TRUE(lists >= 100);
}
TEST(ops_calls, every_required_area_is_covered) {
const char* areas[] = {
"compute.instances.list", "run.projects.locations.services.list",
"cloudfunctions.projects.locations.functions.list", "container.projects.locations.clusters.list",
"cloudbuild.projects.locations.builds.list", "artifactregistry.projects.locations.repositories.list",
"iam.roles.list", "iam.projects.serviceAccounts.list", "iam.projects.serviceAccounts.keys.create",
"iam.projects.serviceAccounts.testIamPermissions", "iamcredentials.projects.serviceAccounts.signJwt",
"iamcredentials.projects.serviceAccounts.signBlob", "cloudresourcemanager.projects.get",
"serviceusage.services.enable", "serviceusage.services.disable", "serviceusage.services.list",
"serviceusage.services.batchGet", "logging.entries.list", "monitoring.projects.timeSeries.list",
"cloudscheduler.projects.locations.jobs.list", "cloudtasks.projects.locations.queues.list",
"workflows.projects.locations.workflows.list", "eventarc.projects.locations.triggers.list",
"cloudbilling.billingAccounts.list", "cloudasset.searchAllResources",
"orgpolicy.projects.policies.list"};
for (const char* rpc : areas) ASSERT_TRUE(find_call(rpc) != nullptr);
ASSERT_EQ(product_count(), 20u);
}
TEST(ops_calls, enable_and_disable_are_writes) {
ASSERT_TRUE(call_named("serviceusage.services.enable").safe() == Safety::kWrite);
ASSERT_TRUE(call_named("serviceusage.services.disable").safe() == Safety::kWrite);
ASSERT_TRUE(call_named("serviceusage.services.list").safe() == Safety::kRead);
// Signing and permission tests change nothing.
ASSERT_TRUE(call_named("iamcredentials.projects.serviceAccounts.signJwt").safe() == Safety::kRead);
ASSERT_TRUE(call_named("iam.projects.serviceAccounts.testIamPermissions").safe() == Safety::kRead);
ASSERT_TRUE(call_named("iam.projects.serviceAccounts.delete").safe() == Safety::kDestructive);
ASSERT_TRUE(call_named("cloudtasks.projects.locations.queues.purge").safe() == Safety::kDestructive);
}
TEST(ops_calls, endpoints_come_from_discovery) {
ASSERT_EQ(endpoint_of(product_named("run")).base_url, "https://run.googleapis.com");
ASSERT_EQ(endpoint_of(product_named("compute")).base_url,
"https://compute.googleapis.com/compute/v1");
ASSERT_EQ(operation_endpoint_of(product_named("serviceusage")).base_url,
"https://serviceusage.googleapis.com/v1");
ASSERT_THROW(product_named("nope"), GoogleError);
ASSERT_THROW(call_named("run.nope"), GoogleError);
}
TEST(ops_calls, no_em_dash_in_table) {
for (std::size_t i = 0; i < call_count(); ++i) {
std::string row = std::string(call_table()[i].rpc) + call_table()[i].path;
ASSERT_TRUE(row.find("\xE2\x80\x94") == std::string::npos);
}
}
TEST(ops_calls, every_product_object_owns_its_rows) {
Ops ops(std::make_shared<GoogleClient>(
std::make_unique<molo::clients::transports::MockTransport>(), nullptr));
std::size_t total = 0;
for (const OpsProduct* p : ops.all()) {
auto rpcs = p->rpcs();
ASSERT_TRUE(!rpcs.empty());
total += rpcs.size();
}
// Every row is reachable through exactly one product object.
ASSERT_EQ(total, call_count());
}
+138
View File
@@ -0,0 +1,138 @@
// Opt-in live, READ-ONLY probes of every ops product (MOLO_LIVE_NET=1,
// GOOGLE_ACCESS_TOKEN, GOOGLE_CLOUD_PROJECT). One list or get per product.
// Nothing is created, changed, enabled, disabled or deleted. A disabled API
// is reported loudly (API NOT ENABLED) and is not a failure: enabling is a
// human decision. A 400 or 401 IS a failure (our request or token is wrong).
#include <cstdlib>
#include <functional>
#include <iostream>
#include <string>
#include "framework.h"
#include "google/credentials.h"
#include "google/errors.h"
#include "google/ops/api_state.h"
#include "google/ops/ops.h"
using namespace molo::google;
using namespace molo::google::ops;
using molo::clients::body::Json;
namespace {
bool ready() {
return std::getenv("MOLO_LIVE_NET") && !Credentials::env("GOOGLE_ACCESS_TOKEN").empty() &&
!Credentials::env("GOOGLE_CLOUD_PROJECT").empty();
}
struct Tally {
int ok = 0, off = 0, denied = 0, other = 0, broken = 0;
};
void probe(Tally& t, const std::string& project, const char* what,
const std::function<std::string()>& call) {
try {
std::string summary = call();
std::cout << " OK " << what << ": " << summary << "\n";
++t.ok;
} catch (const GoogleError& e) {
if (auto d = ApiState::disabled(e, project)) {
std::cout << " " << d->loud() << " (" << what << ")\n";
++t.off;
} else if (e.http_status() == 403) {
std::cout << " DENIED " << what << ": 403 " << e.status() << "\n";
++t.denied;
} else if (e.http_status() == 400 || e.http_status() == 401) {
std::cout << " BROKEN " << what << ": " << e.http_status() << " " << e.status() << ": "
<< e.message() << "\n";
++t.broken;
} else {
std::cout << " other " << what << ": " << e.http_status() << " " << e.status() << "\n";
++t.other;
}
}
}
std::string count(const Json& items) {
return std::to_string(items.is_array() ? items.as_array().size() : 0) + " items";
}
} // namespace
TEST(ops_live, read_only_probe_of_every_product) {
if (!ready()) {
std::cout << "SKIP ops_live.read_only_probe_of_every_product (set MOLO_LIVE_NET=1, "
"GOOGLE_ACCESS_TOKEN and GOOGLE_CLOUD_PROJECT)\n";
return;
}
const std::string project = Credentials::env("GOOGLE_CLOUD_PROJECT");
const std::string pn = Names::project(project);
const std::string loc = Names::location(project, "us-central1");
Ops ops(GoogleClient::from_env());
Tally t;
std::cout << " project " << project << "\n";
probe(t, project, "serviceusage list enabled", [&] {
auto enabled = ops.services.enabled_services(pn);
return std::to_string(enabled.size()) + " enabled APIs";
});
probe(t, project, "serviceusage get iam.googleapis.com", [&] {
ServiceState s = ops.services.state(ServiceUsage::service_name(project, "iam.googleapis.com"));
return s.api + " " + s.state;
});
probe(t, project, "serviceusage batchGet", [&] {
Json r = ops.services.batch_get(pn, {ServiceUsage::service_name(project, "run.googleapis.com"),
ServiceUsage::service_name(project, "compute.googleapis.com")});
const Json* s = r.find("services");
return std::to_string(s && s->is_array() ? s->as_array().size() : 0) + " services";
});
probe(t, project, "resourcemanager project", [&] {
return ops.projects.project(pn).find("state")->as_string();
});
probe(t, project, "resourcemanager search", [&] { return count(ops.projects.search_projects()); });
probe(t, project, "compute zones", [&] { return count(ops.compute.zones(project)); });
probe(t, project, "compute instances", [&] {
return count(ops.compute.instances(project, "us-central1-a"));
});
probe(t, project, "run services", [&] { return count(ops.run.services(loc)); });
probe(t, project, "functions", [&] { return count(ops.functions.functions(loc)); });
probe(t, project, "gke clusters", [&] {
Json r = ops.gke.clusters(Names::location(project, "-"));
const Json* c = r.find("clusters");
return std::to_string(c && c->is_array() ? c->as_array().size() : 0) + " clusters";
});
probe(t, project, "cloudbuild builds", [&] {
return count(ops.build.builds(Names::location(project, "global")));
});
probe(t, project, "artifactregistry repositories", [&] {
return count(ops.artifacts.repositories(loc));
});
probe(t, project, "iam serviceAccounts", [&] { return count(ops.iam.service_accounts(pn)); });
probe(t, project, "iam testIamPermissions on the first service account", [&] {
Json accounts = ops.iam.service_accounts(pn);
if (accounts.as_array().empty()) return std::string("no service account");
const Json* name = accounts.as_array()[0].find("name");
Json r = ops.iam.test_permissions(name->as_string(), {"iam.serviceAccounts.get"});
const Json* p = r.find("permissions");
return std::to_string(p && p->is_array() ? p->as_array().size() : 0) + " of 1 permissions held";
});
probe(t, project, "iam roles (first page)", [&] {
return count(ops.iam.list("iam.roles.list", Args().query("pageSize", Json(5)), 1));
});
probe(t, project, "logging log names", [&] { return count(ops.logging.log_names(pn)); });
probe(t, project, "logging entries", [&] {
return count(ops.logging.entries({pn}, "severity>=ERROR", "timestamp desc", 5));
});
probe(t, project, "monitoring alert policies", [&] { return count(ops.monitoring.alert_policies(pn)); });
probe(t, project, "scheduler jobs", [&] { return count(ops.scheduler.jobs(loc)); });
probe(t, project, "tasks queues", [&] { return count(ops.tasks.queues(loc)); });
probe(t, project, "workflows", [&] { return count(ops.workflows.workflows(loc)); });
probe(t, project, "eventarc triggers", [&] { return count(ops.eventarc.triggers(loc)); });
probe(t, project, "billing project info", [&] {
return std::string(ops.billing.project_billing_info(pn).find("billingEnabled") ? "read" : "empty");
});
probe(t, project, "cloudasset search", [&] { return count(ops.assets.search_resources(pn)); });
probe(t, project, "orgpolicy constraints", [&] { return count(ops.policies.constraints(pn)); });
std::cout << " ok " << t.ok << ", API NOT ENABLED " << t.off << ", denied " << t.denied
<< ", other " << t.other << ", broken " << t.broken << "\n";
ASSERT_EQ(t.broken, 0);
}
+158
View File
@@ -0,0 +1,158 @@
// CallPlan: path rendering, validation and caps. Nothing here touches the
// network: a plan is built and inspected, never sent.
#include <string>
#include "framework.h"
#include "google/errors.h"
#include "google/ops/call_plan.h"
using namespace molo::google;
using namespace molo::google::ops;
using molo::clients::body::Json;
namespace {
CallPlan plan(const char* rpc, const Args& a) { return CallPlan::build(call_named(rpc), a); }
template <typename F>
bool rejects(F&& f) {
try {
f();
} catch (const GoogleError& e) {
return e.http_status() == 400 && e.status() == "INVALID_ARGUMENT";
}
return false;
}
} // namespace
TEST(ops_plan, renders_resource_names_and_plain_params) {
Args a;
a.path("name", "projects/p1/locations/europe-west4/services/web");
ASSERT_EQ(plan("run.projects.locations.services.get", a).path(),
"/v2/projects/p1/locations/europe-west4/services/web");
Args z;
z.path("project", "p1").path("zone", "us-central1-a");
ASSERT_EQ(plan("compute.instances.list", z).path(), "/projects/p1/zones/us-central1-a/instances");
ASSERT_EQ(plan("compute.instances.list", z).url(),
"https://compute.googleapis.com/compute/v1/projects/p1/zones/us-central1-a/instances");
Args s;
s.path("name", "projects/p1/services/iam.googleapis.com");
ASSERT_EQ(plan("serviceusage.services.enable", s).path(),
"/v1/projects/p1/services/iam.googleapis.com:enable");
ASSERT_TRUE(plan("serviceusage.services.enable", s).has_body()); // POST always sends {}
ASSERT_EQ(plan("serviceusage.services.enable", s).body().dump(), "{}");
ASSERT_FALSE(plan("run.projects.locations.services.get", a).has_body());
}
TEST(ops_plan, query_is_validated_and_encoded) {
Args a;
a.path("parent", "projects/p1");
a.query("filter", Json("state:ENABLED")).query("pageSize", Json(50));
std::string p = plan("serviceusage.services.list", a).path();
ASSERT_TRUE(p.find("filter=state%3AENABLED") != std::string::npos);
ASSERT_TRUE(p.find("pageSize=50") != std::string::npos);
Args names;
names.path("parent", "projects/p1");
Json arr = Json::array();
arr.push(Json("a.googleapis.com"));
arr.push(Json("b.googleapis.com"));
names.query("names", arr);
std::string q = plan("serviceusage.services.batchGet", names).path();
ASSERT_TRUE(q.find("names=a.googleapis.com&names=b.googleapis.com") != std::string::npos);
Args bad;
bad.path("parent", "projects/p1").query("nope", Json("x"));
ASSERT_TRUE(rejects([&] { plan("serviceusage.services.list", bad); }));
Args frac;
frac.path("parent", "projects/p1").query("pageSize", Json(1.5));
ASSERT_TRUE(rejects([&] { plan("serviceusage.services.list", frac); }));
Args big;
big.path("parent", "projects/p1").query("filter", Json(std::string(2000, 'x')));
ASSERT_TRUE(rejects([&] { plan("serviceusage.services.list", big); }));
}
TEST(ops_plan, path_validation) {
auto with = [](const char* key, const std::string& v) {
Args a;
a.path(key, v);
return a;
};
ASSERT_TRUE(rejects([&] { plan("run.projects.locations.services.get", Args()); })); // missing
ASSERT_TRUE(rejects([&] {
plan("run.projects.locations.services.get", with("name", "projects/p/locations/l")); // shape
}));
ASSERT_TRUE(rejects([&] {
plan("run.projects.locations.services.get", with("name", "projects/p/locations/l/services/../x"));
}));
ASSERT_TRUE(rejects([&] {
plan("run.projects.locations.services.get", with("name", "projects/p/locations/l/services/%2e%2E"));
}));
ASSERT_TRUE(rejects([&] {
plan("run.projects.locations.services.get", with("name", "other/p/locations/l/services/s"));
}));
ASSERT_TRUE(rejects([&] {
plan("run.projects.locations.services.get", with("name", "projects/p/locations/l/services/s?x=1"));
}));
ASSERT_TRUE(rejects([&] {
plan("run.projects.locations.services.get", with("name", "projects/p/locations/l/services/s#f"));
}));
ASSERT_TRUE(rejects([&] {
plan("run.projects.locations.services.get", with("name", "projects/p/locations/l/services/ s"));
}));
ASSERT_TRUE(rejects([&] { plan("compute.instances.get", with("project", "a/b")); }));
ASSERT_TRUE(rejects([&] {
Args a = with("name", "projects/p/locations/l/services/s");
a.path("extra", "x");
plan("run.projects.locations.services.get", a);
}));
ASSERT_TRUE(rejects([&] {
plan("run.projects.locations.services.get",
with("name", "projects/p/locations/l/services/" + std::string(300, 'a')));
}));
// A service account email and an encoded log name are valid segments.
ASSERT_EQ(plan("iam.projects.serviceAccounts.get",
with("name", "projects/p/serviceAccounts/sa@p.iam.gserviceaccount.com")).path(),
"/v1/projects/p/serviceAccounts/sa@p.iam.gserviceaccount.com");
ASSERT_EQ(plan("logging.projects.logs.delete",
with("logName", "projects/p/logs/cloudaudit.googleapis.com%2Factivity")).path(),
"/v2/projects/p/logs/cloudaudit.googleapis.com%2Factivity");
}
TEST(ops_plan, body_is_checked_against_the_table) {
Args a;
a.path("parent", "projects/p1");
a.field("serviceIds", Json::array());
ASSERT_EQ(plan("serviceusage.services.batchEnable", a).body().dump(), "{\"serviceIds\":[]}");
Args typo = a;
typo.field("serviceId", Json("x"));
ASSERT_TRUE(rejects([&] { plan("serviceusage.services.batchEnable", typo); }));
// GET and DELETE take no body.
Args g;
g.path("name", "projects/p/locations/l/services/s").field("x", Json(1));
ASSERT_TRUE(rejects([&] { plan("run.projects.locations.services.get", g); }));
ASSERT_TRUE(rejects([&] { plan("run.projects.locations.services.delete", g); }));
// Body must be an object and at most 1 MiB.
Args notobj;
notobj.path("parent", "projects/p1").body(Json("str"));
ASSERT_TRUE(rejects([&] { plan("serviceusage.services.batchEnable", notobj); }));
Args huge;
huge.path("parent", "projects/p1").field("serviceIds", Json(std::string(1024 * 1024 + 10, 'x')));
ASSERT_TRUE(rejects([&] { plan("serviceusage.services.batchEnable", huge); }));
}
TEST(ops_plan, args_from_json) {
Json doc = Json::parse(
"{\"path\":{\"parent\":\"projects/p1\"},\"query\":{\"pageSize\":5},\"body\":{}}");
Args a = Args::from_json(doc);
ASSERT_EQ(plan("serviceusage.services.list", a).path(), "/v1/projects/p1/services?pageSize=5");
ASSERT_TRUE(rejects([] { Args::from_json(Json::parse("{\"path\":{\"x\":1}}")); }));
ASSERT_TRUE(rejects([] { Args::from_json(Json::parse("{\"query\":[]}")); }));
ASSERT_TRUE(rejects([] { Args::from_json(Json::parse("[]")); }));
}
TEST(ops_plan, plan_json_shows_the_safety_class) {
Args a;
a.path("name", "projects/p/serviceAccounts/x@p.iam.gserviceaccount.com");
Json j = plan("iam.projects.serviceAccounts.delete", a).to_json();
ASSERT_EQ(j.find("safety")->as_string(), "destructive");
ASSERT_EQ(j.find("http")->as_string(), "DELETE");
ASSERT_TRUE(j.find("url")->as_string().rfind("https://iam.googleapis.com/v1/projects/p", 0) == 0);
}
+243
View File
@@ -0,0 +1,243 @@
// Ops products without a credential: validation happens first, dry runs send
// nothing, confirmed and read calls stop at NotConfiguredError. A second rig
// with a bearer and an UNSCRIPTED mock shows the request that would go out
// (the mock refuses to answer, so no Google reply is invented).
#include <string>
#include "framework.h"
#include "clients/transports/mock_transport.h"
#include "google/credentials.h"
#include "google/errors.h"
#include "google/ops/api_state.h"
#include "google/ops/ops.h"
using namespace molo::google;
using namespace molo::google::ops;
using molo::clients::Method;
using molo::clients::body::Json;
using molo::clients::transports::MockTransport;
namespace {
struct Rig {
MockTransport* mock = nullptr;
std::shared_ptr<GoogleClient> client;
explicit Rig(bool bearer = false) {
auto t = std::make_unique<MockTransport>();
mock = t.get();
client = std::make_shared<GoogleClient>(
std::move(t), bearer ? Credentials::bearer("tok") : nullptr);
}
};
bool invalid(const std::function<void()>& f) {
try {
f();
} catch (const NotConfiguredError&) {
return false;
} catch (const GoogleError& e) {
return e.http_status() == 400 && e.status() == "INVALID_ARGUMENT";
}
return false;
}
bool not_configured(const std::function<void()>& f) {
try {
f();
} catch (const NotConfiguredError&) {
return true;
}
return false;
}
const char* kP = "projects/p1";
} // namespace
TEST(ops_products, dry_run_is_the_default_for_writes) {
Rig r;
ServiceUsage su(r.client);
Outcome o = su.enable(ServiceUsage::service_name("p1", "iam.googleapis.com"));
ASSERT_FALSE(o.executed);
ASSERT_EQ(o.plan.path(), "/v1/projects/p1/services/iam.googleapis.com:enable");
Json j = o.to_json();
ASSERT_EQ(j.find("executed")->as_bool(), false);
ASSERT_TRUE(j.find("hint") != nullptr);
ASSERT_FALSE(su.disable(ServiceUsage::service_name("p1", "iam.googleapis.com")).executed);
ASSERT_FALSE(su.batch_enable(kP, {"a.googleapis.com"}).executed);
ASSERT_EQ(r.mock->send_count(), 0u);
// Confirmed: stops at the credential check.
ASSERT_TRUE(not_configured([&] {
su.enable(ServiceUsage::service_name("p1", "iam.googleapis.com"), true);
}));
ASSERT_EQ(r.mock->send_count(), 0u);
}
TEST(ops_products, destructive_calls_have_no_default_and_dry_run) {
Rig r;
Ops ops(r.client);
Outcome d = ops.run.delete_service("projects/p1/locations/l/services/s", false);
ASSERT_FALSE(d.executed);
ASSERT_EQ(d.plan.to_json().find("safety")->as_string(), "destructive");
ASSERT_FALSE(ops.iam.delete_key("projects/p1/serviceAccounts/a@p1.iam.gserviceaccount.com/keys/k", false).executed);
ASSERT_FALSE(ops.compute.delete_instance("p1", "us-central1-a", "vm", false).executed);
ASSERT_FALSE(ops.tasks.purge_queue("projects/p1/locations/l/queues/q", false).executed);
ASSERT_FALSE(ops.functions.delete_function("projects/p1/locations/l/functions/f", false).executed);
ASSERT_FALSE(ops.projects.delete_project(kP, false).executed);
ASSERT_FALSE(ops.logging.delete_log("projects/p1/logs/x", false).executed);
ASSERT_EQ(r.mock->send_count(), 0u);
ASSERT_TRUE(not_configured([&] { ops.run.delete_service("projects/p1/locations/l/services/s", true); }));
}
TEST(ops_products, reads_validate_then_need_a_credential) {
Rig r;
Ops ops(r.client);
ASSERT_TRUE(not_configured([&] { ops.services.list_services(kP); }));
ASSERT_TRUE(not_configured([&] { ops.services.service("projects/p1/services/iam.googleapis.com"); }));
ASSERT_TRUE(not_configured([&] { ops.compute.instances("p1", "us-central1-a"); }));
ASSERT_TRUE(not_configured([&] { ops.run.services("projects/p1/locations/europe-west4"); }));
ASSERT_TRUE(not_configured([&] { ops.iam.service_accounts(kP); }));
ASSERT_TRUE(not_configured([&] { ops.logging.entries({kP}, "severity>=ERROR"); }));
ASSERT_TRUE(not_configured([&] { ops.projects.search_projects(); }));
ASSERT_TRUE(not_configured([&] { ops.assets.search_resources(kP); }));
ASSERT_TRUE(invalid([&] { ops.services.list_services("projects/p1/x"); })); // shape *
ASSERT_TRUE(invalid([&] { ops.services.list_services("projects/../x"); }));
ASSERT_TRUE(invalid([&] { ops.run.service("nonsense"); }));
ASSERT_TRUE(invalid([&] { ops.compute.instances("p1", "zone/../x"); }));
ASSERT_TRUE(invalid([&] { ops.iam.service_account("projects/p1"); }));
ASSERT_EQ(r.mock->send_count(), 0u);
}
TEST(ops_products, caps_and_batches) {
Rig r;
ServiceUsage su(r.client);
std::vector<std::string> many(OpsCaps::kMaxBatchNames + 1, "projects/p1/services/a.googleapis.com");
ASSERT_TRUE(invalid([&] { su.batch_get(kP, many); }));
ASSERT_TRUE(invalid([&] { su.batch_get(kP, {}); }));
ASSERT_TRUE(invalid([&] { su.batch_enable(kP, {}, true); }));
ASSERT_TRUE(invalid([&] { su.batch_enable(kP, {"bad/id"}, true); }));
Ops ops(r.client);
ASSERT_TRUE(invalid([&] { ops.logging.entries({}, "x"); }));
ASSERT_TRUE(invalid([&] { ops.logging.entries({kP}, "x", "timestamp desc", 0); }));
ASSERT_TRUE(invalid([&] { ops.logging.entries({kP}, "x", "timestamp desc", 100000); }));
ASSERT_TRUE(invalid([&] { ops.logging.entries({kP}, "x", "severity", 5); }));
ASSERT_TRUE(invalid([&] { ops.logging.entries({kP}, std::string(3000, 'a')); }));
ASSERT_TRUE(invalid([&] {
ops.credentials.sign_jwt("projects/-/serviceAccounts/a@p1.iam.gserviceaccount.com", "");
}));
ASSERT_TRUE(invalid([&] {
ops.credentials.sign_blob("projects/-/serviceAccounts/a@p1.iam.gserviceaccount.com",
std::string(OpsCaps::kMaxSignPayloadBytes + 1, 'a'));
}));
ASSERT_TRUE(invalid([&] { ServiceUsage::service_name("p/1", "x"); }));
ASSERT_TRUE(invalid([&] { Names::location("p", "a/b"); }));
}
TEST(ops_products, a_product_only_runs_its_own_rows) {
Rig r;
Ops ops(r.client);
Args a;
a.path("name", "projects/p1/services/iam.googleapis.com");
ASSERT_TRUE(invalid([&] { ops.run.read("serviceusage.services.get", a); }));
ASSERT_TRUE(invalid([&] { ops.services.call("run.projects.locations.services.get", a, true); }));
ASSERT_TRUE(invalid([&] { ops.services.read("serviceusage.services.enable", a); })); // not a read
ASSERT_TRUE(invalid([&] { ops.services.list("serviceusage.services.get", a); })); // not a list
ASSERT_TRUE(invalid([&] { ops.services.read("serviceusage.nope", a); }));
ASSERT_TRUE(invalid([&] { ops.services.list("serviceusage.services.list", a, 0); }));
ASSERT_TRUE(invalid([&] { ops.services.list("serviceusage.services.list", a, 1000); }));
ASSERT_EQ(ops.product("serviceusage").product().version, std::string("v1"));
ASSERT_THROW(ops.product("nope"), GoogleError);
}
TEST(ops_products, typed_methods_build_valid_plans) {
Rig r;
Ops ops(r.client);
// Every dry run goes through the real validation of the table row.
ASSERT_EQ(ops.compute.start_instance("p1", "us-central1-a", "vm").plan.path(),
"/projects/p1/zones/us-central1-a/instances/vm/start");
ASSERT_EQ(ops.iam.create_service_account("projects/p1", "worker", "Worker").plan.body().dump(),
"{\"accountId\":\"worker\",\"serviceAccount\":{\"displayName\":\"Worker\"}}");
ASSERT_EQ(ops.iam.create_key("projects/p1/serviceAccounts/w@p1.iam.gserviceaccount.com").plan.path(),
"/v1/projects/p1/serviceAccounts/w@p1.iam.gserviceaccount.com/keys");
ASSERT_EQ(ops.run.run_job("projects/p1/locations/l/jobs/j").plan.path(),
"/v2/projects/p1/locations/l/jobs/j:run");
ASSERT_EQ(ops.functions.generate_upload_url("projects/p1/locations/l").plan.path(),
"/v2/projects/p1/locations/l/functions:generateUploadUrl");
ASSERT_EQ(ops.scheduler.pause_job("projects/p1/locations/l/jobs/j").plan.path(),
"/v1/projects/p1/locations/l/jobs/j:pause");
ASSERT_EQ(ops.tasks.create_task("projects/p1/locations/l/queues/q", Json::object()).plan.body().dump(),
"{\"task\":{}}");
ASSERT_EQ(ops.workflows.create_workflow("projects/p1/locations/l", "wf", Json::object()).plan.path(),
"/v1/projects/p1/locations/l/workflows?workflowId=wf");
ASSERT_EQ(ops.executions.start("projects/p1/locations/l/workflows/wf", "{\"a\":1}").plan.body().dump(),
"{\"argument\":\"{\\\"a\\\":1}\"}");
ASSERT_EQ(ops.eventarc.create_trigger("projects/p1/locations/l", "t", Json::object()).plan.path(),
"/v1/projects/p1/locations/l/triggers?triggerId=t");
ASSERT_TRUE(ops.billing.link_project(kP, "billingAccounts/000-000-000").plan.method() ==
molo::clients::Method::kPut);
ASSERT_EQ(ops.build.cancel_build("projects/p1/locations/l/builds/b").plan.path(),
"/v1/projects/p1/locations/l/builds/b:cancel");
ASSERT_EQ(ops.artifacts.delete_repository("projects/p1/locations/l/repositories/r", false).plan.path(),
"/v1/projects/p1/locations/l/repositories/r");
ASSERT_EQ(ops.gke.set_node_pool_size("projects/p1/locations/l/clusters/c/nodePools/n", 3).plan.body().dump(),
"{\"nodeCount\":3}");
ASSERT_EQ(ops.policies.delete_policy("projects/p1/policies/constraints~foo", false).plan.path(),
"/v2/projects/p1/policies/constraints~foo");
ASSERT_EQ(ops.assets.export_assets(kP, Json::object()).plan.path(), "/v1/projects/p1:exportAssets");
ASSERT_EQ(ops.monitoring.delete_alert_policy("projects/p1/alertPolicies/a", false).plan.path(),
"/v3/projects/p1/alertPolicies/a");
ASSERT_EQ(ops.logging.write_entries(Json::object()).plan.path(), "/v2/entries:write");
ASSERT_EQ(r.mock->send_count(), 0u);
}
TEST(ops_products, confirmed_request_goes_out_with_bearer) {
Rig r(true);
ServiceUsage su(r.client);
// The mock has no scripted answer: the call fails, but the request it saw
// is the one a real transport would carry.
try {
su.list_services(kP, "state:ENABLED");
} catch (const std::exception&) {
}
auto seen = r.mock->seen();
ASSERT_EQ(seen.size(), 1u);
ASSERT_EQ(seen[0].method, "GET");
ASSERT_TRUE(seen[0].target.find("/v1/projects/p1/services?") == 0);
ASSERT_TRUE(seen[0].target.find("filter=state%3AENABLED") != std::string::npos);
ASSERT_EQ(seen[0].headers.get_or("Authorization", ""), "Bearer tok");
}
TEST(ops_products, wait_checks_the_operation_name) {
Rig r;
ServiceUsage su(r.client);
ASSERT_TRUE(invalid([&] { su.wait(""); }));
ASSERT_TRUE(invalid([&] { su.wait("operations/x"); }));
ASSERT_TRUE(invalid([&] { su.wait("projects/p/../x"); }));
ASSERT_TRUE(invalid([&] { su.wait("projects/p/operations/x?y=1"); }));
ASSERT_TRUE(invalid([&] { su.wait("projects/" + std::string(600, 'a')); }));
ASSERT_TRUE(not_configured([&] { su.wait("projects/p/operations/x"); }));
}
TEST(ops_products, service_state_parses_google_documents) {
Json doc = Json::parse(
"{\"name\":\"projects/1/services/iam.googleapis.com\",\"state\":\"DISABLED\","
"\"config\":{\"name\":\"iam.googleapis.com\",\"title\":\"Identity and Access Management (IAM) API\"}}");
ServiceState s = ServiceState::from_json(doc);
ASSERT_EQ(s.api, "iam.googleapis.com");
ASSERT_FALSE(s.enabled());
ASSERT_TRUE(ServiceState::from_json(Json::parse("[]")).name.empty());
}
TEST(ops_products, disabled_api_is_recognised_loudly) {
GoogleError e(403, "PERMISSION_DENIED",
"Identity and Access Management (IAM) API has not been used in project 123 before "
"or it is disabled. Enable it by visiting https://console.developers.google.com/"
"apis/api/iam.googleapis.com/overview?project=123 then retry.");
auto d = ApiState::disabled(e, "p1");
ASSERT_TRUE(d.has_value());
ASSERT_EQ(d->service, "iam.googleapis.com");
ASSERT_EQ(d->loud().rfind("API NOT ENABLED: iam.googleapis.com", 0), 0u);
ASSERT_TRUE(d->activation_url.find("project=p1") != std::string::npos);
ASSERT_FALSE(ApiState::disabled(GoogleError(404, "NOT_FOUND", "no such thing"), "p1").has_value());
ASSERT_FALSE(ApiState::disabled(GoogleError(403, "PERMISSION_DENIED", "caller lacks permission"), "p1")
.has_value());
}