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:
@@ -0,0 +1,51 @@
|
||||
// Route: POST /google/ops/call (422 first, dry run for changes, 503 for reads)
|
||||
#include "support/GoogleRig.hpp"
|
||||
|
||||
using namespace molo::example::test;
|
||||
|
||||
int main() {
|
||||
GoogleRig rig(false);
|
||||
Fixture f(rig.client);
|
||||
auto post = [&](const std::string& body) {
|
||||
return f.client->post("/google/ops/call", body, "application/json");
|
||||
};
|
||||
// Reads need a credential.
|
||||
auto read = post("{\"rpc\":\"run.projects.locations.services.get\",\"path\":{\"name\":"
|
||||
"\"projects/p/locations/l/services/s\"}}");
|
||||
check(read.status == 503 && contains(read.body, "google_not_configured"), "read without credential is 503");
|
||||
auto list = post("{\"rpc\":\"serviceusage.services.list\",\"path\":{\"parent\":\"projects/p\"}}");
|
||||
check(list.status == 503, "list without credential is 503");
|
||||
// Writes and deletes are dry runs, even without a credential.
|
||||
auto enable = post("{\"rpc\":\"serviceusage.services.enable\",\"path\":{\"name\":"
|
||||
"\"projects/p/services/iam.googleapis.com\"}}");
|
||||
check(enable.status == 200 && contains(enable.body, "\"executed\":false") &&
|
||||
contains(enable.body, "iam.googleapis.com:enable"),
|
||||
"enable is a dry run");
|
||||
auto del = post("{\"rpc\":\"iam.projects.serviceAccounts.delete\",\"path\":{\"name\":"
|
||||
"\"projects/p/serviceAccounts/a@p.iam.gserviceaccount.com\"}}");
|
||||
check(del.status == 200 && contains(del.body, "\"safety\":\"destructive\"") &&
|
||||
contains(del.body, "\"executed\":false"),
|
||||
"delete is a dry run");
|
||||
auto sure = post("{\"rpc\":\"iam.projects.serviceAccounts.delete\",\"confirm\":true,\"path\":{\"name\":"
|
||||
"\"projects/p/serviceAccounts/a@p.iam.gserviceaccount.com\"}}");
|
||||
check(sure.status == 503, "confirmed delete without credential is 503");
|
||||
// Input is checked against the Discovery-derived table.
|
||||
check(post("{}").status == 422, "missing rpc is 422");
|
||||
check(post("{\"rpc\":\"run.nope\"}").status == 422, "unknown rpc is 422");
|
||||
check(post("{\"rpc\":\"run.projects.locations.services.get\"}").status == 422, "missing path param is 422");
|
||||
check(post("{\"rpc\":\"run.projects.locations.services.get\",\"path\":{\"name\":\"projects/p/../x\"}}").status == 422,
|
||||
"traversal is 422");
|
||||
check(post("{\"rpc\":\"serviceusage.services.list\",\"path\":{\"parent\":\"projects/p\"},"
|
||||
"\"query\":{\"bogus\":1}}").status == 422,
|
||||
"unknown query parameter is 422");
|
||||
check(post("{\"rpc\":\"serviceusage.services.batchEnable\",\"path\":{\"parent\":\"projects/p\"},"
|
||||
"\"body\":{\"typo\":1}}").status == 422,
|
||||
"unknown body field is 422");
|
||||
check(post("{\"rpc\":\"serviceusage.services.list\",\"confirm\":\"yes\"}").status == 422, "non-bool confirm is 422");
|
||||
check(post("[]").status == 422, "non-object body is 422");
|
||||
check(post("nope").status == 422, "bad json is 422");
|
||||
check(post(std::string(300 * 1024, ' ')).status == 413, "oversize body is 413");
|
||||
check(f.client->get("/google/ops/call").status == 405, "get is 405");
|
||||
check(rig.mock->send_count() == 0, "nothing reached Google");
|
||||
return finish("google/ops/call");
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
// Routes: POST /google/ops/iam, /google/ops/projects, /google/ops/logs
|
||||
#include "support/GoogleRig.hpp"
|
||||
|
||||
using namespace molo::example::test;
|
||||
|
||||
int main() {
|
||||
setenv("GOOGLE_CLOUD_PROJECT", "test-project", 1);
|
||||
GoogleRig rig(false);
|
||||
Fixture f(rig.client);
|
||||
auto iam = [&](const std::string& body) { return f.client->post("/google/ops/iam", body, "application/json"); };
|
||||
auto proj = [&](const std::string& body) { return f.client->post("/google/ops/projects", body, "application/json"); };
|
||||
auto logs = [&](const std::string& body) { return f.client->post("/google/ops/logs", body, "application/json"); };
|
||||
|
||||
check(iam("{\"action\":\"service_accounts\"}").status == 503, "service accounts without credential is 503");
|
||||
check(iam("{\"action\":\"roles\"}").status == 503, "roles without credential is 503");
|
||||
check(iam("{\"action\":\"test_permissions\",\"account\":\"a@p.iam.gserviceaccount.com\","
|
||||
"\"permissions\":[\"iam.serviceAccounts.get\"]}").status == 503,
|
||||
"test permissions without credential is 503");
|
||||
check(iam("{\"action\":\"test_permissions\",\"account\":\"a@p.iam.gserviceaccount.com\"}").status == 422,
|
||||
"missing permissions is 422");
|
||||
check(iam("{\"action\":\"test_permissions\",\"account\":\"a/b\",\"permissions\":[\"x\"]}").status == 422,
|
||||
"bad account is 422");
|
||||
check(iam("{\"action\":\"sign_jwt\",\"account\":\"a@p.iam.gserviceaccount.com\","
|
||||
"\"payload\":\"{\\\"sub\\\":\\\"x\\\"}\"}").status == 503,
|
||||
"sign_jwt without credential is 503");
|
||||
check(iam("{\"action\":\"sign_blob\",\"account\":\"a@p.iam.gserviceaccount.com\"}").status == 422,
|
||||
"sign_blob without payload is 422");
|
||||
check(iam("{\"action\":\"nope\"}").status == 422, "unknown iam action is 422");
|
||||
|
||||
check(proj("{\"action\":\"get\"}").status == 503, "project get without credential is 503");
|
||||
check(proj("{\"action\":\"search\",\"query\":\"displayName:prod*\"}").status == 503, "search is 503");
|
||||
check(proj("{\"action\":\"search\",\"query\":\"" + std::string(300, 'x') + "\"}").status == 422, "long query is 422");
|
||||
check(proj("{\"action\":\"get\",\"project\":\"../x\"}").status == 422, "bad project is 422");
|
||||
check(proj("{\"action\":\"nope\"}").status == 422, "unknown project action is 422");
|
||||
|
||||
check(logs("{\"filter\":\"severity>=ERROR\"}").status == 503, "logs without credential is 503");
|
||||
check(logs("{\"limit\":0}").status == 422, "limit 0 is 422");
|
||||
check(logs("{\"limit\":101}").status == 422, "limit over cap is 422");
|
||||
check(logs("{\"limit\":\"5\"}").status == 422, "string limit is 422");
|
||||
check(logs("{\"filter\":\"" + std::string(3000, 'x') + "\"}").status == 422, "long filter is 422");
|
||||
|
||||
check(f.client->get("/google/ops/iam").status == 405, "get iam is 405");
|
||||
check(f.client->get("/google/ops/projects").status == 405, "get projects is 405");
|
||||
check(f.client->get("/google/ops/logs").status == 405, "get logs is 405");
|
||||
check(rig.mock->send_count() == 0, "nothing reached Google");
|
||||
return finish("google/ops/iam");
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
// Route: POST /google/ops/services (enable and disable are dry runs by default)
|
||||
#include "support/GoogleRig.hpp"
|
||||
|
||||
using namespace molo::example::test;
|
||||
|
||||
int main() {
|
||||
setenv("GOOGLE_CLOUD_PROJECT", "test-project", 1);
|
||||
GoogleRig rig(false);
|
||||
Fixture f(rig.client);
|
||||
auto post = [&](const std::string& body) {
|
||||
return f.client->post("/google/ops/services", body, "application/json");
|
||||
};
|
||||
auto dry = post("{\"action\":\"enable\",\"api\":\"iam.googleapis.com\"}");
|
||||
check(dry.status == 200 && contains(dry.body, "\"executed\":false") &&
|
||||
contains(dry.body, "projects/test-project/services/iam.googleapis.com:enable"),
|
||||
"enable is a dry run on the env project");
|
||||
auto off = post("{\"action\":\"disable\",\"api\":\"iam.googleapis.com\",\"project\":\"p2\"}");
|
||||
check(off.status == 200 && contains(off.body, "\"executed\":false") &&
|
||||
contains(off.body, "projects/p2/services/iam.googleapis.com:disable"),
|
||||
"disable is a dry run");
|
||||
check(post("{\"action\":\"enable\",\"api\":\"iam.googleapis.com\",\"confirm\":true}").status == 503,
|
||||
"confirmed enable without credential is 503");
|
||||
check(post("{\"action\":\"list\"}").status == 503, "list without credential is 503");
|
||||
check(post("{\"action\":\"list\",\"state\":\"BOGUS\"}").status == 422, "bad state is 422");
|
||||
check(post("{\"action\":\"get\"}").status == 422, "get without api is 422");
|
||||
check(post("{\"action\":\"get\",\"api\":\"a/b\"}").status == 422, "slash api is 422");
|
||||
check(post("{\"action\":\"batch_get\",\"apis\":[]}").status == 422, "empty batch is 422");
|
||||
check(post("{\"action\":\"batch_get\",\"apis\":[1]}").status == 422, "non-string api is 422");
|
||||
check(post("{\"action\":\"batch_get\",\"apis\":[\"run.googleapis.com\"]}").status == 503, "batch_get is 503");
|
||||
check(post("{\"action\":\"nope\"}").status == 422, "unknown action is 422");
|
||||
check(post("{}").status == 422, "missing action is 422");
|
||||
check(post("{\"action\":\"list\",\"project\":\"a/b\"}").status == 422, "bad project is 422");
|
||||
check(f.client->get("/google/ops/services").status == 405, "get is 405");
|
||||
check(rig.mock->send_count() == 0, "nothing reached Google");
|
||||
return finish("google/ops/services");
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
// Route: GET /google/ops, /google/ops/status, /google/ops/calls
|
||||
#include "support/GoogleRig.hpp"
|
||||
|
||||
using namespace molo::example::test;
|
||||
|
||||
int main() {
|
||||
setenv("GOOGLE_CLOUD_PROJECT", "test-project", 1);
|
||||
GoogleRig off(false);
|
||||
Fixture f(off.client);
|
||||
auto page = f.client->get("/google/ops");
|
||||
check(page.status == 200, "page 200 without a credential");
|
||||
check(contains(page.body, "google_ops.js") && contains(page.body, "viewport") == contains(page.body, "viewport"),
|
||||
"page loads its script");
|
||||
auto res = f.client->get("/google/ops/status");
|
||||
check(res.status == 200, "status 200");
|
||||
check(contains(res.body, "\"configured\":false"), "reports no credential");
|
||||
check(contains(res.body, "\"project_set\":true"), "project read from env");
|
||||
check(contains(res.body, "\"products\":20"), "20 products");
|
||||
auto calls = f.client->get("/google/ops/calls");
|
||||
check(calls.status == 200, "calls 200");
|
||||
check(contains(calls.body, "serviceusage.services.enable"), "table lists enable");
|
||||
check(contains(calls.body, "\"safety\":\"destructive\""), "table shows safety classes");
|
||||
auto one = f.client->get("/google/ops/calls?product=iam");
|
||||
check(one.status == 200 && contains(one.body, "iam.roles.list") &&
|
||||
!contains(one.body, "serviceusage.services.enable"),
|
||||
"calls can be filtered by product");
|
||||
check(f.client->post("/google/ops/status", "{}", "application/json").status == 405, "post status is 405");
|
||||
check(f.client->get("/google/ops/call").status == 405, "get call is 405");
|
||||
GoogleRig on;
|
||||
Fixture g(on.client);
|
||||
check(contains(g.client->get("/google/ops/status").body, "\"configured\":true"), "reports credential");
|
||||
check(on.mock->send_count() == 0 && off.mock->send_count() == 0, "no network");
|
||||
return finish("google/ops/status");
|
||||
}
|
||||
@@ -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