feat(clients): registry: Agent Registry, Agent Gateway, Agent Identity from discovery call table
86-row call table checked against Google discovery documents, typed services, local approval ledger, live read-only tests, /agent/registry demo. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,548 @@
|
||||
// Registry module: deterministic, local. No scripted Google replies: the
|
||||
// call table, validation, caps, request construction and local logic are
|
||||
// tested; Google's side is verified by tools/check_discovery.py and the
|
||||
// opt-in live test (test_registry_live.cpp).
|
||||
#include <memory>
|
||||
#include <set>
|
||||
|
||||
#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_principal.h"
|
||||
#include "google/registry/agent_registry.h"
|
||||
#include "google/registry/approvals.h"
|
||||
#include "google/registry/audit_mapper.h"
|
||||
#include "google/registry/call_runner.h"
|
||||
#include "google/registry/caps.h"
|
||||
#include "google/registry/gateway_policy.h"
|
||||
#include "google/registry/ids.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;
|
||||
}
|
||||
};
|
||||
|
||||
const char* kAsset = "projects/p/locations/us-central1/agents/a1";
|
||||
const char* kAsset2 = "projects/p/locations/us-central1/mcpServers/m1";
|
||||
|
||||
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;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
TEST(registry_calls, table_rows_are_unique_and_well_formed) {
|
||||
std::set<std::string> ids;
|
||||
for (const CallSpec& c : Calls::all()) {
|
||||
ASSERT_TRUE(ids.insert(c.id).second);
|
||||
std::string m = c.method;
|
||||
ASSERT_TRUE(m == "GET" || m == "POST" || m == "PATCH" || m == "PUT" || m == "DELETE");
|
||||
ASSERT_TRUE(std::string(c.path).rfind("/", 0) == 0);
|
||||
ASSERT_TRUE(std::string(c.rpc).rfind(c.service, 0) == 0);
|
||||
// A body exists exactly for POST/PATCH/PUT calls that name a schema, and
|
||||
// those that send a body declare fields.
|
||||
if (Calls::has_body(c)) ASSERT_TRUE(m != "GET" && m != "DELETE");
|
||||
}
|
||||
ASSERT_TRUE(Calls::all().size() >= 80);
|
||||
ASSERT_THROW(Calls::get("agentregistry.v1.nope"), GoogleError);
|
||||
}
|
||||
|
||||
TEST(registry_calls, render_paths_match_discovery_templates) {
|
||||
Rig r;
|
||||
CallRunner run(r.client, "us-central1");
|
||||
CallArgs a;
|
||||
a.vars["parent"] = "projects/p/locations/us-central1";
|
||||
ASSERT_EQ(run.describe("agentregistry.v1.agents.list", a),
|
||||
"GET https://agentregistry.googleapis.com/v1/projects/p/locations/us-central1/agents");
|
||||
a.query["pageSize"] = "50";
|
||||
a.query["filter"] = "a b";
|
||||
ASSERT_TRUE(run.describe("agentregistry.v1.agents.list", a).find("?filter=a%20b&pageSize=50") !=
|
||||
std::string::npos);
|
||||
CallArgs g;
|
||||
g.vars["name"] = "projects/p/locations/us-central1/agentGateways/gw";
|
||||
ASSERT_EQ(run.describe("networkservices.v1.agentGateways.get", g),
|
||||
"GET https://networkservices.googleapis.com/v1/projects/p/locations/us-central1/agentGateways/gw");
|
||||
CallArgs s;
|
||||
s.vars["parent"] = "projects/p/locations/us-central1";
|
||||
s.body = Json::object();
|
||||
ASSERT_EQ(run.describe("agentregistry.v1.agents.search", s),
|
||||
"POST https://agentregistry.googleapis.com/v1/projects/p/locations/us-central1/agents:search");
|
||||
CallArgs e;
|
||||
e.vars["name"] = "projects/p/locations/us-central1/reasoningEngines/e1";
|
||||
ASSERT_EQ(run.describe("aiplatform.v1.reasoningEngines.get", e),
|
||||
"GET https://us-central1-aiplatform.googleapis.com/v1/projects/p/locations/us-central1/reasoningEngines/e1");
|
||||
CallArgs i;
|
||||
i.vars["resource"] = "projects/p/locations/us-central1/reasoningEngines/e1";
|
||||
ASSERT_EQ(run.describe("aiplatform.v1.reasoningEngines.getIamPolicy", i),
|
||||
"POST https://us-central1-aiplatform.googleapis.com/v1/projects/p/locations/us-central1/reasoningEngines/e1:getIamPolicy");
|
||||
CallArgs sk;
|
||||
sk.vars["parent"] = "projects/p/locations/us-central1";
|
||||
ASSERT_EQ(run.describe("agentregistry.v1alpha.skills.search", sk),
|
||||
"GET https://agentregistry.googleapis.com/v1alpha/projects/p/locations/us-central1/skills:search");
|
||||
}
|
||||
|
||||
TEST(registry_calls, runner_rejects_before_traffic) {
|
||||
Rig r;
|
||||
CallRunner run(r.client, "us-central1");
|
||||
CallArgs ok;
|
||||
ok.vars["parent"] = "projects/p/locations/us-central1";
|
||||
CallArgs bad_query = ok;
|
||||
bad_query.query["bogus"] = "1";
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { run.invoke("agentregistry.v1.agents.list", bad_query); }));
|
||||
CallArgs big_page = ok;
|
||||
big_page.query["pageSize"] = "101";
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { run.invoke("agentregistry.v1.agents.list", big_page); }));
|
||||
CallArgs nan_page = ok;
|
||||
nan_page.query["pageSize"] = "x";
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { run.invoke("agentregistry.v1.agents.list", nan_page); }));
|
||||
CallArgs missing;
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { run.invoke("agentregistry.v1.agents.list", missing); }));
|
||||
CallArgs traversal;
|
||||
traversal.vars["parent"] = "projects/p/../q";
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { run.invoke("agentregistry.v1.agents.list", traversal); }));
|
||||
CallArgs extra = ok;
|
||||
extra.vars["name"] = "x";
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { run.invoke("agentregistry.v1.agents.list", extra); }));
|
||||
CallArgs unwanted_body = ok;
|
||||
unwanted_body.body = Json::object();
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { run.invoke("agentregistry.v1.agents.list", unwanted_body); }));
|
||||
CallArgs undeclared = ok;
|
||||
undeclared.body = Json::object();
|
||||
undeclared.body.set("surprise", Json(1));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { run.invoke("agentregistry.v1.agents.search", undeclared); }));
|
||||
CallArgs no_body = ok;
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { run.invoke("agentregistry.v1.agents.search", no_body); }));
|
||||
CallArgs bad_req = ok;
|
||||
bad_req.query["requestId"] = "00000000-0000-0000-0000-000000000000";
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { run.invoke("agentregistry.v1.services.list", bad_req); }));
|
||||
ASSERT_EQ(r.mock->send_count(), 0u);
|
||||
}
|
||||
|
||||
TEST(registry_calls, update_mask_uses_declared_fields) {
|
||||
ASSERT_EQ(CallRunner::update_mask("agentregistry.v1.services.patch", {"displayName", "description"}),
|
||||
"displayName,description");
|
||||
ASSERT_EQ(CallRunner::update_mask("networkservices.v1.agentGateways.patch", {"labels.env"}),
|
||||
"labels.env");
|
||||
ASSERT_THROW(CallRunner::update_mask("agentregistry.v1.services.patch", {}), GoogleError);
|
||||
ASSERT_THROW(CallRunner::update_mask("agentregistry.v1.services.patch", {"name"}), GoogleError);
|
||||
}
|
||||
|
||||
TEST(registry_ids, validation) {
|
||||
ASSERT_TRUE(Ids::service_id("my-agent-1"));
|
||||
ASSERT_FALSE(Ids::service_id("abc"));
|
||||
ASSERT_FALSE(Ids::service_id("1abc"));
|
||||
ASSERT_FALSE(Ids::service_id("Abcd"));
|
||||
ASSERT_FALSE(Ids::service_id(std::string(64, 'a')));
|
||||
ASSERT_TRUE(Ids::asset_name(kAsset));
|
||||
ASSERT_FALSE(Ids::asset_name("projects/p/locations/l/widgets/x"));
|
||||
ASSERT_FALSE(Ids::asset_name("projects/p/locations/l/agents/../x"));
|
||||
ASSERT_EQ(Ids::collection_of(kAsset2), "mcpServers");
|
||||
ASSERT_THROW(Ids::require_template_name("projects/p/templates/t"), GoogleError);
|
||||
Ids::require_template_name("projects/p/locations/us/templates/t1");
|
||||
Ids::require_request_id("");
|
||||
Ids::require_request_id("123e4567-e89b-12d3-a456-426614174000");
|
||||
ASSERT_THROW(Ids::require_request_id("00000000-0000-0000-0000-000000000000"), GoogleError);
|
||||
ASSERT_THROW(Ids::require_request_id("nope"), GoogleError);
|
||||
ASSERT_THROW(Ids::require_text("a\nb", 10, "t"), GoogleError);
|
||||
}
|
||||
|
||||
TEST(registry_records, service_record_shape_and_rules) {
|
||||
ServiceRecord rec;
|
||||
rec.display_name = "Billing agent";
|
||||
rec.description = "d";
|
||||
rec.kind = SpecKind::kAgent;
|
||||
rec.spec_type = "A2A_AGENT_CARD";
|
||||
rec.content = Json::object();
|
||||
rec.content.set("name", Json("billing"));
|
||||
Json j = rec.to_json();
|
||||
ASSERT_EQ(j.find("agentSpec")->find("type")->as_string(), "A2A_AGENT_CARD");
|
||||
ASSERT_EQ(j.find("displayName")->as_string(), "Billing agent");
|
||||
for (const auto& kv : j.as_object())
|
||||
ASSERT_TRUE(Calls::allows_field(Calls::get("agentregistry.v1.services.create"), kv.first));
|
||||
// A2A_AGENT_CARD: interfaces must be empty.
|
||||
ServiceRecord both = rec;
|
||||
both.interfaces.push_back({"https://x.example/a2a", ProtocolBinding::kJsonRpc});
|
||||
ASSERT_THROW(both.to_json(), GoogleError);
|
||||
// MCP server with TOOL_SPEC and an interface.
|
||||
ServiceRecord mcp;
|
||||
mcp.kind = SpecKind::kMcpServer;
|
||||
mcp.spec_type = "TOOL_SPEC";
|
||||
mcp.content = Json::parse("{\"tools\":[]}");
|
||||
mcp.interfaces.push_back({"https://mcp.example/rpc", ProtocolBinding::kHttpJson});
|
||||
Json mj = mcp.to_json();
|
||||
ASSERT_EQ(mj.find("mcpServerSpec")->find("type")->as_string(), "TOOL_SPEC");
|
||||
ASSERT_EQ(mj.find("interfaces")->as_array()[0].find("protocolBinding")->as_string(), "HTTP_JSON");
|
||||
// Round trip.
|
||||
ServiceRecord back = ServiceRecord::from_json(Json::parse(mj.dump()));
|
||||
ASSERT_TRUE(back.kind == SpecKind::kMcpServer);
|
||||
// Rules.
|
||||
ServiceRecord wrong = rec;
|
||||
wrong.spec_type = "TOOL_SPEC";
|
||||
ASSERT_THROW(wrong.to_json(), GoogleError);
|
||||
ServiceRecord nospec_content = rec;
|
||||
nospec_content.spec_type = "NO_SPEC";
|
||||
ASSERT_THROW(nospec_content.to_json(), GoogleError);
|
||||
ServiceRecord longname = rec;
|
||||
longname.display_name = std::string(64, 'x');
|
||||
ASSERT_THROW(longname.to_json(), GoogleError);
|
||||
ServiceRecord big = rec;
|
||||
big.content.set("pad", Json(std::string(RegistryCaps::kMaxSpecBytes, 'x')));
|
||||
ASSERT_THROW(big.to_json(), GoogleError);
|
||||
ServiceRecord badurl = mcp;
|
||||
badurl.interfaces[0].url = "ftp://x";
|
||||
ASSERT_THROW(badurl.to_json(), GoogleError);
|
||||
ServiceRecord toomany = mcp;
|
||||
toomany.interfaces.assign(RegistryCaps::kMaxInterfaces + 1, mcp.interfaces[0]);
|
||||
ASSERT_THROW(toomany.to_json(), GoogleError);
|
||||
}
|
||||
|
||||
TEST(registry_records, skill_revision_and_binding) {
|
||||
SkillRecord skill;
|
||||
skill.display_name = "Create docs";
|
||||
skill.target_state = SkillState::kActive;
|
||||
SkillRevisionRecord rev;
|
||||
rev.gcs_uri = "gs://bucket/skill.zip";
|
||||
Json j = skill.to_create_json(&rev);
|
||||
ASSERT_EQ(j.find("type")->as_string(), "SIMPLE");
|
||||
ASSERT_EQ(j.find("targetState")->as_string(), "TARGET_STATE_ACTIVE");
|
||||
ASSERT_EQ(j.find("initialRevision")->find("gcsSource")->find("uri")->as_string(), "gs://bucket/skill.zip");
|
||||
for (const auto& kv : j.as_object())
|
||||
ASSERT_TRUE(Calls::allows_field(Calls::get("agentregistry.v1alpha.skills.create"), kv.first));
|
||||
SkillRecord nameless;
|
||||
ASSERT_THROW(nameless.to_create_json(), GoogleError);
|
||||
SkillRevisionRecord none;
|
||||
ASSERT_THROW(none.to_json(), GoogleError);
|
||||
SkillRevisionRecord both;
|
||||
both.gcs_uri = "gs://b/o";
|
||||
both.archive_base64 = "AAAA";
|
||||
ASSERT_THROW(both.to_json(), GoogleError);
|
||||
SkillRevisionRecord badgs;
|
||||
badgs.gcs_uri = "http://b/o";
|
||||
ASSERT_THROW(badgs.to_json(), GoogleError);
|
||||
SkillRevisionRecord inl;
|
||||
inl.archive_base64 = "AAAA";
|
||||
ASSERT_EQ(inl.to_json().find("archiveUploadSource")->find("archiveContent")->as_string(), "AAAA");
|
||||
|
||||
BindingRecord b;
|
||||
b.display_name = "link";
|
||||
b.source_id = "urn:agent:acme:sales:bot";
|
||||
b.target_id = "urn:mcp:acme:tools:crm";
|
||||
b.auth_provider = "projects/p/locations/l/authProviders/x";
|
||||
b.scopes = {"read"};
|
||||
Json bj = b.to_json();
|
||||
ASSERT_EQ(bj.find("target")->find("identifier")->as_string(), "urn:mcp:acme:tools:crm");
|
||||
ASSERT_EQ(bj.find("authProviderBinding")->find("scopes")->as_array().size(), 1u);
|
||||
for (const auto& kv : bj.as_object())
|
||||
ASSERT_TRUE(Calls::allows_field(Calls::get("agentregistry.v1.bindings.create"), kv.first));
|
||||
BindingRecord bad = b;
|
||||
bad.target_id = "urn:widget:a:b:c";
|
||||
ASSERT_THROW(bad.to_json(), GoogleError);
|
||||
BindingRecord bad_src = b;
|
||||
bad_src.source_id = "urn:mcp:a:b:c"; // The source must be an agent.
|
||||
ASSERT_THROW(bad_src.to_json(), GoogleError);
|
||||
BindingRecord empty;
|
||||
ASSERT_THROW(empty.to_json(), GoogleError);
|
||||
}
|
||||
|
||||
TEST(registry_gateway, spec_shape_and_caps) {
|
||||
GatewaySpec s;
|
||||
s.description = "egress gateway";
|
||||
s.labels["env"] = "prod";
|
||||
s.registries = {"//agentregistry.googleapis.com/projects/p/locations/us-central1"};
|
||||
Json j = s.to_json();
|
||||
ASSERT_EQ(j.find("googleManaged")->find("governedAccessPath")->as_string(), "AGENT_TO_ANYWHERE");
|
||||
ASSERT_EQ(j.find("labels")->find("env")->as_string(), "prod");
|
||||
for (const auto& kv : j.as_object())
|
||||
ASSERT_TRUE(Calls::allows_field(Calls::get("networkservices.v1.agentGateways.create"), kv.first));
|
||||
GatewaySpec self;
|
||||
self.mode = GatewayMode::kSelfManaged;
|
||||
self.resource_uris = {"https://x.example/proxy"};
|
||||
self.network_attachment = "projects/p/regions/r/networkAttachments/na";
|
||||
self.dns_domains = {"corp.example."};
|
||||
self.dns_target_project = "tp";
|
||||
self.dns_target_network = "tn";
|
||||
Json sj = self.to_json();
|
||||
ASSERT_EQ(sj.find("selfManaged")->find("resourceUris")->as_array().size(), 1u);
|
||||
ASSERT_EQ(sj.find("networkConfig")->find("dnsPeeringConfig")->find("targetProject")->as_string(), "tp");
|
||||
ASSERT_TRUE(sj.find("googleManaged") == nullptr);
|
||||
GatewaySpec mixed;
|
||||
mixed.resource_uris = {"https://x"}; // googleManaged takes none.
|
||||
ASSERT_THROW(mixed.to_json(), GoogleError);
|
||||
GatewaySpec many;
|
||||
many.registries.assign(RegistryCaps::kMaxRegistries + 1, "r");
|
||||
ASSERT_THROW(many.to_json(), GoogleError);
|
||||
GatewaySpec client_to_agent;
|
||||
client_to_agent.access_path = GovernedAccessPath::kClientToAgent;
|
||||
ASSERT_EQ(client_to_agent.to_json().find("googleManaged")->find("governedAccessPath")->as_string(),
|
||||
"CLIENT_TO_AGENT");
|
||||
}
|
||||
|
||||
TEST(registry_gateway, policy_spec_rules) {
|
||||
AuthzPolicySpec p;
|
||||
p.target_resources = {"projects/p/locations/us-central1/agentGateways/gw"};
|
||||
p.action = PolicyAction::kAllow;
|
||||
Json rule = Json::parse("{\"to\":{\"operations\":[{\"mcp\":{\"methods\":[{\"name\":\"tools/call\"}]}}]}}");
|
||||
p.http_rules.push(rule);
|
||||
Json j = p.to_json();
|
||||
ASSERT_EQ(j.find("action")->as_string(), "ALLOW");
|
||||
ASSERT_EQ(j.find("policyProfile")->as_string(), "REQUEST_AUTHZ");
|
||||
ASSERT_EQ(j.find("target")->find("resources")->as_array().size(), 1u);
|
||||
for (const auto& kv : j.as_object())
|
||||
ASSERT_TRUE(Calls::allows_field(Calls::get("networksecurity.v1.authzPolicies.create"), kv.first));
|
||||
ASSERT_TRUE(p.to_json(false).find("policyProfile") == nullptr);
|
||||
|
||||
AuthzPolicySpec custom = p;
|
||||
custom.action = PolicyAction::kCustom;
|
||||
custom.profile = PolicyProfile::kContentAuthz;
|
||||
ASSERT_THROW(custom.to_json(), GoogleError); // CUSTOM needs a provider
|
||||
custom.extension_resources = {"projects/p/locations/us-central1/authzExtensions/ext"};
|
||||
Json cj = custom.to_json();
|
||||
ASSERT_EQ(cj.find("customProvider")->find("authzExtension")->find("resources")->as_array().size(), 1u);
|
||||
ASSERT_EQ(cj.find("policyProfile")->as_string(), "CONTENT_AUTHZ");
|
||||
custom.cloud_iap = true;
|
||||
ASSERT_THROW(custom.to_json(), GoogleError); // one provider only
|
||||
AuthzPolicySpec stray = p;
|
||||
stray.cloud_iap = true; // provider without CUSTOM
|
||||
ASSERT_THROW(stray.to_json(), GoogleError);
|
||||
AuthzPolicySpec no_target;
|
||||
ASSERT_THROW(no_target.to_json(), GoogleError);
|
||||
AuthzPolicySpec many = p;
|
||||
for (int i = 0; i < 5; ++i) many.http_rules.push(rule); // 6 total
|
||||
ASSERT_THROW(many.to_json(), GoogleError);
|
||||
AuthzPolicySpec scheme = p;
|
||||
scheme.load_balancing_scheme = "WEIRD";
|
||||
ASSERT_THROW(scheme.to_json(), GoogleError);
|
||||
}
|
||||
|
||||
TEST(registry_gateway, model_armor_reference_only) {
|
||||
ModelArmorReference ref;
|
||||
ASSERT_THROW(ref.validate(), GoogleError);
|
||||
ref.request_template = "projects/p/locations/us/templates/req";
|
||||
ref.response_template = "projects/p/locations/us/templates/resp";
|
||||
Json m = ref.extension_metadata();
|
||||
std::string v = m.find("model_armor_settings")->as_string();
|
||||
ASSERT_TRUE(v.find("request_template_id") != std::string::npos);
|
||||
ASSERT_TRUE(v.find("projects/p/locations/us/templates/resp") != std::string::npos);
|
||||
ref.response_template = "not-a-template";
|
||||
ASSERT_THROW(ref.settings_value(), GoogleError);
|
||||
}
|
||||
|
||||
TEST(registry_identity, principal_forms) {
|
||||
ASSERT_EQ(AgentPrincipal::org_trust_domain("123"), "agents.global.org-123.system.id.goog");
|
||||
ASSERT_EQ(AgentPrincipal::project_trust_domain("456"), "agents.global.proj-456.system.id.goog");
|
||||
ASSERT_EQ(AgentPrincipal::project_set("123", "456"),
|
||||
"principalSet://agents.global.org-123.system.id.goog/attribute.platformContainer/aiplatform/projects/456");
|
||||
ASSERT_EQ(AgentPrincipal::org_set("123"),
|
||||
"principalSet://agents.global.org-123.system.id.goog/attribute.platform/aiplatform");
|
||||
AgentPrincipal p = AgentPrincipal::parse(
|
||||
"principal://agents.global.org-123.system.id.goog/aiplatform/engine-1");
|
||||
ASSERT_EQ(p.ns, "aiplatform");
|
||||
ASSERT_EQ(p.agent_name, "engine-1");
|
||||
ASSERT_EQ(p.str(), "principal://agents.global.org-123.system.id.goog/aiplatform/engine-1");
|
||||
ASSERT_THROW(AgentPrincipal::parse("principal://evil.example.com/a/b"), GoogleError);
|
||||
ASSERT_THROW(AgentPrincipal::parse("serviceAccount:x@y"), GoogleError);
|
||||
ASSERT_THROW(AgentPrincipal::parse("principal://agents.global.org-1.system.id.goog/a"), GoogleError);
|
||||
ASSERT_THROW(AgentPrincipal::org_trust_domain("12x"), GoogleError);
|
||||
ASSERT_FALSE(AgentPrincipal::is_agent_principal("user:a@b.c"));
|
||||
}
|
||||
|
||||
TEST(registry_identity, deny_policy_and_boundary_bodies) {
|
||||
DenyPolicySpec d;
|
||||
d.display_name = "block agents";
|
||||
DenyRuleSpec rule;
|
||||
rule.denied_principals = {AgentPrincipal::org_set("123")};
|
||||
rule.denied_permissions = {"iam.googleapis.com/roles.create", "storage.googleapis.com/buckets.delete"};
|
||||
d.rules.push_back(rule);
|
||||
Json j = d.to_json();
|
||||
const Json& r0 = j.find("rules")->as_array()[0];
|
||||
ASSERT_EQ(r0.find("denyRule")->find("deniedPermissions")->as_array().size(), 2u);
|
||||
for (const auto& kv : j.as_object())
|
||||
ASSERT_TRUE(Calls::allows_field(Calls::get("iam.v2.policies.createPolicy"), kv.first));
|
||||
DenyPolicySpec none;
|
||||
ASSERT_THROW(none.to_json(), GoogleError);
|
||||
DenyPolicySpec bad = d;
|
||||
bad.rules[0].denied_permissions = {"drop table"};
|
||||
ASSERT_THROW(bad.to_json(), GoogleError);
|
||||
DenyPolicySpec bad_pr = d;
|
||||
bad_pr.rules[0].denied_principals = {"allUsers"};
|
||||
ASSERT_THROW(bad_pr.to_json(), GoogleError);
|
||||
DenyPolicySpec quote = d;
|
||||
quote.rules[0].denied_principals = {"principal://a\"b"};
|
||||
ASSERT_THROW(quote.to_json(), GoogleError);
|
||||
|
||||
AccessBoundarySpec b;
|
||||
b.display_name = "agents may reach";
|
||||
b.resources = {"//cloudresourcemanager.googleapis.com/projects/456"};
|
||||
Json bj = b.to_json();
|
||||
ASSERT_EQ(bj.find("details")->find("rules")->as_array()[0].find("effect")->as_string(), "ALLOW");
|
||||
for (const auto& kv : bj.as_object())
|
||||
ASSERT_TRUE(Calls::allows_field(Calls::get("iam.v3.principalAccessBoundaryPolicies.create"), kv.first));
|
||||
AccessBoundarySpec empty;
|
||||
ASSERT_THROW(empty.to_json(), GoogleError);
|
||||
|
||||
ASSERT_EQ(AgentIdentity::attachment_for_project("456"),
|
||||
"cloudresourcemanager.googleapis.com%2Fprojects%2F456");
|
||||
ASSERT_THROW(AgentIdentity::attachment_for_project("../x"), GoogleError);
|
||||
}
|
||||
|
||||
TEST(registry_identity, audit_mapping) {
|
||||
Json autonomous = Json::parse(
|
||||
"{\"timestamp\":\"2026-10-24T10:00:00Z\",\"protoPayload\":{\"serviceName\":\"storage.googleapis.com\","
|
||||
"\"methodName\":\"storage.objects.get\",\"resourceName\":\"projects/_/buckets/b/objects/o\","
|
||||
"\"authenticationInfo\":{\"principalSubject\":\"principal://agents.global.org-1.system.id.goog/aiplatform/e1\"}}}");
|
||||
AuditEvent a = AuditMapper::map(autonomous);
|
||||
ASSERT_TRUE(a.by_agent);
|
||||
ASSERT_TRUE(a.autonomous);
|
||||
ASSERT_EQ(a.agent_name, "e1");
|
||||
ASSERT_EQ(a.method_name, "storage.objects.get");
|
||||
Json delegated = Json::parse(
|
||||
"{\"protoPayload\":{\"authenticationInfo\":{\"principalSubject\":"
|
||||
"\"principal://agents.global.org-1.system.id.goog/aiplatform/e1\","
|
||||
"\"serviceAccountDelegationInfo\":[{\"principalSubject\":\"user:alice@example.com\"}]}}}");
|
||||
AuditEvent d = AuditMapper::map(delegated);
|
||||
ASSERT_TRUE(d.by_agent);
|
||||
ASSERT_FALSE(d.autonomous);
|
||||
ASSERT_EQ(d.delegated_by.size(), 1u);
|
||||
AuditEvent human = AuditMapper::map(Json::parse(
|
||||
"{\"protoPayload\":{\"authenticationInfo\":{\"principalEmail\":\"bob@example.com\"}}}"));
|
||||
ASSERT_FALSE(human.by_agent);
|
||||
ASSERT_EQ(human.caller, "bob@example.com");
|
||||
ASSERT_EQ(AuditMapper::map(Json::parse("{}")).caller, "");
|
||||
Json many = Json::array();
|
||||
for (std::size_t i = 0; i < RegistryCaps::kMaxAuditEntries + 10; ++i) many.push(autonomous);
|
||||
ASSERT_EQ(AuditMapper::map_all(many).size(), RegistryCaps::kMaxAuditEntries);
|
||||
ASSERT_EQ(AuditMapper::filter_for_agent("principal://agents.global.org-1.system.id.goog/aiplatform/e1"),
|
||||
"protoPayload.authenticationInfo.principalSubject=\"principal://agents.global.org-1.system.id.goog/aiplatform/e1\"");
|
||||
ASSERT_THROW(AuditMapper::filter_for_agent("x\" OR true"), GoogleError);
|
||||
}
|
||||
|
||||
TEST(registry_approvals, lifecycle_restriction_and_caps) {
|
||||
ApprovalLedger ledger;
|
||||
ASSERT_TRUE(ledger.state_of(kAsset) == ApprovalState::kUnreviewed);
|
||||
ASSERT_THROW(ledger.deprecate(kAsset, "alice"), GoogleError); // never approved
|
||||
ledger.approve(kAsset, "alice", "reviewed");
|
||||
ASSERT_TRUE(ledger.is_approved(kAsset));
|
||||
ledger.reject(kAsset2, "alice", "no");
|
||||
Json items = Json::array();
|
||||
for (const char* n : {kAsset, kAsset2, "projects/p/locations/us-central1/agents/other"}) {
|
||||
Json o = Json::object();
|
||||
o.set("name", Json(n));
|
||||
items.push(o);
|
||||
}
|
||||
Json approved = ledger.restrict_to_approved(items);
|
||||
ASSERT_EQ(approved.as_array().size(), 1u);
|
||||
ledger.deprecate(kAsset, "bob", "replaced", kAsset2);
|
||||
ASSERT_TRUE(ledger.state_of(kAsset) == ApprovalState::kDeprecated);
|
||||
ASSERT_EQ(ledger.restrict_to_approved(items).as_array().size(), 0u);
|
||||
ASSERT_THROW(ledger.approve("bad name", "alice"), GoogleError);
|
||||
ASSERT_THROW(ledger.approve(kAsset, ""), GoogleError);
|
||||
ASSERT_THROW(ledger.approve(kAsset, "alice", std::string(RegistryCaps::kMaxNoteChars + 1, 'x')), GoogleError);
|
||||
ASSERT_EQ(ledger.audit().size(), 3u);
|
||||
ASSERT_EQ(ledger.audit().snapshot()[0].action, "approve");
|
||||
}
|
||||
|
||||
TEST(registry_approvals, ledger_and_trail_are_bounded) {
|
||||
ApprovalLedger ledger;
|
||||
for (std::size_t i = 0; i < RegistryCaps::kMaxLedgerEntries; ++i)
|
||||
ledger.approve("projects/p/locations/l/agents/a" + std::to_string(i), "x");
|
||||
try {
|
||||
ledger.approve("projects/p/locations/l/agents/overflow", "x");
|
||||
FAIL("ledger must refuse past the cap");
|
||||
} catch (const GoogleError& e) {
|
||||
ASSERT_EQ(e.http_status(), 429);
|
||||
}
|
||||
// Re-deciding an existing entry is still allowed at the cap.
|
||||
ledger.reject("projects/p/locations/l/agents/a0", "x");
|
||||
ASSERT_EQ(ledger.audit().size(), RegistryCaps::kMaxAuditEntries);
|
||||
ASSERT_TRUE(ledger.audit().dropped() > 0);
|
||||
}
|
||||
|
||||
TEST(registry_service, no_credential_is_loud_and_silent_on_the_wire) {
|
||||
Rig r(false);
|
||||
AgentRegistry reg(r.client, r.ctx());
|
||||
try {
|
||||
reg.list(AssetKind::kAgents);
|
||||
FAIL("expected NotConfiguredError");
|
||||
} catch (const NotConfiguredError& e) {
|
||||
ASSERT_EQ(e.http_status(), 503);
|
||||
}
|
||||
AgentGateway gw(r.client, r.ctx());
|
||||
ASSERT_THROW(gw.list(), NotConfiguredError);
|
||||
GatewayPolicies pol(r.client, r.ctx());
|
||||
ASSERT_THROW(pol.list(), NotConfiguredError);
|
||||
AgentIdentity id(r.client, r.ctx());
|
||||
ASSERT_THROW(id.engines(), NotConfiguredError);
|
||||
ASSERT_EQ(r.mock->send_count(), 0u);
|
||||
}
|
||||
|
||||
TEST(registry_service, inputs_rejected_before_any_traffic) {
|
||||
Rig r;
|
||||
AgentRegistry reg(r.client, r.ctx());
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.get(AssetKind::kAgents, "../x"); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.get(AssetKind::kAgents, ""); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.search(AssetKind::kEndpoints, "q"); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.search(AssetKind::kAgents, std::string(513, 'x')); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.search(AssetKind::kAgents, "q", 101); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.search(AssetKind::kAgents, "q", 0); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.search_skills("q", "", 101); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.list(AssetKind::kAgents, {{"bogus", "1"}}); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.list(AssetKind::kAgents, {{"filter", std::string(600, 'x')}}); }));
|
||||
ServiceRecord rec;
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.register_service("BAD", rec); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.register_service("good-id", rec, "not-a-uuid"); }));
|
||||
ServiceRecord bad;
|
||||
bad.spec_type = "TOOL_SPEC"; // Wrong for an agent.
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.register_service("good-id", bad); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.update_service("good-id", rec, {}); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.update_service("good-id", rec, {"name"}); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.remove_service("x"); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.set_skill_state("../s", SkillState::kActive); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.iam_policy(AssetKind::kAgents, "a1"); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.test_iam_permissions(AssetKind::kSkills, "s1", {}); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.fetch_available_bindings("urn:bad", ""); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.application_assets("app1", AssetKind::kSkills); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { reg.operation("a/b"); }));
|
||||
AgentGateway gw(r.client, r.ctx());
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { gw.get("../x"); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { gw.update("g1", GatewaySpec{}, {}); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { gw.update("g1", GatewaySpec{}, {"name"}); }));
|
||||
GatewayPolicies pol(r.client, r.ctx());
|
||||
AuthzPolicySpec spec;
|
||||
spec.target_resources = {"x"};
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { pol.update_policy("p1", spec, {"policyProfile"}); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { pol.create_policy("../p", spec); }));
|
||||
AgentIdentity ident(r.client, r.ctx());
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { ident.identity("../e"); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { ident.audit("not-a-principal"); }));
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { ident.deny_policy("plain", "p"); }));
|
||||
CloudContext none;
|
||||
AgentRegistry no_project(r.client, none);
|
||||
ASSERT_TRUE(invalid_without_traffic(r, [&] { no_project.list(AssetKind::kAgents); }));
|
||||
ASSERT_EQ(r.mock->send_count(), 0u);
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
// Opt-in live checks for the registry module. Read-only GETs and lists
|
||||
// only: nothing is created, updated or deleted, nothing costs money.
|
||||
//
|
||||
// MOLO_LIVE_NET=1 GOOGLE_CLOUD_PROJECT=<project> GOOGLE_API_KEY=<key>
|
||||
// (then) make google-test
|
||||
//
|
||||
// With a service-account token (GOOGLE_ACCESS_TOKEN) the registry, gateway and
|
||||
// policy hosts answer 403 SERVICE_DISABLED until a human enables the APIs.
|
||||
// With only an express/API key, the aiplatform reasoningEngines list works;
|
||||
// the registry, gateway and policy hosts answer 401 UNAUTHENTICATED "API
|
||||
// keys are not supported", which still proves the path reached the auth
|
||||
// layer. With GOOGLE_ACCESS_TOKEN (OAuth) the same calls must succeed.
|
||||
// Credentials are read from the environment and never printed.
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
|
||||
#include "framework.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/gateway_policy.h"
|
||||
|
||||
using namespace molo::google;
|
||||
using namespace molo::google::registry;
|
||||
|
||||
namespace {
|
||||
bool live_ready(const char* test) {
|
||||
if (!std::getenv("MOLO_LIVE_NET") || Credentials::env("GOOGLE_CLOUD_PROJECT").empty() ||
|
||||
(Credentials::env("GOOGLE_API_KEY").empty() && Credentials::env("GOOGLE_ACCESS_TOKEN").empty())) {
|
||||
std::cout << "SKIP " << test
|
||||
<< " (set MOLO_LIVE_NET=1, GOOGLE_CLOUD_PROJECT and a key or GOOGLE_ACCESS_TOKEN)\n";
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
bool have_oauth() { return !Credentials::env("GOOGLE_ACCESS_TOKEN").empty(); }
|
||||
|
||||
// With OAuth the call must work, or answer 403 SERVICE_DISABLED (the API is
|
||||
// not enabled on the project: the path and auth were accepted, enabling an
|
||||
// API is a human decision this test never makes). With a key only, 401
|
||||
// UNAUTHENTICATED is the expected proof that the path exists and needs OAuth.
|
||||
template <typename F>
|
||||
void expect_read(F&& f) {
|
||||
try {
|
||||
f();
|
||||
} catch (const GoogleError& e) {
|
||||
if (have_oauth()) {
|
||||
bool disabled = e.http_status() == 403 && e.status() == "PERMISSION_DENIED" &&
|
||||
(e.message().find("has not been used") != std::string::npos ||
|
||||
e.message().find("disabled") != std::string::npos);
|
||||
if (!disabled) throw;
|
||||
std::cout << " API not enabled on the project (SERVICE_DISABLED)\n";
|
||||
return;
|
||||
}
|
||||
ASSERT_EQ(e.http_status(), 401);
|
||||
ASSERT_EQ(e.status(), "UNAUTHENTICATED");
|
||||
}
|
||||
}
|
||||
} // namespace
|
||||
|
||||
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";
|
||||
}
|
||||
|
||||
TEST(registry_live, audit_trail_read_needs_oauth) {
|
||||
if (!live_ready("registry_live.audit_trail_read_needs_oauth")) return;
|
||||
if (!have_oauth()) {
|
||||
std::cout << "SKIP registry_live.audit_trail_read_needs_oauth (needs GOOGLE_ACCESS_TOKEN)\n";
|
||||
return;
|
||||
}
|
||||
AgentIdentity identity(GoogleClient::from_env(), CloudContext::from_env());
|
||||
// A principal that matches nothing: the call is read-only and returns 0..n entries.
|
||||
auto events = identity.audit(
|
||||
"principal://agents.global.org-1.system.id.goog/aiplatform/molo-live-check", 1);
|
||||
ASSERT_TRUE(events.size() <= 1);
|
||||
}
|
||||
|
||||
TEST(registry_live, registry_reads) {
|
||||
if (!live_ready("registry_live.registry_reads")) return;
|
||||
AgentRegistry reg(GoogleClient::from_env(), CloudContext::from_env());
|
||||
for (AssetKind k : {AssetKind::kServices, AssetKind::kAgents, AssetKind::kMcpServers,
|
||||
AssetKind::kEndpoints, AssetKind::kBindings, AssetKind::kSkills,
|
||||
AssetKind::kPublishers})
|
||||
expect_read([&] { reg.list(k); });
|
||||
}
|
||||
|
||||
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());
|
||||
expect_read([&] { gw.list(); });
|
||||
GatewayPolicies pol(GoogleClient::from_env(), CloudContext::from_env());
|
||||
expect_read([&] { pol.list(); });
|
||||
}
|
||||
Reference in New Issue
Block a user