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:
@@ -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";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user