feat(clients): sessions+registry+optimize+armor: close gaps, loud list truncation, shared Gemini adapter

sessions: operations get/list/cancel/delete/wait for engine, session, memory and
serving profile; servingProfiles CRUD. registry: ListResult with truncated flag,
v1alpha twins, gateway/policy operations, authz IAM, deny policy update, boundary
patch/bindings. optimize: make_gemini_model over models::VertexModel (DirectModel
removed), generateSyntheticData, online evaluator operations, trace/log writers.
armor: SecurityAdmin for all SCC v2 methods (attack exposure excluded), documented
agent threat categories, floor settings fixed to location global after live run.
check_discovery.py of all four enforce coverage.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-24 05:43:13 +02:00
co-authored by Claude Sonnet 5.5
parent 29d775a923
commit a3396bfc68
83 changed files with 5020 additions and 378 deletions
+96
View File
@@ -0,0 +1,96 @@
// Routes: GET /agent/armor/categories (no credential) and the Security
// Command Center administration routes under /agent/armor/scc. Without a
// credential a valid request answers 503 google_not_configured; bad input is
// 422 before any traffic; a wrong verb is 405. Google replies are not scripted.
#include <string>
#include <vector>
#include "support/GoogleRig.hpp"
using namespace molo::example::test;
using molo::example::fw::Method;
int main() {
setenv("GOOGLE_CLOUD_PROJECT", "demo-project", 1);
const std::string json = "application/json";
const std::string finding = "organizations/1/sources/2/findings/f1";
struct Route {
std::string path, valid, invalid;
};
const std::vector<Route> routes = {
{"/agent/armor/scc/availability", "{\"scope\":\"projects/demo-project\"}",
"{\"scope\":\"projects/demo-project/locations/global\"}"},
{"/agent/armor/scc/configs/list",
"{\"kind\":\"muteConfigs\",\"parent\":\"projects/demo-project/locations/global\"}",
"{\"kind\":\"widgets\",\"parent\":\"projects/demo-project\"}"},
{"/agent/armor/scc/configs/get",
"{\"kind\":\"muteConfigs\",\"name\":\"projects/demo-project/muteConfigs/m1\"}",
"{\"kind\":\"muteConfigs\",\"name\":\"projects/demo-project\"}"},
{"/agent/armor/scc/finding/state", "{\"finding\":\"" + finding + "\",\"state\":\"INACTIVE\"}",
"{\"finding\":\"" + finding + "\",\"state\":\"MAYBE\"}"},
{"/agent/armor/scc/finding/mute", "{\"finding\":\"" + finding + "\",\"mute\":\"MUTED\"}",
"{\"finding\":\"organizations/1/sources/2\",\"mute\":\"MUTED\"}"},
{"/agent/armor/scc/bulk-mute",
"{\"parent\":\"projects/demo-project\",\"filter\":\"severity=\\\"LOW\\\"\",\"value\":\"MUTED\","
"\"confirm\":\"bulk-mute\"}",
"{\"parent\":\"projects/demo-project\",\"filter\":\"\",\"value\":\"MUTED\",\"confirm\":\"bulk-mute\"}"},
{"/agent/armor/scc/operations/list", "{\"organization\":\"organizations/1\"}",
"{\"organization\":\"projects/demo-project\"}"},
};
{
GoogleRig rig(false);
Fixture f(rig.client);
for (const auto& r : routes) {
auto res = f.client->post(r.path, r.valid, json);
check(res.status == 503 && contains(res.body, "google_not_configured"),
"503 google_not_configured: " + r.path);
}
auto del = f.client->request(Method::Delete,
"/agent/armor/scc/configs?kind=muteConfigs&name=projects/demo-project/muteConfigs/m1");
check(del.status == 503 && contains(del.body, "google_not_configured"), "delete config: 503 without a credential");
check(rig.mock->send_count() == 0, "no upstream traffic without a credential");
}
{
GoogleRig rig;
Fixture f(rig.client);
for (const auto& r : routes) {
auto res = f.client->post(r.path, r.invalid, json);
check(res.status == 422 && contains(res.body, "validation_error"), "422 on bad input: " + r.path);
check(f.client->get(r.path).status == 405, "get is 405: " + r.path);
}
// Limit and guard cases.
check(f.client->post("/agent/armor/scc/bulk-mute",
"{\"parent\":\"projects/demo-project\",\"filter\":\"x\",\"value\":\"MUTED\"}", json)
.status == 422,
"bulk mute without confirm is 422");
check(f.client->post("/agent/armor/scc/bulk-mute",
"{\"parent\":\"projects/demo-project\",\"filter\":\"x\",\"value\":\"UNMUTED\","
"\"confirm\":\"bulk-mute\"}", json).status == 422,
"bulk mute value UNMUTED is not allowed (422)");
check(f.client->request(Method::Delete, "/agent/armor/scc/configs?kind=x&name=y").status == 422,
"delete config: unknown kind is 422");
check(f.client->request(Method::Delete,
"/agent/armor/scc/configs?kind=muteConfigs&name=projects/demo-project").status == 422,
"delete config: a parent is not a config name (422)");
check(f.client->post("/agent/armor/scc/configs").status == 405, "post on the delete route is 405");
check(f.client->post("/agent/armor/findings", "{\"scope\":\"projects/demo-project\",\"family\":\"bogus\"}",
json).status == 422,
"findings: unknown family is 422");
check(rig.mock->send_count() == 0, "side effect: rejected before any upstream call");
}
{
// The category table needs no credential and never calls Google.
GoogleRig rig(false);
Fixture f(rig.client);
auto res = f.client->get("/agent/armor/categories");
check(res.status == 200 && contains(res.headers.get("Content-Type"), "application/json"), "categories 200 json");
check(contains(res.body, "Execution: Container Escape") && contains(res.body, "AGENT_ENGINE_CONTAINER_ESCAPE"),
"lists a documented runtime category and its module");
check(contains(res.body, "AGENT_ENGINE_REVERSE_SHELL") && contains(res.body, "control_plane"),
"lists both families");
check(contains(res.body, "agentAnomaly"), "says how anomaly findings are recognised");
check(f.client->post("/agent/armor/categories").status == 405, "post is 405");
check(rig.mock->send_count() == 0, "side effect: GET never calls Google");
}
return finish("agent/armor/scc");
}
@@ -0,0 +1,71 @@
// Routes: POST /agent/optimize/synthetic, /operations/{list,get,wait,cancel},
// DELETE /agent/optimize/operations, POST /agent/optimize/logs/write
#include <cstdlib>
#include <string>
#include "support/GoogleRig.hpp"
using namespace molo::example::test;
using molo::example::fw::Method;
namespace {
const std::string kJson = "application/json";
const std::string kEval = "projects/test-proj/locations/us-central1/onlineEvaluators/1";
const std::string kOp = kEval + "/operations/7";
struct Case {
std::string path, good, bad;
};
} // namespace
int main() {
setenv("GOOGLE_CLOUD_PROJECT", "test-proj", 1);
const Case cases[] = {
{"/agent/optimize/synthetic", "{\"request\":{\"taskDescription\":\"x\"}}", "{\"request\":{\"nope\":1}}"},
{"/agent/optimize/operations/list", "{\"evaluator\":\"" + kEval + "\"}",
"{\"evaluator\":\"projects/p/locations/l/evaluationRuns/r\"}"},
{"/agent/optimize/operations/get", "{\"name\":\"" + kOp + "\"}", "{\"name\":\"operations/7\"}"},
{"/agent/optimize/operations/wait", "{\"name\":\"" + kOp + "\",\"timeout_seconds\":\"60\"}",
"{\"name\":\"" + kOp + "\",\"timeout_seconds\":\"61\"}"},
{"/agent/optimize/operations/cancel", "{\"name\":\"" + kOp + "\"}", "{\"name\":\"\"}"},
{"/agent/optimize/logs/write", "{\"log_id\":\"agent-check\",\"text\":\"hello\"}",
"{\"log_id\":\"a/b\",\"text\":\"hello\"}"},
};
for (const Case& c : cases) {
{
GoogleRig none(false);
Fixture f(none.client);
auto res = f.client->post(c.path, c.good, kJson);
check(res.status == 503 && contains(res.body, "google_not_configured"),
c.path + ": no credential is a loud 503");
check(none.mock->send_count() == 0, c.path + ": no network without a credential");
}
{
GoogleRig keyed;
Fixture f(keyed.client);
auto res = f.client->post(c.path, c.bad, kJson);
check(res.status == 422 && contains(res.body, "validation_error"), c.path + ": bad input is 422");
check(f.client->get(c.path).status == 405, c.path + ": get is 405");
check(keyed.mock->send_count() == 0, c.path + ": rejected before any upstream call");
}
}
{
GoogleRig none(false);
Fixture f(none.client);
auto del = f.client->request(Method::Delete, "/agent/optimize/operations?name=" + kOp);
check(del.status == 503 && contains(del.body, "google_not_configured"),
"delete operation: no credential is 503");
check(none.mock->send_count() == 0, "no network without a credential");
}
{
GoogleRig keyed;
Fixture f(keyed.client);
check(f.client->request(Method::Delete, "/agent/optimize/operations").status == 422,
"delete: missing name is 422");
check(f.client->request(Method::Delete, "/agent/optimize/operations?name=x").status == 422,
"delete: bad name is 422");
check(f.client->post("/agent/optimize/operations").status == 405, "post on the delete route is 405");
check(keyed.mock->send_count() == 0, "side effect: rejected before any upstream call");
}
return finish("agent/optimize/gaps");
}
+27
View File
@@ -0,0 +1,27 @@
// Routes: POST /agent/registry/deny-policies/list, POST /agent/registry/boundaries/bindings
#include "agent/registry/cases.hpp"
using namespace molo::example::test;
int main() {
check_google_post_route("/agent/registry/deny-policies/list", "{\"project_number\":\"123456\"}",
"{\"project_number\":\"my-project\"}", "non numeric project number");
check_google_post_route("/agent/registry/boundaries/bindings",
"{\"org_id\":\"42\",\"id\":\"pab-1\"}",
"{\"org_id\":\"42\",\"id\":\"a/b\"}", "bad policy id");
{
GoogleRig rig;
Fixture f(rig.client);
check(f.client->post("/agent/registry/deny-policies/list", "{}", "application/json").status == 422,
"limit: a missing project number is 422");
check(f.client->post("/agent/registry/deny-policies/list",
"{\"project_number\":\"" + std::string(21, '1') + "\"}", "application/json")
.status == 422,
"limit: 21 digits is 422");
check(f.client->post("/agent/registry/boundaries/bindings", "{\"org_id\":\"x\",\"id\":\"pab-1\"}",
"application/json").status == 422,
"boundary bindings: bad org id is 422");
check(rig.mock->send_count() == 0, "side effect: rejected before any upstream call");
}
return finish("agent/registry/iam");
}
@@ -14,6 +14,18 @@ int main() {
check(f.client->post("/agent/registry/list", "{\"kind\":\"aiApplications\"}", "application/json").status == 422,
"limit: a collection that is not listable here is 422");
check(f.client->post("/agent/registry/list", "", "application/json").status == 422, "empty body is 422");
check(f.client->post("/agent/registry/list", "{\"kind\":\"agents\",\"version\":\"v2\"}",
"application/json").status == 422,
"limit: an unknown API version is 422");
}
{
// v1alpha is accepted as input and still needs a credential.
GoogleRig rig(false);
Fixture f(rig.client);
auto res = f.client->post("/agent/registry/list", "{\"kind\":\"agents\",\"version\":\"v1alpha\"}",
"application/json");
check(res.status == 503 && contains(res.body, "google_not_configured"), "v1alpha without a credential is 503");
check(rig.mock->send_count() == 0, "side effect: no upstream traffic");
}
return finish("agent/registry/list");
}
@@ -0,0 +1,39 @@
// Routes: POST /agent/registry/operations/list, POST /agent/registry/operations/cancel,
// DELETE /agent/registry/operations (explicit destructive route)
#include "agent/registry/cases.hpp"
using namespace molo::example::test;
using molo::example::fw::Method;
int main() {
for (const char* scope : {"registry", "gateways", "policies"}) {
std::string s = scope;
check_google_post_route("/agent/registry/operations/list", "{\"scope\":\"" + s + "\"}",
"{\"scope\":\"nowhere\"}", "unknown scope");
check_google_post_route("/agent/registry/operations/cancel",
"{\"scope\":\"" + s + "\",\"id\":\"op-1\"}",
"{\"scope\":\"" + s + "\",\"id\":\"a/b\"}", "bad operation id");
}
{
GoogleRig rig(false);
Fixture f(rig.client);
auto del = f.client->request(Method::Delete, "/agent/registry/operations?scope=gateways&id=op-1");
check(del.status == 503 && contains(del.body, "google_not_configured"),
"delete operation: 503 without a credential");
check(rig.mock->send_count() == 0, "side effect: no upstream traffic");
}
{
GoogleRig rig;
Fixture f(rig.client);
check(f.client->request(Method::Delete, "/agent/registry/operations?scope=x&id=op-1").status == 422,
"delete: unknown scope is 422");
check(f.client->request(Method::Delete, "/agent/registry/operations?scope=policies&id=a..b").status == 422,
"delete: bad id is 422");
check(f.client->request(Method::Delete, "/agent/registry/operations").status == 422,
"delete: missing parameters are 422");
check(f.client->get("/agent/registry/operations").status == 405, "get never deletes");
check(f.client->post("/agent/registry/operations").status == 405, "post never deletes");
check(rig.mock->send_count() == 0, "side effect: rejected before any upstream call");
}
return finish("agent/registry/operations");
}
@@ -13,6 +13,9 @@ int main() {
check(res.status == 200, "status 200 without a credential");
check(contains(res.headers.get("Content-Type"), "text/html"), "html");
check(contains(res.body, "Agent registry") && contains(res.body, "agent_registry.js"), "page and script");
check(contains(res.body, "id=\"r-truncated\""), "page has the loud truncation banner");
check(contains(res.body, "id=\"r-version\"") && contains(res.body, "v1alpha"), "page offers v1alpha");
check(contains(res.body, "ops-gateways"), "page offers the operations lists");
check(f.client->post("/agent/registry").status == 405, "post is 405");
check(f.client->get("/agent/registry/nope").status == 404, "unknown sub route is 404");
check(rig.mock->send_count() == 0, "side effect: no upstream traffic");
@@ -15,6 +15,7 @@ int main() {
check(contains(res.headers.get("Content-Type"), "application/json"), "json");
check(contains(res.body, "\"configured\":false") && contains(res.body, "\"project_set\":true"), "state shown");
check(contains(res.body, "\"max_ledger_entries\":5000"), "caps shown");
check(contains(res.body, "\"max_items\":1000"), "the list item cap is stated");
check(rig.mock->send_count() == 0, "side effect: no upstream traffic");
}
{
@@ -57,6 +57,26 @@ int main() {
body("\"scope_key\":\"user_id\",\"scope_value\":\"1\""), body("\"scope_key\":\"\"")},
{"/agent/sessions/memories/purge", body("\"filter\":\"scope.user_id=\\\"1\\\"\""),
body("\"filter\":\"\"")},
{"/agent/sessions/operations/list", body("\"parent\":\"" + kEngine + "/sessions/chat-1\""),
body("\"parent\":\"" + kEngine + "/other/x\"")},
{"/agent/sessions/operations/get", body("\"name\":\"" + kEngine + "/operations/7\""),
body("\"name\":\"" + kEngine + "/operations/..\"")},
{"/agent/sessions/operations/wait",
body("\"name\":\"" + kEngine + "/operations/7\",\"timeout_seconds\":\"60\""),
body("\"name\":\"" + kEngine + "/operations/7\",\"timeout_seconds\":\"61\"")},
{"/agent/sessions/operations/cancel",
body("\"name\":\"" + kEngine + "/memories/mem-1/operations/7\""),
body("\"name\":\"operations/7\"")},
{"/agent/sessions/serving-profiles/list", "{\"location\":\"us-central1\"}",
"{\"location\":\"Bad Place\"}"},
{"/agent/sessions/serving-profiles/get",
"{\"location\":\"us-central1\",\"profile_id\":\"sp-1\"}",
"{\"location\":\"us-central1\",\"profile_id\":\"Bad_Id\"}"},
{"/agent/sessions/serving-profiles/create",
"{\"location\":\"us-central1\",\"profile_id\":\"sp-1\",\"display_name\":\"Live\","
"\"scope\":\"GEMINI_LIVE\"}",
"{\"location\":\"us-central1\",\"profile_id\":\"sp-1\",\"display_name\":\"Live\","
"\"scope\":\"EVERYTHING\"}"},
};
GoogleRig rig(false);
@@ -119,6 +139,30 @@ int main() {
422,
"delete memory: bad id is 422");
auto del_op = f.client->request(
Method::Delete, "/agent/sessions/operations/operation?engine=" + kEngine +
"&name=" + kEngine + "/operations/7");
check(del_op.status == 503 && contains(del_op.body, "google_not_configured"),
"delete operation: no credential is 503");
check(f.client->request(Method::Delete,
"/agent/sessions/operations/operation?engine=" + kEngine +
"&name=" + kEngine + "/sessions").status == 422,
"delete operation: a name that is no operation is 422");
check(f.client->post("/agent/sessions/operations/operation").status == 405,
"delete operation route: post is 405");
auto del_profile = f.client->request(
Method::Delete, "/agent/sessions/serving-profiles/profile?location=us-central1&id=sp-1");
check(del_profile.status == 503 && contains(del_profile.body, "google_not_configured"),
"delete serving profile: no credential is 503");
check(f.client->request(Method::Delete,
"/agent/sessions/serving-profiles/profile?location=us-central1&id=A_B")
.status == 422,
"delete serving profile: bad id is 422");
check(f.client->post("/agent/sessions/operations/wait",
body("\"name\":\"" + kEngine + "/operations/7\",\"timeout_seconds\":\"0\""),
kJson).status == 422,
"server-side wait of 0 seconds is 422");
check(rig.mock->send_count() == 0, "side effect: nothing reached the network");
// With a credential, validation still runs first and still stops traffic.
@@ -12,6 +12,8 @@ int main() {
check(contains(page.headers.get("Content-Type"), "text/html"), "html");
check(contains(page.body, "Agent sessions and memory"), "heading");
check(contains(page.body, "/agent/sessions/memories/purge"), "lists the purge route");
check(contains(page.body, "/agent/sessions/operations/wait"), "lists the server-side wait route");
check(contains(page.body, "/agent/sessions/serving-profiles/list"), "lists serving profiles");
check(contains(page.body, "viewport"), "mobile viewport meta from the base template");
auto status = f.client->get("/agent/sessions/status");
@@ -20,6 +22,7 @@ int main() {
check(contains(status.body, "\"configured\":true"), "configured with a credential");
check(contains(status.body, "aiplatform v1beta1"), "names the API surface");
check(contains(status.body, "\"max_top_k\":50"), "shows the top_k cap");
check(contains(status.body, "\"max_server_wait_seconds\":60"), "shows the wait cap");
check(!contains(status.body, kTestKey), "credential never shown");
check(rig.mock->send_count() == 0, "side effect: GET pages never call Google");
}
+43 -6
View File
@@ -19,6 +19,7 @@
#include "google/armor/findings.h"
#include "google/armor/guarded_model.h"
#include "google/armor/model_armor.h"
#include "google/armor/security_admin.h"
#include "google/credentials.h"
using namespace molo::google;
@@ -252,13 +253,13 @@ TEST(armor_model_armor, requests_match_discovery) {
"modelarmor.projects.locations.templates.sanitizeModelResponse", std::string("/v1/") + p + "/templates/t1:sanitizeModelResponse");
FloorSetting f;
check(on_fresh([&](ModelArmor& armor) { armor.get_floor_setting(); }),
"modelarmor.projects.locations.getFloorSetting", "/v1/projects/demo-project/locations/us-central1/floorSetting");
"modelarmor.projects.locations.getFloorSetting", "/v1/projects/demo-project/locations/global/floorSetting");
check(on_fresh([&](ModelArmor& armor) { armor.update_floor_setting(f, {"enableFloorSettingEnforcement"}); }),
"modelarmor.projects.locations.updateFloorSetting", "/v1/projects/demo-project/locations/us-central1/floorSetting?updateMask=");
"modelarmor.projects.locations.updateFloorSetting", "/v1/projects/demo-project/locations/global/floorSetting?updateMask=");
check(on_fresh([&](ModelArmor& armor) { armor.get_floor_setting("folders/42"); }),
"modelarmor.folders.locations.getFloorSetting", "/v1/folders/42/locations/us-central1/floorSetting");
"modelarmor.folders.locations.getFloorSetting", "/v1/folders/42/locations/global/floorSetting");
check(on_fresh([&](ModelArmor& armor) { armor.get_floor_setting("organizations/7"); }),
"modelarmor.organizations.locations.getFloorSetting", "/v1/organizations/7/locations/us-central1/floorSetting");
"modelarmor.organizations.locations.getFloorSetting", "/v1/organizations/7/locations/global/floorSetting");
check(on_fresh([&](ModelArmor& armor) { armor.list_locations(); }),
"modelarmor.projects.locations.list", "/v1/projects/demo-project/locations");
check(on_fresh([&](ModelArmor& armor) { armor.get_location(); }),
@@ -836,15 +837,51 @@ TEST(google_live_armor, oauth_token_reads_templates_and_findings) {
} catch (const GoogleError& e) {
if (!disabled(e)) throw;
}
// Model Armor locations: list works on the global host only, get on the
// location's own host (observed live 2026-10-24).
try {
ASSERT_TRUE(armor.list_locations().size() > 3);
ArmorLocation here = armor.get_location();
ASSERT_EQ(here.location_id, ctx.location);
} catch (const GoogleError& e) {
if (!disabled(e)) throw;
}
// sanitize needs a template and this test never creates one. When none
// exists, a call against an absent template id proves routing and request
// shape: Google answers 404 NOT_FOUND for the template (observed live).
try {
if (armor.list_templates(1).templates.empty()) {
try {
armor.sanitize_user_prompt("molo-live-check-absent", "hello");
FAIL("an absent template cannot sanitize");
} catch (const GoogleError& e) {
std::cout << " sanitize against an absent template: " << e.http_status() << " "
<< e.status() << ": " << e.message().substr(0, 160) << "\n";
ASSERT_TRUE(e.http_status() == 404 || e.http_status() == 400);
}
}
} catch (const GoogleError& e) {
if (!disabled(e)) throw;
}
// Security Command Center. The API can be enabled while SCC is not
// activated for the project (no organization or tier): sources answers 404
// and the config lists 400 FAILED_PRECONDITION. availability() classifies
// that instead of throwing; findings are listed only when it is available.
SecurityAdmin admin(client);
SccAvailability avail = admin.availability("projects/" + ctx.project);
std::cout << " security command center: " << availability_name(avail) << "\n";
if (avail == SccAvailability::kAvailable) {
SecurityFindings scc(client);
FindingQuery q;
q.scope = "projects/" + ctx.project;
q.page_size = 5;
FindingPage found = scc.list(q);
std::cout << " findings listed: " << found.findings.size() << "\n";
} catch (const GoogleError& e) {
if (!disabled(e)) throw;
SccList mutes = admin.list_configs(SccCollection::kMuteConfigs, q.scope + "/locations/global");
std::cout << " mute configs: " << mutes.items.as_array().size()
<< (mutes.truncated ? " (TRUNCATED)" : "") << "\n";
} else {
std::cout << " findings and configs NOT exercised: SCC is not usable on this project\n";
}
}
+330
View File
@@ -0,0 +1,330 @@
// Armor gap closing: every Security Command Center v2 method outside the
// attack exposure engine (SecurityAdmin), the Agent Threat Detection category
// table, the floor setting location fix. Local only: requests are read back
// from the mock (a fresh client per probe, the circuit breaker opens after a
// run of failures); nothing answers (no scripted Google replies).
#include <cstdlib>
#include <functional>
#include <iostream>
#include <memory>
#include <set>
#include <string>
#include "framework.h"
#include "clients/transports/mock_transport.h"
#include "google/armor/agent_categories.h"
#include "google/armor/calls.h"
#include "google/armor/caps.h"
#include "google/armor/findings.h"
#include "google/armor/model_armor.h"
#include "google/armor/scc_name.h"
#include "google/armor/security_admin.h"
#include "google/credentials.h"
#include "google/errors.h"
using namespace molo::google;
using namespace molo::google::armor;
using molo::clients::body::Json;
using molo::clients::transports::MockTransport;
namespace {
struct Probe {
std::string method, target, body;
std::size_t sent = 0;
bool invalid = false;
std::string error;
};
// Runs f on a fresh client and reports what reached the wire.
Probe probe(const std::function<void(SecurityAdmin&)>& f, bool credential = true) {
auto t = std::make_unique<MockTransport>();
MockTransport* mock = t.get();
auto client = std::make_shared<GoogleClient>(
std::move(t), credential ? Credentials::bearer("tok") : nullptr);
SecurityAdmin admin(client);
Probe p;
try {
f(admin);
} catch (const GoogleError& e) {
p.error = e.what();
p.invalid = e.status() == "INVALID_ARGUMENT" && e.service().empty();
}
p.sent = mock->send_count();
if (p.sent) {
auto s = mock->seen().front();
p.method = s.method;
p.target = s.target;
p.body = s.body;
}
return p;
}
bool has(const std::string& hay, const std::string& needle) {
return hay.find(needle) != std::string::npos;
}
const char* kProj = "projects/p";
const char* kProjLoc = "projects/p/locations/global";
const char* kFinding = "organizations/1/sources/2/findings/f1";
const char* kFindingLoc = "organizations/1/sources/2/locations/global/findings/f1";
} // namespace
TEST(armor_table, rows_are_well_formed_and_every_body_has_fields) {
std::set<std::string> ids;
for (const CallSpec& c : kCalls) {
ASSERT_TRUE(ids.insert(c.rpc).second);
std::string http = c.http;
ASSERT_TRUE(http == "GET" || http == "POST" || http == "PATCH" || http == "DELETE");
if (http == "GET" || http == "DELETE") ASSERT_EQ(std::string(c.request), std::string());
ASSERT_EQ(std::string(c.request).empty(), std::string(c.fields).empty());
}
ASSERT_TRUE(kCallCount >= 140);
// Families that must exist for each scope, with and without a location.
for (const char* scope : {"organizations", "folders", "projects"}) {
for (const char* tail : {"muteConfigs.list", "muteConfigs.create", "findings.bulkMute"}) {
ASSERT_TRUE(find_rpc(std::string("securitycenter.") + scope + "." + tail) != nullptr);
std::string loc = std::string(tail).rfind("findings", 0) == 0
? std::string("securitycenter.") + scope + ".locations." + tail
: std::string("securitycenter.") + scope + ".locations." + tail;
ASSERT_TRUE(find_rpc(loc) != nullptr);
}
}
}
TEST(armor_names, rows_follow_the_name) {
SccName a = SccName::parse("projects/p/locations/global/muteConfigs/m1");
ASSERT_TRUE(a.has_location());
ASSERT_EQ(a.rpc_for("muteConfigs.get"), std::string("securitycenter.projects.locations.muteConfigs.get"));
ASSERT_TRUE(a.row("muteConfigs.get") != nullptr);
SccName b = SccName::parse("projects/p/muteConfigs/m1");
ASSERT_FALSE(b.has_location());
ASSERT_EQ(b.rpc_for("muteConfigs.get"), std::string("securitycenter.projects.muteConfigs.get"));
SccName f = SccName::parse(kFindingLoc);
ASSERT_TRUE(f.has_location());
ASSERT_EQ(f.rpc_for("sources.findings.setState"),
std::string("securitycenter.organizations.sources.locations.findings.setState"));
ASSERT_EQ(SccName::parse(kFinding).rpc_for("sources.findings.setState"),
std::string("securitycenter.organizations.sources.findings.setState"));
// Notification configs and BigQuery exports exist only with a location.
ASSERT_TRUE(SccName::parse("projects/p/notificationConfigs/n").row("notificationConfigs.get") == nullptr);
ASSERT_TRUE(SccName::parse("projects/p/locations/global/notificationConfigs/n").row("notificationConfigs.get") != nullptr);
ASSERT_TRUE(SccName::parse("folders/9/locations/global/bigQueryExports/b").row("bigQueryExports.get") != nullptr);
for (const char* bad : {"", "x/1", "projects", "projects/", "/projects/p", "projects/p/../q",
"projects/p//q", "projects/a b", "sources/1/x"})
ASSERT_THROW(SccName::parse(bad), GoogleError);
}
TEST(armor_admin, config_calls_use_the_declared_rows) {
for (SccCollection c : {SccCollection::kMuteConfigs, SccCollection::kNotificationConfigs,
SccCollection::kBigQueryExports}) {
std::string coll = scc_collection_name(c);
std::string parent = kProjLoc;
std::string name = parent + "/" + coll + "/c1";
Probe p = probe([&](SecurityAdmin& a) { a.list_configs(c, parent); });
ASSERT_EQ(p.method, std::string("GET"));
ASSERT_TRUE(has(p.target, "/v2/" + parent + "/" + coll + "?pageSize=100"));
p = probe([&](SecurityAdmin& a) { a.get_config(c, name); });
ASSERT_TRUE(has(p.target, "/v2/" + name));
p = probe([&](SecurityAdmin& a) { a.delete_config(c, name); });
ASSERT_EQ(p.method, std::string("DELETE"));
Json body = Json::object();
body.set("description", "d");
p = probe([&](SecurityAdmin& a) { a.create_config(c, parent, "c1", body); });
ASSERT_EQ(p.method, std::string("POST"));
ASSERT_TRUE(has(p.target, "/v2/" + parent + "/" + coll + "?"));
ASSERT_TRUE(has(p.target, std::string(c == SccCollection::kMuteConfigs ? "muteConfigId=c1"
: c == SccCollection::kNotificationConfigs ? "configId=c1"
: "bigQueryExportId=c1")));
p = probe([&](SecurityAdmin& a) { a.update_config(c, name, body, "description"); });
ASSERT_EQ(p.method, std::string("PATCH"));
ASSERT_TRUE(has(p.target, "updateMask=description"));
}
// Without a location the mute configs also exist; the other two do not.
Probe p = probe([&](SecurityAdmin& a) { a.list_configs(SccCollection::kMuteConfigs, kProj); });
ASSERT_TRUE(has(p.target, "/v2/projects/p/muteConfigs?pageSize=100"));
p = probe([&](SecurityAdmin& a) { a.list_configs(SccCollection::kBigQueryExports, kProj); });
ASSERT_TRUE(p.invalid);
ASSERT_EQ(p.sent, std::size_t(0));
}
TEST(armor_admin, bad_input_is_refused_before_traffic) {
Json body = Json::object();
body.set("description", "d");
Json bogus = Json::object();
bogus.set("notAField", 1);
std::vector<std::function<void(SecurityAdmin&)>> bad = {
[&](SecurityAdmin& a) { a.list_configs(SccCollection::kMuteConfigs, std::string(kProjLoc) + "/muteConfigs"); },
[&](SecurityAdmin& a) { a.get_config(SccCollection::kMuteConfigs, kProjLoc); },
[&](SecurityAdmin& a) { a.create_config(SccCollection::kMuteConfigs, kProj, "a/b", body); },
[&](SecurityAdmin& a) { a.create_config(SccCollection::kMuteConfigs, kProj, "ok", bogus); },
[&](SecurityAdmin& a) { a.create_config(SccCollection::kMuteConfigs, kProj, "ok", Json::array()); },
[&](SecurityAdmin& a) { a.update_config(SccCollection::kMuteConfigs, "projects/p/muteConfigs/m", body, ""); },
[&](SecurityAdmin& a) { a.update_config(SccCollection::kMuteConfigs, "projects/p/muteConfigs/m", body, "nope"); },
[&](SecurityAdmin& a) { a.update_config(SccCollection::kMuteConfigs, "projects/p/muteConfigs/m", body, "descr iption"); },
[&](SecurityAdmin& a) { a.delete_config(SccCollection::kMuteConfigs, "projects/p"); },
[&](SecurityAdmin& a) { a.set_finding_state("organizations/1/sources/2", FindingState::kActive); },
[&](SecurityAdmin& a) { a.set_finding_mute("../x/findings/f", MuteValue::kMuted); },
[&](SecurityAdmin& a) { a.patch_finding(kFinding, bogus, "category"); },
[&](SecurityAdmin& a) { a.patch_finding(kFinding, body, ""); },
[&](SecurityAdmin& a) { a.create_finding("organizations/1/sources/2", "a/b", body); },
[&](SecurityAdmin& a) { a.bulk_mute(kProj, "", BulkMuteValue::kMuted); },
[&](SecurityAdmin& a) { a.bulk_mute(std::string(kProj) + "/findings", "x", BulkMuteValue::kMuted); },
[&](SecurityAdmin& a) { a.export_findings("organizations/1/sources/2", Json::object()); },
[&](SecurityAdmin& a) { a.create_source("folders/1", body); },
[&](SecurityAdmin& a) { a.create_source("organizations/1/x", body); },
[&](SecurityAdmin& a) { a.update_source("organizations/1", body, "displayName"); },
[&](SecurityAdmin& a) { a.test_source_iam("organizations/1/sources/2", {}); },
[&](SecurityAdmin& a) { a.set_source_iam_policy("organizations/1/sources/2", Json::array()); },
[&](SecurityAdmin& a) { a.update_asset_marks("projects/p/assets/a1", body, "marks.k"); },
[&](SecurityAdmin& a) { a.get_operation("organizations/1"); },
[&](SecurityAdmin& a) { a.list_operations("projects/p"); },
[&](SecurityAdmin& a) { a.cancel_operation("organizations/1/sources/2"); },
[&](SecurityAdmin& a) { a.delete_operation("nope"); },
[&](SecurityAdmin& a) { a.availability("projects/p/locations/global"); },
};
int n = 0;
for (auto& f : bad) {
Probe p = probe(f);
if (!p.invalid || p.sent != 0) FAIL("case " << n << " reached the network or was not invalid: " << p.error);
++n;
}
}
TEST(armor_admin, finding_and_source_calls_use_the_declared_rows) {
Probe p = probe([&](SecurityAdmin& a) { a.set_finding_state(kFinding, FindingState::kInactive); });
ASSERT_EQ(p.method, std::string("POST"));
ASSERT_TRUE(has(p.target, std::string("/v2/") + kFinding + ":setState"));
ASSERT_TRUE(has(p.body, "\"state\":\"INACTIVE\""));
p = probe([&](SecurityAdmin& a) { a.set_finding_mute(kFindingLoc, MuteValue::kUnmuted); });
ASSERT_TRUE(has(p.target, std::string("/v2/") + kFindingLoc + ":setMute"));
ASSERT_TRUE(has(p.body, "\"mute\":\"UNMUTED\""));
Json f = Json::object();
f.set("category", "X");
p = probe([&](SecurityAdmin& a) { a.patch_finding(kFinding, f, "category"); });
ASSERT_EQ(p.method, std::string("PATCH"));
ASSERT_TRUE(has(p.target, std::string("/v2/") + kFinding + "?updateMask=category"));
p = probe([&](SecurityAdmin& a) { a.create_finding("organizations/1/sources/2", "f9", f); });
ASSERT_TRUE(has(p.target, "/v2/organizations/1/sources/2/findings?findingId=f9"));
Json marks = Json::object();
marks.set("marks", Json::parse("{\"k\":\"v\"}"));
p = probe([&](SecurityAdmin& a) { a.update_finding_marks(kFinding, marks, "marks.k"); });
ASSERT_TRUE(has(p.target, std::string("/v2/") + kFinding + "/securityMarks?updateMask=marks.k"));
p = probe([&](SecurityAdmin& a) {
a.update_asset_marks("projects/p/assets/a1/securityMarks", marks, "marks.k");
});
ASSERT_TRUE(has(p.target, "/v2/projects/p/assets/a1/securityMarks?updateMask=marks.k"));
p = probe([&](SecurityAdmin& a) { a.bulk_mute(kProjLoc, "severity=\"LOW\"", BulkMuteValue::kMuted); });
ASSERT_TRUE(has(p.target, std::string("/v2/") + kProjLoc + "/findings:bulkMute"));
ASSERT_TRUE(has(p.body, "\"muteState\":\"MUTED\""));
p = probe([&](SecurityAdmin& a) {
a.export_findings("organizations/1/sources/2/locations/global",
Json::parse("{\"bigQueryDestination\":{}}"));
});
ASSERT_TRUE(has(p.target, "/v2/organizations/1/sources/2/locations/global/findings:export"));
p = probe([&](SecurityAdmin& a) { a.patch_external_system(std::string(kFinding) + "/externalSystems/x", Json::parse("{\"status\":\"OPEN\"}"), "status"); });
ASSERT_TRUE(has(p.target, "/externalSystems/x?updateMask=status"));
p = probe([&](SecurityAdmin& a) { a.create_source("organizations/1", Json::parse("{\"displayName\":\"s\"}")); });
ASSERT_TRUE(has(p.target, "/v2/organizations/1/sources"));
p = probe([&](SecurityAdmin& a) { a.update_source("organizations/1/sources/2", Json::parse("{\"displayName\":\"s\"}"), "displayName"); });
ASSERT_EQ(p.method, std::string("PATCH"));
p = probe([&](SecurityAdmin& a) { a.source_iam_policy("organizations/1/sources/2"); });
ASSERT_EQ(p.method, std::string("POST"));
ASSERT_TRUE(has(p.target, "organizations/1/sources/2:getIamPolicy"));
p = probe([&](SecurityAdmin& a) { a.set_source_iam_policy("organizations/1/sources/2", Json::object()); });
ASSERT_TRUE(has(p.target, ":getIamPolicy")); // read first
p = probe([&](SecurityAdmin& a) { a.test_source_iam("organizations/1/sources/2", {"securitycenter.sources.get"}); });
ASSERT_TRUE(has(p.target, ":testIamPermissions"));
ASSERT_TRUE(has(p.body, "securitycenter.sources.get"));
p = probe([&](SecurityAdmin& a) { a.get_operation("organizations/1/operations/op1"); });
ASSERT_TRUE(has(p.target, "/v2/organizations/1/operations/op1"));
p = probe([&](SecurityAdmin& a) { a.list_operations("organizations/1"); });
ASSERT_TRUE(has(p.target, "/v2/organizations/1/operations?pageSize=100"));
p = probe([&](SecurityAdmin& a) { a.cancel_operation("organizations/1/operations/op1"); });
ASSERT_EQ(p.method, std::string("GET")); // read first
p = probe([&](SecurityAdmin& a) { a.delete_operation("organizations/1/operations/op1"); });
ASSERT_EQ(p.method, std::string("GET"));
p = probe([&](SecurityAdmin& a) { a.availability("projects/p"); });
ASSERT_TRUE(has(p.target, "/v2/projects/p/sources?pageSize=1"));
}
TEST(armor_admin, no_credential_is_loud_and_offline) {
auto t = std::make_unique<MockTransport>();
MockTransport* mock = t.get();
SecurityAdmin admin(std::make_shared<GoogleClient>(std::move(t), nullptr));
ASSERT_THROW(admin.list_configs(SccCollection::kMuteConfigs, kProj), NotConfiguredError);
ASSERT_THROW(admin.availability("projects/p"), NotConfiguredError);
ASSERT_THROW(admin.delete_config(SccCollection::kMuteConfigs, "projects/p/muteConfigs/m"), NotConfiguredError);
ASSERT_EQ(mock->send_count(), std::size_t(0));
}
TEST(armor_admin, availability_names_are_stable) {
ASSERT_EQ(std::string(availability_name(SccAvailability::kNotActivated)), std::string("not_activated"));
ASSERT_EQ(std::string(availability_name(SccAvailability::kApiDisabled)), std::string("api_disabled"));
ASSERT_EQ(std::string(availability_name(SccAvailability::kAvailable)), std::string("available"));
}
TEST(armor_categories, table_is_complete_and_consistent) {
const auto& all = AgentCategories::all();
ASSERT_TRUE(all.size() >= 55);
std::set<std::string> seen;
std::size_t runtime = 0, control = 0;
for (const AgentCategory& c : all) {
ASSERT_TRUE(seen.insert(c.category).second);
if (c.alt[0]) ASSERT_TRUE(seen.insert(c.alt).second);
(c.family == AgentFamily::kRuntime ? runtime : control)++;
if (c.family == AgentFamily::kRuntime) {
ASSERT_EQ(std::string(c.module).rfind("AGENT_ENGINE_", 0), std::size_t(0));
}
}
ASSERT_TRUE(runtime >= 38);
ASSERT_TRUE(control >= 14);
const AgentCategory* c = AgentCategories::find("Execution: Container Escape");
ASSERT_TRUE(c != nullptr);
ASSERT_EQ(std::string(c->module), std::string("AGENT_ENGINE_CONTAINER_ESCAPE"));
ASSERT_TRUE(AgentCategories::find("Exfiltration: AI Agent Initiated Cloud SQL Exfiltration to Public Bucket") ==
AgentCategories::find("Exfiltration: AI Agent Initiated CloudSQL Exfiltration to Public Bucket"));
ASSERT_TRUE(AgentCategories::find("Persistence: New Geography for AI Service") == nullptr);
ASSERT_TRUE(AgentCategories::find_module("AGENT_ENGINE_REVERSE_SHELL") != nullptr);
ASSERT_TRUE(AgentCategories::find_module("") == nullptr);
ASSERT_TRUE(AgentCategories::is_agent_threat("Reverse Shell"));
}
TEST(armor_categories, every_category_is_accepted_by_the_finding_filter) {
FindingQuery q;
q.scope = "projects/p";
q.categories = AgentCategories::strings(AgentFamily::kRuntime);
std::string filter = q.filter(); // validates every string
ASSERT_TRUE(has(filter, "category=\"Execution: Container Escape\""));
ASSERT_TRUE(has(filter, "(CVE-2024-47177)"));
q.categories = AgentCategories::strings(AgentFamily::kControlPlane);
q.filter();
q.categories = AgentCategories::strings();
ASSERT_TRUE(q.categories.size() <= ArmorCaps::kMaxFilterCategories);
q.filter();
q.categories = {"bad\"quote"};
ASSERT_THROW(q.filter(), GoogleError);
q.categories = {"bad\\slash"};
ASSERT_THROW(q.filter(), GoogleError);
q.categories = {std::string("tab\there")};
ASSERT_THROW(q.filter(), GoogleError);
}
TEST(armor_model_armor, floor_settings_live_at_global_only) {
auto t = std::make_unique<MockTransport>();
MockTransport* mock = t.get();
auto client = std::make_shared<GoogleClient>(std::move(t), Credentials::bearer("tok"));
CloudContext c;
c.project = "p";
c.location = "us-central1";
ModelArmor armor(client, c);
try {
armor.get_floor_setting();
} catch (const GoogleError&) {
}
auto seen = mock->seen();
ASSERT_EQ(seen.size(), std::size_t(1));
ASSERT_TRUE(has(seen[0].target, "/v1/projects/p/locations/global/floorSetting"));
ASSERT_EQ(armor.floor_path(""), std::string("/projects/p/locations/global/floorSetting"));
}
+284
View File
@@ -0,0 +1,284 @@
// Optimize gap closing: the shared Gemini adapter (models::VertexModel) behind
// make_gemini_model, online evaluator operations, generateSyntheticData and
// the telemetry writers. Local only: requests are read back from the mock,
// nothing answers (no scripted Google replies).
#include <cstdlib>
#include <iostream>
#include <functional>
#include <memory>
#include <string>
#include <vector>
#include "framework.h"
#include "clients/transports/mock_transport.h"
#include "google/credentials.h"
#include "google/errors.h"
#include "google/models/vertex_model.h"
#include "google/optimize/calls.h"
#include "google/optimize/evaluation_api.h"
#include "google/optimize/model_factory.h"
#include "google/optimize/operations_api.h"
#include "google/optimize/telemetry_writer.h"
using namespace molo::google;
using namespace molo::google::optimize;
using molo::clients::body::Json;
using molo::clients::transports::MockTransport;
namespace {
struct Rig {
MockTransport* mock;
std::shared_ptr<GoogleClient> client;
explicit Rig(bool with_credential = true) {
auto t = std::make_unique<MockTransport>();
mock = t.get();
client = std::make_shared<GoogleClient>(
std::move(t), with_credential ? Credentials::bearer("tok") : nullptr);
}
};
CloudContext ctx() {
CloudContext c;
c.project = "p";
c.location = "us-central1";
return c;
}
bool has(const std::string& hay, const std::string& needle) {
return hay.find(needle) != std::string::npos;
}
MockTransport::SeenRequest first_sent(Rig& rig, const std::function<void()>& fn) {
std::size_t before = rig.mock->seen().size();
try {
fn();
} catch (...) {
}
auto all = rig.mock->seen();
if (all.size() <= before) FAIL("no request reached the transport");
return all[before];
}
bool invalid_without_traffic(Rig& rig, const std::function<void()>& fn) {
std::size_t before = rig.mock->send_count();
try {
fn();
} catch (const GoogleError& e) {
return e.status() == "INVALID_ARGUMENT" && rig.mock->send_count() == before;
}
return false;
}
// Sets or clears environment variables for one test and restores them, so
// later (live) tests still see the caller's credentials.
class EnvGuard {
public:
EnvGuard() {
for (const char* k : {"GOOGLE_ACCESS_TOKEN", "GOOGLE_CLOUD_PROJECT"}) {
const char* v = std::getenv(k);
saved_.push_back({k, v != nullptr, v ? v : ""});
}
}
~EnvGuard() {
for (const auto& s : saved_) {
if (s.had) setenv(s.key.c_str(), s.value.c_str(), 1);
else unsetenv(s.key.c_str());
}
}
private:
struct Saved {
std::string key;
bool had;
std::string value;
};
std::vector<Saved> saved_;
};
const char* kEval = "projects/p/locations/us-central1/onlineEvaluators/oe1";
const std::string kOp = std::string(kEval) + "/operations/op1";
} // namespace
TEST(optimize_model, factory_returns_the_shared_vertex_adapter) {
Rig rig;
auto model = make_gemini_model(rig.client, "gemini-2.5-flash");
auto* vertex = dynamic_cast<models::VertexModel*>(model.get());
ASSERT_TRUE(vertex != nullptr);
ASSERT_EQ(vertex->default_model(), std::string("gemini-2.5-flash"));
ASSERT_TRUE(dynamic_cast<models::VertexModel*>(make_gemini_model(rig.client).get()) != nullptr);
}
TEST(optimize_model, oauth_with_a_project_uses_the_global_project_path) {
EnvGuard guard;
setenv("GOOGLE_ACCESS_TOKEN", "tok", 1);
setenv("GOOGLE_CLOUD_PROJECT", "p1", 1);
Rig rig;
auto model = make_gemini_model(rig.client, "m1");
GenerateRequest req;
req.contents.push_back(Content::user("hi"));
auto r = first_sent(rig, [&] { model->generate(req); });
ASSERT_EQ(r.method, std::string("POST"));
ASSERT_TRUE(has(r.target, "/projects/p1/locations/global/publishers/google/models/m1:generateContent"));
}
TEST(optimize_model, without_a_token_it_is_vertex_express) {
EnvGuard guard;
unsetenv("GOOGLE_ACCESS_TOKEN");
setenv("GOOGLE_CLOUD_PROJECT", "p1", 1);
Rig rig;
auto model = make_gemini_model(rig.client, "m1");
GenerateRequest req;
req.contents.push_back(Content::user("hi"));
auto r = first_sent(rig, [&] { model->generate(req); });
ASSERT_TRUE(has(r.target, "/publishers/google/models/m1:generateContent"));
ASSERT_FALSE(has(r.target, "/projects/"));
// A bad model name is refused before any traffic.
ASSERT_TRUE(invalid_without_traffic(rig, [&] { make_gemini_model(rig.client, "a/b"); }));
}
TEST(optimize_operations, names_and_bounds) {
ASSERT_TRUE(OnlineEvaluatorOperations::is_operation_name(kOp));
for (const char* bad : {"", "operations/1", "projects/p/locations/l/onlineEvaluators/e",
"projects/p/locations/l/evaluationRuns/e/operations/o",
"projects/p/locations/l/onlineEvaluators/e/operations/",
"projects/p/locations/l/onlineEvaluators/e/operations/..",
"projects/p/locations/l/onlineEvaluators/e/operations/o/x"})
ASSERT_FALSE(OnlineEvaluatorOperations::is_operation_name(bad));
Rig rig;
OnlineEvaluatorOperations ops(rig.client, ctx());
ASSERT_TRUE(invalid_without_traffic(rig, [&] { ops.get("nope"); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { ops.cancel("nope"); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { ops.remove("nope"); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { ops.wait_server(kOp, 0); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { ops.wait_server(kOp, 61); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { ops.list("projects/p/locations/l/evaluationRuns/r"); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { ops.list(kEval, "", 101); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { ops.list(kEval, std::string(1001, 'x')); }));
Rig off(false);
OnlineEvaluatorOperations n(off.client, ctx());
ASSERT_THROW(n.get(kOp), NotConfiguredError);
ASSERT_EQ(off.mock->send_count(), std::size_t(0));
}
TEST(optimize_operations, requests_use_the_declared_rows) {
Rig rig;
OnlineEvaluatorOperations ops(rig.client, ctx());
auto r = first_sent(rig, [&] { ops.get(kOp); });
ASSERT_EQ(r.method, std::string("GET"));
ASSERT_TRUE(has(r.target, "/v1/" + kOp));
r = first_sent(rig, [&] { ops.cancel(kOp); });
ASSERT_EQ(r.method, std::string("POST"));
ASSERT_TRUE(has(r.target, kOp + ":cancel"));
r = first_sent(rig, [&] { ops.remove(kOp); });
ASSERT_EQ(r.method, std::string("DELETE"));
r = first_sent(rig, [&] { ops.wait_server(kOp, 30); });
ASSERT_EQ(r.method, std::string("POST"));
ASSERT_TRUE(has(r.target, kOp + ":wait?timeout=30s"));
r = first_sent(rig, [&] { ops.list(kEval, "done=true", 20); });
ASSERT_TRUE(has(r.target, std::string(kEval) + "/operations?"));
ASSERT_TRUE(has(r.target, "pageSize=20"));
}
TEST(optimize_synthetic_data, request_is_checked_against_the_table) {
Rig rig;
EvaluationApi api(rig.client, ctx());
ASSERT_TRUE(invalid_without_traffic(rig, [&] { api.generate_synthetic_data(Json::object()); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] {
api.generate_synthetic_data(Json::parse("{\"notAField\":1}"));
}));
const CallSpec& spec = call_spec(rpc::kGenerateSyntheticData);
std::string field = split_list(spec.body_fields).front();
Json body = Json::object();
body.set(field, Json::object());
auto r = first_sent(rig, [&] { api.generate_synthetic_data(body); });
ASSERT_EQ(r.method, std::string("POST"));
ASSERT_TRUE(has(r.target, "/v1/projects/p/locations/us-central1:generateSyntheticData"));
}
TEST(optimize_writers, trace_writer_validates_then_uses_v1_and_v2) {
Rig rig;
TraceWriter w(rig.client);
ASSERT_TRUE(invalid_without_traffic(rig, [&] { w.patch_traces("BAD ID", Json::object()); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { w.patch_traces("p", Json::parse("{\"traces\":{}}")); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { w.batch_write("p", Json::parse("{\"spans\":[]}")); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { w.batch_write("p", Json::parse("{\"other\":[1]}")); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { w.create_span("x", Json::object()); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] {
w.create_span("projects/p/traces/abc/spans/s1", Json::parse("{\"name\":\"other\"}"));
}));
auto r = first_sent(rig, [&] {
w.patch_traces("p", Json::parse("{\"traces\":{\"traces\":[{\"traceId\":\"a\"}]}}"));
});
ASSERT_EQ(r.method, std::string("PATCH"));
ASSERT_TRUE(has(r.target, "/v1/projects/p/traces"));
r = first_sent(rig, [&] { w.batch_write("p", Json::parse("{\"spans\":[{\"name\":\"n\"}]}")); });
ASSERT_EQ(r.method, std::string("POST"));
ASSERT_TRUE(has(r.target, "/v2/projects/p/traces:batchWrite"));
r = first_sent(rig, [&] {
w.create_span("projects/p/traces/abc/spans/s1", Json::parse("{\"name\":\"projects/p/traces/abc/spans/s1\"}"));
});
ASSERT_TRUE(has(r.target, "/v2/projects/p/traces/abc/spans/s1"));
}
TEST(optimize_writers, log_writer_validates_then_uses_the_table) {
Rig rig;
LogWriter w(rig.client);
ASSERT_TRUE(invalid_without_traffic(rig, [&] { w.write(Json::object()); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { w.write(Json::parse("{\"entries\":[]}")); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { w.write(Json::parse("{\"bogus\":[1]}")); }));
Json many = Json::array();
for (int i = 0; i < 1001; ++i) many.push(Json::object());
Json big = Json::object();
big.set("entries", many);
ASSERT_TRUE(invalid_without_traffic(rig, [&] { w.write(big); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { w.copy(Json::parse("{\"name\":\"x\"}")); }));
auto r = first_sent(rig, [&] {
w.write(Json::parse("{\"dryRun\":true,\"logName\":\"projects/p/logs/l\",\"entries\":[{\"textPayload\":\"x\"}]}"));
});
ASSERT_EQ(r.method, std::string("POST"));
ASSERT_TRUE(has(r.target, "/v2/entries:write"));
ASSERT_TRUE(has(r.body, "\"dryRun\":true"));
r = first_sent(rig, [&] { w.copy(Json::parse("{\"name\":\"projects/p/locations/global/buckets/b\",\"destination\":\"storage.googleapis.com/b2\"}")); });
ASSERT_TRUE(has(r.target, "/v2/entries:copy"));
}
// Read-only live probe (MOLO_LIVE_NET=1, GOOGLE_ACCESS_TOKEN, GOOGLE_CLOUD_PROJECT;
// loud SKIP otherwise). Observed 2026-10-24: an operations list under a
// numeric, absent online evaluator id answers 200 with no operations; a
// non numeric evaluator id is 400 INVALID_ARGUMENT from Google's LRO layer.
TEST(optimize_live_gaps, online_evaluator_operations_list_and_shared_model) {
std::string project = Credentials::env("GOOGLE_CLOUD_PROJECT");
if (!std::getenv("MOLO_LIVE_NET") || Credentials::env("GOOGLE_ACCESS_TOKEN").empty() ||
project.empty()) {
std::cout << "SKIP optimize_live_gaps (set MOLO_LIVE_NET=1, GOOGLE_ACCESS_TOKEN and "
"GOOGLE_CLOUD_PROJECT)\n";
return;
}
auto client = GoogleClient::from_env();
CloudContext c;
c.project = project;
c.location = "us-central1";
OnlineEvaluatorOperations ops(client, c);
OperationPage page = ops.list("projects/" + project + "/locations/us-central1/onlineEvaluators/1");
ASSERT_EQ(page.operations.size(), std::size_t(0));
ASSERT_FALSE(page.truncated);
// The shared adapter answers a real generateContent (a few tokens).
auto model = make_gemini_model(client);
GenerateRequest req;
req.contents.push_back(Content::user("Reply with the single word: ok"));
GenerateResponse res = model->generate(req);
ASSERT_FALSE(res.text().empty());
std::cout << " shared VertexModel reply chars: " << res.text().size() << "\n";
}
TEST(optimize_table, new_calls_are_rows) {
for (const char* id : {rpc::kGenerateSyntheticData, rpc::kOnlineEvaluatorOpGet,
rpc::kOnlineEvaluatorOpList, rpc::kOnlineEvaluatorOpCancel,
rpc::kOnlineEvaluatorOpDelete, rpc::kOnlineEvaluatorOpWait,
rpc::kTracePatch, rpc::kTraceBatchWrite, rpc::kTraceCreateSpan,
rpc::kLogEntriesWrite, rpc::kLogEntriesCopy})
ASSERT_TRUE(find_call(id) != nullptr);
ASSERT_TRUE(all_calls().size() >= 46);
}
+2 -2
View File
@@ -7,7 +7,7 @@
#include "framework.h"
#include "google/credentials.h"
#include "google/optimize/autorater.h"
#include "google/optimize/direct_model.h"
#include "google/optimize/model_factory.h"
#include "google/optimize/eval_resources.h"
#include "google/optimize/evaluation_api.h"
#include "google/optimize/observability.h"
@@ -105,7 +105,7 @@ TEST(optimize_live, llm_judged_evaluate_instances) {
TEST(optimize_live, autorater_parses_a_real_model_reply) {
if (!live("optimize_live.autorater_parses_a_real_model_reply", false)) return;
auto model = DirectModel::from_env(GoogleClient::from_env());
auto model = make_gemini_model(GoogleClient::from_env());
Autorater rater(model);
Conversation c = Conversation::parse_transcript(
"user: What is 2+2?\nagent: 4.", "live");
@@ -0,0 +1,299 @@
// Registry gap closing: lists that report truncation loudly, v1alpha twins of
// every v1 collection, operations of the gateway and policy hosts, IAM on
// authz policies, deny policy update, boundary patch and bindings search.
// Local only: the paging state machine is fed synthetic documents (it is local
// logic, not a claim about Google's replies) and requests are inspected as the
// mock saw them. Nothing answers.
#include <functional>
#include <memory>
#include <set>
#include <string>
#include "framework.h"
#include "clients/transports/mock_transport.h"
#include "google/credentials.h"
#include "google/registry/agent_gateway.h"
#include "google/registry/agent_identity.h"
#include "google/registry/agent_registry.h"
#include "google/registry/approvals.h"
#include "google/registry/call_runner.h"
#include "google/registry/caps.h"
#include "google/registry/gateway_policy.h"
using namespace molo::google;
using namespace molo::google::registry;
using molo::clients::body::Json;
using molo::clients::transports::MockTransport;
namespace {
struct Rig {
MockTransport* mock;
std::shared_ptr<GoogleClient> client;
explicit Rig(bool with_credential = true) {
auto t = std::make_unique<MockTransport>();
mock = t.get();
client = std::make_shared<GoogleClient>(
std::move(t), with_credential ? Credentials::bearer("tok") : nullptr);
}
CloudContext ctx() const {
CloudContext c;
c.project = "p";
c.location = "us-central1";
return c;
}
};
bool has(const std::string& hay, const std::string& needle) {
return hay.find(needle) != std::string::npos;
}
// Runs fn (which fails: the mock has no expectation) and returns the first
// request that reached the transport during it.
MockTransport::SeenRequest first_sent(Rig& rig, const std::function<void()>& fn) {
std::size_t before = rig.mock->seen().size();
try {
fn();
} catch (...) {
}
auto all = rig.mock->seen();
if (all.size() <= before) FAIL("no request reached the transport");
return all[before];
}
template <typename F>
bool invalid_without_traffic(Rig& r, F&& f) {
std::size_t before = r.mock->send_count();
try {
f();
} catch (const GoogleError& e) {
return e.status() == "INVALID_ARGUMENT" && r.mock->send_count() == before;
}
return false;
}
Json page(int items, const std::string& next) {
Json arr = Json::array();
for (int i = 0; i < items; ++i) {
Json o = Json::object();
o.set("name", Json("x/" + std::to_string(i)));
arr.push(o);
}
Json doc = Json::object();
doc.set("agents", arr);
if (!next.empty()) doc.set("nextPageToken", Json(next));
return doc;
}
} // namespace
TEST(registry_lists, pager_follows_pages_until_the_server_stops) {
ListPager p("agents", 10, 1000);
ASSERT_TRUE(p.feed(page(100, "t1")));
ASSERT_EQ(p.token(), std::string("t1"));
ASSERT_FALSE(p.feed(page(7, "")));
ASSERT_EQ(p.result().size(), std::size_t(107));
ASSERT_EQ(p.result().pages, std::size_t(2));
ASSERT_FALSE(p.result().truncated);
ASSERT_EQ(p.result().next_page_token, std::string());
}
TEST(registry_lists, pager_reports_truncation_at_the_page_cap_loudly) {
ListPager p("agents", 3, 1000);
ASSERT_TRUE(p.feed(page(100, "t1")));
ASSERT_TRUE(p.feed(page(100, "t2")));
ASSERT_FALSE(p.feed(page(100, "t3"))); // third page used, a fourth exists
ASSERT_TRUE(p.result().truncated);
ASSERT_EQ(p.result().next_page_token, std::string("t3"));
ASSERT_EQ(p.result().size(), std::size_t(300));
Json j = p.result().to_json();
ASSERT_TRUE(j.find("truncated")->as_bool());
ASSERT_EQ(j.find("next_page_token")->as_string(), std::string("t3"));
ASSERT_EQ(j.find("count")->as_int(), 300);
ASSERT_EQ(j.find("cap_items")->as_int(), 1000);
}
TEST(registry_lists, pager_reports_truncation_at_the_item_cap_loudly) {
ListPager p("agents", 100, 250);
ASSERT_TRUE(p.feed(page(100, "t1")));
ASSERT_TRUE(p.feed(page(100, "t2")));
ASSERT_FALSE(p.feed(page(100, "t3"))); // 300 returned, 250 allowed
ASSERT_TRUE(p.result().truncated);
ASSERT_EQ(p.result().size(), std::size_t(250));
ASSERT_EQ(p.result().next_page_token, std::string()); // no exact continuation
}
TEST(registry_lists, a_list_that_ends_exactly_at_the_cap_is_not_truncated) {
ListPager p("agents", 2, 200);
ASSERT_TRUE(p.feed(page(100, "t1")));
ASSERT_FALSE(p.feed(page(100, "")));
ASSERT_FALSE(p.result().truncated);
ASSERT_EQ(p.result().size(), std::size_t(200));
}
TEST(registry_lists, caps_are_the_stated_ceiling) {
ASSERT_EQ(RegistryCaps::kMaxItems, std::size_t(1000));
ASSERT_EQ(RegistryCaps::kMaxPages, std::size_t(10));
ListPager p("agents", RegistryCaps::kMaxPages, RegistryCaps::kMaxItems);
for (std::size_t i = 0; i + 1 < RegistryCaps::kMaxPages; ++i)
ASSERT_TRUE(p.feed(page(100, "t" + std::to_string(i))));
ASSERT_FALSE(p.feed(page(100, "more")));
ASSERT_TRUE(p.result().truncated); // 1000 items and more existed
}
TEST(registry_lists, the_caller_cannot_page_by_hand) {
Rig rig;
AgentRegistry reg(rig.client, rig.ctx());
ASSERT_TRUE(invalid_without_traffic(rig, [&] {
CallArgs a;
a.vars["parent"] = "projects/p/locations/us-central1";
a.query["pageToken"] = "x";
reg.runner().list("agentregistry.v1.agents.list", "agents", a);
}));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { reg.list(AssetKind::kAgents, {{"pageToken", "x"}}); }));
}
TEST(registry_lists, a_first_page_request_carries_the_stated_page_size) {
Rig rig;
AgentRegistry reg(rig.client, rig.ctx());
auto r = first_sent(rig, [&] { reg.list(AssetKind::kAgents); });
ASSERT_EQ(r.method, std::string("GET"));
ASSERT_TRUE(has(r.target, "/v1/projects/p/locations/us-central1/agents?pageSize=100"));
}
TEST(registry_lists, approved_listing_keeps_the_truncation_flag_in_its_type) {
// list_approved returns ListResult: the flag cannot be dropped silently.
static_assert(std::is_same_v<decltype(std::declval<AgentRegistry>().list_approved(
AssetKind::kAgents, std::declval<ApprovalLedger>())),
ListResult>);
static_assert(std::is_same_v<decltype(std::declval<AgentGateway>().list()), ListResult>);
static_assert(std::is_same_v<decltype(std::declval<GatewayPolicies>().list()), ListResult>);
static_assert(std::is_same_v<decltype(std::declval<AgentIdentity>().deny_policies("a%2Fb")),
ListResult>);
ASSERT_TRUE(true);
}
TEST(registry_versions, v1alpha_twins_exist_for_every_v1_collection) {
std::set<std::string> ids;
for (const CallSpec& c : Calls::all()) ids.insert(c.id);
std::size_t twins = 0;
for (const CallSpec& c : Calls::all()) {
std::string id = c.id;
const std::string v1 = "agentregistry.v1.";
if (id.rfind(v1, 0) != 0) continue;
ASSERT_TRUE(ids.count("agentregistry.v1alpha." + id.substr(v1.size())) == 1);
++twins;
}
ASSERT_TRUE(twins >= 35);
}
TEST(registry_versions, version_picks_the_host_path_and_rows) {
Rig rig;
AgentRegistry v1(rig.client, rig.ctx());
AgentRegistry alpha(rig.client, rig.ctx(), RegistryVersion::kV1Alpha);
ASSERT_EQ(v1.version(), std::string("v1"));
ASSERT_EQ(alpha.version(), std::string("v1alpha"));
ASSERT_EQ(alpha.default_endpoint(RegistryVersion::kV1Alpha).base_url,
std::string("https://agentregistry.googleapis.com/v1alpha"));
auto r = first_sent(rig, [&] { alpha.list(AssetKind::kMcpServers); });
ASSERT_TRUE(has(r.target, "/v1alpha/projects/p/locations/us-central1/mcpServers?pageSize=100"));
r = first_sent(rig, [&] { alpha.get(AssetKind::kAgents, "a1"); });
ASSERT_TRUE(has(r.target, "/v1alpha/projects/p/locations/us-central1/agents/a1"));
r = first_sent(rig, [&] { alpha.operations(); });
ASSERT_TRUE(has(r.target, "/v1alpha/projects/p/locations/us-central1/operations"));
r = first_sent(rig, [&] { v1.operations(); });
ASSERT_TRUE(has(r.target, "/v1/projects/p/locations/us-central1/operations"));
// Skills exist in v1alpha only for CRUD, whichever version is chosen.
r = first_sent(rig, [&] { v1.get(AssetKind::kSkills, "s1"); });
ASSERT_TRUE(has(r.target, "/v1alpha/projects/p/locations/us-central1/skills/s1"));
// Validation still happens before traffic in v1alpha.
ASSERT_TRUE(invalid_without_traffic(rig, [&] { alpha.get(AssetKind::kAgents, "a/b"); }));
}
TEST(registry_operations, gateway_and_policy_hosts_wrap_all_four_operation_methods) {
Rig rig;
AgentGateway gw(rig.client, rig.ctx());
GatewayPolicies pol(rig.client, rig.ctx());
auto r = first_sent(rig, [&] { gw.operations(); });
ASSERT_TRUE(has(r.target, "/v1/projects/p/locations/us-central1/operations"));
r = first_sent(rig, [&] { pol.operations(); });
ASSERT_TRUE(has(r.target, "/v1/projects/p/locations/us-central1/operations"));
// cancel and delete read the operation first.
r = first_sent(rig, [&] { gw.cancel_operation("op-1"); });
ASSERT_EQ(r.method, std::string("GET"));
ASSERT_TRUE(has(r.target, "/operations/op-1"));
r = first_sent(rig, [&] { pol.delete_operation("op-1"); });
ASSERT_EQ(r.method, std::string("GET"));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { gw.cancel_operation("a/b"); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { gw.delete_operation(".."); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { pol.cancel_operation(""); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { pol.delete_operation("x?y"); }));
Rig off(false);
AgentGateway n(off.client, off.ctx());
ASSERT_THROW(n.operations(), NotConfiguredError);
ASSERT_EQ(off.mock->send_count(), std::size_t(0));
}
TEST(registry_policies, iam_on_authz_policies_is_validated_and_read_first) {
Rig rig;
GatewayPolicies pol(rig.client, rig.ctx());
auto r = first_sent(rig, [&] { pol.set_iam_policy("pol-1", Json::parse("{\"bindings\":[]}")); });
ASSERT_EQ(r.method, std::string("GET")); // read before write
ASSERT_TRUE(has(r.target, "/authzPolicies/pol-1"));
r = first_sent(rig, [&] { pol.test_iam_permissions("pol-1", {"networksecurity.authzPolicies.get"}); });
ASSERT_EQ(r.method, std::string("POST"));
ASSERT_TRUE(has(r.target, "/authzPolicies/pol-1:testIamPermissions"));
ASSERT_TRUE(has(r.body, "\"permissions\":[\"networksecurity.authzPolicies.get\"]"));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { pol.set_iam_policy("pol-1", Json::array()); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { pol.set_iam_policy("a/b", Json::object()); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { pol.test_iam_permissions("pol-1", {}); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] {
pol.test_iam_permissions("pol-1", std::vector<std::string>(65, "p.q"));
}));
}
TEST(registry_identity, deny_policy_update_boundary_patch_and_operations) {
Rig rig;
AgentIdentity id(rig.client, rig.ctx());
std::string attach = AgentIdentity::attachment_for_project("123");
DenyPolicySpec spec;
spec.display_name = "deny";
DenyRuleSpec rule;
rule.denied_principals = {"principalSet://goog/group/a@b.c"};
rule.denied_permissions = {"storage.googleapis.com/buckets.delete"};
spec.rules = {rule};
spec.etag = "abc";
ASSERT_TRUE(has(spec.to_json().dump(), "\"etag\":\"abc\""));
spec.etag.clear();
ASSERT_FALSE(has(spec.to_json().dump(), "etag"));
// update reads first (needs the etag and a clear 404).
auto r = first_sent(rig, [&] { id.update_deny_policy(attach, "p1", spec); });
ASSERT_EQ(r.method, std::string("GET"));
ASSERT_TRUE(has(r.target, "/v2/policies/" + attach + "/denypolicies/p1"));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { id.update_deny_policy("plain", "p1", spec); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { id.update_deny_policy(attach, "a/b", spec); }));
r = first_sent(rig, [&] { id.deny_policy_operation("policies/" + attach + "/operations/o1"); });
ASSERT_TRUE(has(r.target, "/v2/policies/" + attach + "/operations/o1"));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { id.deny_policy_operation("operations/o1"); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { id.deny_policy_operation("policies/x"); }));
r = first_sent(rig, [&] { id.engine_operation("op9"); });
ASSERT_TRUE(has(r.target, "/v1/projects/p/locations/us-central1/operations/op9"));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { id.engine_operation("a/b"); }));
AccessBoundarySpec b;
b.display_name = "pab";
b.resources = {"//cloudresourcemanager.googleapis.com/projects/p"};
r = first_sent(rig, [&] { id.update_boundary("42", "pab1", b, {"displayName"}); });
ASSERT_EQ(r.method, std::string("GET")); // exists first
ASSERT_TRUE(has(r.target, "/v3/organizations/42/locations/global/principalAccessBoundaryPolicies/pab1"));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { id.update_boundary("42", "pab1", b, {}); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { id.update_boundary("4x", "pab1", b, {"displayName"}); }));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { id.update_boundary("42", "pab1", b, {"name"}); }));
r = first_sent(rig, [&] { id.boundary_bindings("42", "pab1"); });
ASSERT_TRUE(has(r.target,
"/v3/organizations/42/locations/global/principalAccessBoundaryPolicies/pab1:searchPolicyBindings?pageSize=100"));
ASSERT_TRUE(invalid_without_traffic(rig, [&] { id.boundary_bindings("42", "a/b"); }));
}
@@ -62,9 +62,9 @@ void expect_read(F&& f) {
TEST(registry_live, reasoning_engines_list_with_key_or_token) {
if (!live_ready("registry_live.reasoning_engines_list_with_key_or_token")) return;
AgentIdentity identity(GoogleClient::from_env(), CloudContext::from_env());
molo::clients::body::Json engines = identity.engines();
ASSERT_TRUE(engines.is_array());
std::cout << " engines: " << engines.as_array().size() << "\n";
ListResult engines = identity.engines();
ASSERT_TRUE(engines.items.is_array());
std::cout << " engines: " << engines.size() << (engines.truncated ? " (TRUNCATED)" : "") << "\n";
}
TEST(registry_live, audit_trail_read_needs_oauth) {
@@ -89,6 +89,34 @@ TEST(registry_live, registry_reads) {
expect_read([&] { reg.list(k); });
}
// Gap-closing reads: v1alpha twins of every v1 collection, the operations lists
// of all three registry-side hosts, deny policies (iam v2). Read-only. Each
// answers 200 once its API is enabled; a disabled API is reported loudly.
TEST(registry_live, v1alpha_operations_and_deny_policy_reads) {
if (!live_ready("registry_live.v1alpha_operations_and_deny_policy_reads")) return;
AgentRegistry alpha(GoogleClient::from_env(), CloudContext::from_env(),
RegistryVersion::kV1Alpha);
ASSERT_EQ(alpha.version(), std::string("v1alpha"));
for (AssetKind k : {AssetKind::kServices, AssetKind::kAgents, AssetKind::kMcpServers,
AssetKind::kEndpoints, AssetKind::kBindings, AssetKind::kAiApplications})
expect_read([&] { alpha.list(k); });
AgentRegistry reg(GoogleClient::from_env(), CloudContext::from_env());
expect_read([&] { reg.operations(); });
AgentGateway gw(GoogleClient::from_env(), CloudContext::from_env());
expect_read([&] { gw.operations(); });
GatewayPolicies pol(GoogleClient::from_env(), CloudContext::from_env());
expect_read([&] { pol.operations(); });
// The project number is not known here; the deny policy list needs it. The
// attachment is built from GOOGLE_CLOUD_PROJECT_NUMBER when the caller sets it.
std::string number = Credentials::env("GOOGLE_CLOUD_PROJECT_NUMBER");
if (number.empty()) {
std::cout << "SKIP deny policy list (set GOOGLE_CLOUD_PROJECT_NUMBER)\n";
return;
}
AgentIdentity identity(GoogleClient::from_env(), CloudContext::from_env());
expect_read([&] { identity.deny_policies(AgentIdentity::attachment_for_project(number)); });
}
TEST(registry_live, gateway_and_policy_reads) {
if (!live_ready("registry_live.gateway_and_policy_reads")) return;
AgentGateway gw(GoogleClient::from_env(), CloudContext::from_env());
@@ -0,0 +1,353 @@
// Gap closing for Agent Sessions and Memory Bank: operations (get, list,
// cancel, delete, wait) under the engine, a session, a memory and a serving
// profile; servingProfiles; lists that stop loudly. Requests are inspected as
// the mock saw them; nothing answers (no scripted Google replies).
#include <cstdlib>
#include <functional>
#include <iostream>
#include <memory>
#include <set>
#include <sstream>
#include "framework.h"
#include "clients/transports/mock_transport.h"
#include "google/credentials.h"
#include "google/sessions/calls.h"
#include "google/sessions/memory_bank.h"
#include "google/sessions/operation_names.h"
#include "google/sessions/serving_profile.h"
#include "google/sessions/sessions.h"
using namespace molo::google;
using namespace molo::google::sessions;
using molo::clients::body::Json;
using molo::clients::transports::MockTransport;
namespace {
const char* kEngine = "projects/p1/locations/us-central1/reasoningEngines/e1";
const char* kLocation = "projects/p1/locations/us-central1";
struct Rig {
MockTransport* mock;
std::shared_ptr<GoogleClient> client;
explicit Rig(bool with_credential = true) {
auto t = std::make_unique<MockTransport>();
mock = t.get();
client = std::make_shared<GoogleClient>(
std::move(t), with_credential ? Credentials::bearer("tok") : nullptr);
}
};
bool has(const std::string& hay, const std::string& needle) {
return hay.find(needle) != std::string::npos;
}
std::set<std::string> words(const std::string& s) {
std::set<std::string> out;
std::istringstream in(s);
for (std::string w; in >> w;) out.insert(w);
return out;
}
void keys_declared(const Json& body, Call call) {
std::set<std::string> allowed = words(spec_of(call).fields);
ASSERT_TRUE(body.is_object());
for (const auto& [key, value] : body.as_object()) {
(void)value;
if (!allowed.count(key)) FAIL("body key '" << key << "' not in the table row");
}
}
void invalid(const std::function<void()>& fn) {
try {
fn();
} catch (const GoogleError& e) {
ASSERT_EQ(e.http_status(), 400);
ASSERT_EQ(e.status(), std::string("INVALID_ARGUMENT"));
ASSERT_TRUE(e.service().empty()); // local validation, not upstream
return;
}
FAIL("expected INVALID_ARGUMENT");
}
// Runs fn (which fails: the mock has no expectation) and returns the one
// request that reached the transport.
MockTransport::SeenRequest sent(Rig& rig, const std::function<void()>& fn) {
std::size_t before = rig.mock->seen().size();
try {
fn();
} catch (...) {
}
auto all = rig.mock->seen();
if (all.size() != before + 1)
FAIL("expected exactly one request, saw " << all.size() - before);
return all.back();
}
std::string engine_op(const std::string& middle = "") {
return std::string(kEngine) + middle + "/operations/op1";
}
} // namespace
TEST(sessions_operations, every_owner_has_all_five_verbs_in_the_table) {
const std::string e = kEngine;
const std::string sp = std::string(kLocation) + "/servingProfiles/sp1/operations/op1";
struct Case {
std::string root, name;
OperationOwner owner;
};
std::vector<Case> cases = {{e, engine_op(), OperationOwner::kEngine},
{e, engine_op("/sessions/s1"), OperationOwner::kSession},
{e, engine_op("/memories/m1"), OperationOwner::kMemory},
{kLocation, sp, OperationOwner::kServingProfile}};
std::set<int> rows;
for (const Case& c : cases) {
OperationName n = OperationName::parse(c.root, c.name);
ASSERT_EQ(static_cast<int>(n.owner()), static_cast<int>(c.owner));
ASSERT_EQ(n.str(), c.name);
for (OperationVerb v : {OperationVerb::kGet, OperationVerb::kCancel, OperationVerb::kList,
OperationVerb::kDelete, OperationVerb::kWait}) {
ASSERT_TRUE(rows.insert(static_cast<int>(n.call(v))).second); // all distinct
ASSERT_TRUE(has(spec_of(n.call(v)).method, "operations."));
}
}
ASSERT_EQ(rows.size(), std::size_t(20));
}
TEST(sessions_operations, names_are_confined_to_their_root) {
const std::string e = kEngine;
for (const char* bad :
{"", "operations/1",
"projects/p1/locations/us-central1/reasoningEngines/other/operations/1",
"projects/p1/locations/us-central1/reasoningEngines/e1/operations/..",
"projects/p1/locations/us-central1/reasoningEngines/e1/operations//x",
"projects/p1/locations/us-central1/reasoningEngines/e1/jobs/j/operations/1",
"projects/p1/locations/us-central1/reasoningEngines/e1/sessions/s/events/e/operations/1",
"projects/p1/locations/us-central1/reasoningEngines/e1/servingProfiles/p/operations/1",
"projects/p1/locations/us-central1/reasoningEngines/e1/operations/1?x=1"})
invalid([&] { OperationName::parse(e, bad); });
// A location root only serves serving profiles.
invalid([&] { OperationName::parse(kLocation, std::string(kLocation) + "/operations/1"); });
invalid([&] {
OperationName::parse(kLocation, std::string(kLocation) + "/sessions/s/operations/1");
});
invalid([&] { OperationName::parse_parent(kLocation, kLocation); });
OperationName::parse_parent(e, e);
OperationName::parse_parent(e, e + "/sessions/s1");
invalid([&] { OperationName::parse_parent(e, e + "/sessions"); });
invalid([&] { OperationName::parse_parent(e, e + "/other/x"); });
}
TEST(sessions_operations, requests_use_the_declared_rows) {
Rig rig;
Sessions s(rig.client, EngineName(kEngine));
MemoryBank b(rig.client, EngineName(kEngine));
auto r = sent(rig, [&] { s.operation(engine_op()); });
ASSERT_EQ(r.method, std::string("GET"));
ASSERT_TRUE(has(r.target, "/v1beta1/" + engine_op()));
r = sent(rig, [&] { s.delete_operation(engine_op()); });
ASSERT_EQ(r.method, std::string("DELETE"));
ASSERT_TRUE(has(r.target, "/v1beta1/" + engine_op()));
r = sent(rig, [&] { s.cancel_operation(engine_op("/sessions/s1")); });
ASSERT_EQ(r.method, std::string("POST"));
ASSERT_TRUE(has(r.target, engine_op("/sessions/s1") + ":cancel"));
r = sent(rig, [&] { b.wait_server(engine_op("/memories/m1"), 30); });
ASSERT_EQ(r.method, std::string("POST"));
ASSERT_TRUE(has(r.target, engine_op("/memories/m1") + ":wait?timeout=30s"));
r = sent(rig, [&] { s.list_operations("", {"done=true", 10}); });
ASSERT_EQ(r.method, std::string("GET"));
ASSERT_TRUE(has(r.target, std::string(kEngine) + "/operations?"));
ASSERT_TRUE(has(r.target, "pageSize=10"));
ASSERT_TRUE(has(r.target, "filter=done%3Dtrue"));
r = sent(rig, [&] { s.list_session_operations("s1"); });
ASSERT_TRUE(has(r.target, std::string(kEngine) + "/sessions/s1/operations"));
r = sent(rig, [&] { b.list_memory_operations("m1"); });
ASSERT_TRUE(has(r.target, std::string(kEngine) + "/memories/m1/operations"));
}
TEST(sessions_operations, bad_input_never_reaches_the_network) {
Rig rig;
Sessions s(rig.client, EngineName(kEngine));
invalid([&] { s.wait_server(engine_op(), 0); });
invalid([&] { s.wait_server(engine_op(), 61); });
invalid([&] { s.wait_server("nope", 5); });
invalid([&] { s.delete_operation(engine_op() + "?x"); });
invalid([&] { s.list_operations("", {"a\nb", 0}); });
invalid([&] { s.list_operations("", {"", 101}); });
invalid([&] { s.list_operations(std::string(kEngine) + "/sessions/BAD ID"); });
invalid([&] { s.list_session_operations("Bad_Id"); });
ASSERT_EQ(rig.mock->send_count(), std::size_t(0));
Rig off(false);
Sessions n(off.client, EngineName(kEngine));
ASSERT_THROW(n.delete_operation(engine_op()), NotConfiguredError);
ASSERT_THROW(n.list_operations(), NotConfiguredError);
ASSERT_THROW(n.wait_server(engine_op(), 5), NotConfiguredError);
ASSERT_EQ(off.mock->send_count(), std::size_t(0));
}
TEST(sessions_operations, lists_stop_loudly_instead_of_truncating) {
ASSERT_FALSE(list_over_limit(100, false, 0, 10, 1000));
ASSERT_FALSE(list_over_limit(1000, false, 9, 10, 1000));
ASSERT_TRUE(list_over_limit(1001, false, 3, 10, 1000));
ASSERT_TRUE(list_over_limit(10, true, 9, 10, 1000)); // page 10 used, more left
ASSERT_FALSE(list_over_limit(10, true, 8, 10, 1000)); // page 9, one more allowed
}
TEST(sessions_serving_profiles, scope_enum_and_names) {
ASSERT_EQ(std::string(serving_scope_name(ServingScope::kGeminiLive)),
std::string("GEMINI_LIVE"));
ASSERT_EQ(std::string(serving_scope_name(ServingScope::kInteractionsApi)),
std::string("INTERACTIONS_API"));
ASSERT_EQ(std::string(serving_scope_name(serving_scope_from("RESPONSE_API"))),
std::string("RESPONSE_API"));
for (const char* bad : {"", "gemini_live", "SERVING_PROFILE_SCOPE_UNSPECIFIED", "ALL"})
invalid([&] { serving_scope_from(bad); });
LocationName loc(kLocation);
ASSERT_EQ(loc.location(), std::string("us-central1"));
ASSERT_EQ(loc.serving_profile("sp-1"), std::string(kLocation) + "/servingProfiles/sp-1");
for (const char* bad : {"", "projects/p1", "projects/p1/locations", "projects/P/locations/l",
"projects/p1/locations/us-central1/x", "projects/p/locations/L",
"projects/p/locations/"})
invalid([&] { LocationName n{std::string(bad)}; });
invalid([&] { loc.serving_profile("Bad_Id"); });
invalid([&] { loc.serving_profile(""); });
}
TEST(sessions_serving_profiles, bodies_use_only_declared_fields) {
ServingProfileSpec spec;
spec.profile_id = "sp-1";
spec.display_name = "Live profile";
spec.description = "d";
spec.scope = ServingScope::kResponseApi;
spec.kms_key_name = "projects/p1/locations/us-central1/keyRings/k/cryptoKeys/c";
spec.validate();
Json body = spec.to_json();
keys_declared(body, Call::kServingProfileCreate);
ASSERT_EQ(body.find("scope")->as_string(), std::string("RESPONSE_API"));
ASSERT_EQ(body.find("cmekConfig")->find("encryptionSpec")->find("kmsKeyName")->as_string(),
spec.kms_key_name);
ServingProfilePatch patch;
patch.profile_id = "sp-1";
patch.display_name = "x";
patch.description = "y";
patch.kms_key_name = spec.kms_key_name;
patch.update_mask = "displayName,description,cmekConfig";
patch.validate();
keys_declared(patch.to_json(), Call::kServingProfilePatch);
ServingProfileSpec bad = spec;
bad.display_name = "";
invalid([&] { bad.validate(); });
bad = spec;
bad.display_name = std::string(129, 'x');
invalid([&] { bad.validate(); });
bad = spec;
bad.profile_id = "A";
invalid([&] { bad.validate(); });
bad = spec;
bad.kms_key_name = "keys/1";
invalid([&] { bad.validate(); });
bad = spec;
bad.description = std::string(4001, 'x');
invalid([&] { bad.validate(); });
ServingProfilePatch bp = patch;
bp.update_mask = "";
invalid([&] { bp.validate(); });
bp.update_mask = "display name";
invalid([&] { bp.validate(); });
ServingProfile p = ServingProfile::from_json(Json::parse(
"{\"name\":\"projects/p1/locations/us-central1/servingProfiles/sp-1\","
"\"displayName\":\"n\",\"scope\":\"GEMINI_LIVE\","
"\"cmekConfig\":{\"encryptionSpec\":{\"kmsKeyName\":\"k\"}}}"));
ASSERT_EQ(p.id(), std::string("sp-1"));
ASSERT_EQ(p.kms_key_name, std::string("k"));
ASSERT_EQ(p.scope, std::string("GEMINI_LIVE"));
}
TEST(sessions_serving_profiles, requests_use_the_declared_rows) {
Rig rig;
ServingProfiles sp(rig.client, LocationName(kLocation));
ASSERT_EQ(sp.endpoint().base_url,
std::string("https://us-central1-aiplatform.googleapis.com/v1beta1"));
ServingProfileSpec spec;
spec.profile_id = "sp-1";
spec.display_name = "Live";
spec.scope = ServingScope::kGeminiLive;
auto r = sent(rig, [&] { sp.create(spec); });
ASSERT_EQ(r.method, std::string("POST"));
ASSERT_TRUE(has(r.target, std::string(kLocation) + "/servingProfiles?servingProfileId=sp-1"));
ASSERT_TRUE(has(r.body, "\"scope\":\"GEMINI_LIVE\""));
r = sent(rig, [&] { sp.get("sp-1"); });
ASSERT_EQ(r.method, std::string("GET"));
ASSERT_TRUE(has(r.target, std::string(kLocation) + "/servingProfiles/sp-1"));
r = sent(rig, [&] { sp.list(25); });
ASSERT_TRUE(has(r.target, "/servingProfiles?pageSize=25"));
ServingProfilePatch patch;
patch.profile_id = "sp-1";
patch.display_name = "new";
patch.update_mask = "displayName";
r = sent(rig, [&] { sp.patch(patch); });
ASSERT_EQ(r.method, std::string("PATCH"));
ASSERT_TRUE(has(r.target, "/servingProfiles/sp-1?updateMask=displayName"));
r = sent(rig, [&] { sp.remove("sp-1"); });
ASSERT_EQ(r.method, std::string("DELETE"));
r = sent(rig, [&] { sp.list_profile_operations("sp-1"); });
ASSERT_TRUE(has(r.target, "/servingProfiles/sp-1/operations"));
r = sent(rig, [&] {
sp.wait_server(std::string(kLocation) + "/servingProfiles/sp-1/operations/o1", 5);
});
ASSERT_TRUE(has(r.target, "/servingProfiles/sp-1/operations/o1:wait?timeout=5s"));
// The location root has no operations of its own.
invalid([&] { sp.list_operations(); });
invalid([&] { sp.operation(engine_op()); });
}
TEST(sessions_serving_profiles, validation_and_credentials_run_before_traffic) {
Rig rig;
ServingProfiles sp(rig.client, LocationName(kLocation));
invalid([&] { sp.get("Bad_Id"); });
invalid([&] { sp.remove(""); });
invalid([&] { sp.create(ServingProfileSpec{}); });
invalid([&] { sp.list(101); });
ASSERT_EQ(rig.mock->send_count(), std::size_t(0));
Rig off(false);
ServingProfiles n(off.client, LocationName(kLocation));
ASSERT_THROW(n.get("sp-1"), NotConfiguredError);
ASSERT_THROW(n.list(), NotConfiguredError);
ASSERT_EQ(off.mock->send_count(), std::size_t(0));
}
// Read-only live probe of the gap-closing calls (MOLO_LIVE_NET=1, a
// credential, GOOGLE_CLOUD_PROJECT; loud SKIP otherwise). Observed
// 2026-10-24 with a service-account token: operations lists under any engine,
// session or memory answer 200 with an empty list even for a missing engine;
// servingProfiles list answers 501 UNIMPLEMENTED (not available to the
// project). Either answer is accepted for servingProfiles and reported.
TEST(sessions_live, operations_and_serving_profiles_reads) {
std::string project = Credentials::env("GOOGLE_CLOUD_PROJECT");
bool has_credential =
!Credentials::env().empty() || !Credentials::env("GOOGLE_ACCESS_TOKEN").empty();
if (!std::getenv("MOLO_LIVE_NET") || !has_credential || project.empty()) {
std::cout << "SKIP sessions_live gaps (set MOLO_LIVE_NET=1, a credential and "
"GOOGLE_CLOUD_PROJECT)\n";
return;
}
auto client = GoogleClient::from_env();
EngineName engine("projects/" + project + "/locations/us-central1/reasoningEngines/1");
Sessions s(client, engine);
MemoryBank b(client, engine);
ASSERT_EQ(s.list_operations().size(), std::size_t(0));
ASSERT_EQ(s.list_session_operations("probe").size(), std::size_t(0));
ASSERT_EQ(b.list_memory_operations("probe").size(), std::size_t(0));
ServingProfiles sp(client, LocationName("projects/" + project + "/locations/us-central1"));
try {
std::size_t n = sp.list(5).size();
std::cout << "servingProfiles list: 200, " << n << " profiles\n";
} catch (const GoogleError& e) {
std::cout << "servingProfiles list: " << e.http_status() << " " << e.status() << "\n";
ASSERT_TRUE(e.http_status() == 501 || e.http_status() == 403 || e.http_status() == 404);
}
}