Merge branch 'worktree-agent-afa3d6579009e448f'

This commit is contained in:
2026-10-25 15:24:28 +01:00
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());
}