Merge branch 'worktree-agent-afa3d6579009e448f'
This commit is contained in:
@@ -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());
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
Reference in New Issue
Block a user