Merge registry module (Agent Registry, Gateway, Identity)

This commit is contained in:
2026-10-24 04:46:35 +02:00
55 changed files with 4629 additions and 3 deletions
+548
View File
@@ -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(); });
}