Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package api
import (
"slices"
"strings"
"testing"
"github.com/eclipse-biscuit/biscuit-go/v2/parser"
"github.com/libp2p/go-libp2p/core/peer"
)
func TestBuildPolicyRules(t *testing.T) {
// A node member written in the CIDv1 encoding peer.Decode also accepts;
// the rule must carry the base58 form a token's node() fact uses.
const nodeID = "12D3KooWA4Xop1JaT3MHxwYMkCepYsv4iPVopMXwCz5iHYdBfeSB"
decoded, err := peer.Decode(nodeID)
if err != nil {
t.Fatal(err)
}
nodeCID := peer.ToCid(decoded).String()
if nodeCID == nodeID {
t.Fatal("test needs a non-canonical encoding")
}
roles := []*PolicyRole{
{
Name: "test-role",
AllowedTargets: []string{"*", "node:" + nodeCID, "node:not-a-peer-id", "custom-fact:custom-val", "legacy-peer"},
AllowedServices: []string{"*:*", "mcp:*", "mcp:*.suffix", "mcp:prefix.*", "mcp:exact"},
AllowedPublish: []string{"mcp://*", "a2a://echo"},
CustomDatalog: []string{
"custom_rule($x) <- fact($x), $x > 3;",
"custom_fact(\"hello\")",
"not datalog at all(",
},
},
}
bindings := []*PolicyBinding{
{
Role: "test-role",
Members: []string{"mesh:system:authenticated", "user:alice", "role:admin", "agent:spoofed", "node:" + nodeCID, "node:not-a-peer-id"},
},
}
rules, warnings := BuildPolicyRules(roles, bindings)
expectedStrings := map[string]bool{
"role(\"test-role\") <- true": false,
"role(\"test-role\") <- user(\"alice\")": false,
"role(\"test-role\") <- node(\"" + nodeID + "\")": false,
"granted_service_all_types(true) <- role(\"test-role\")": false,
"granted_service_all(\"mcp\") <- role(\"test-role\")": false,
"granted_service_suffix(\"mcp\", \".suffix\") <- role(\"test-role\")": false,
"granted_service_prefix(\"mcp\", \"prefix.\") <- role(\"test-role\")": false,
"granted_service_set(\"mcp\", [\"exact\"]) <- role(\"test-role\")": false,
"granted_publish_all(\"mcp\") <- role(\"test-role\")": false,
"granted_publish_set(\"a2a\", [\"echo\"]) <- role(\"test-role\")": false,
"target_unrestricted(true) <- role(\"test-role\")": false,
"target_restricted(true) <- role(\"test-role\")": false,
"granted_target_set(\"node\", [\"" + nodeID + "\", \"legacy-peer\"]) <- role(\"test-role\")": false,
"granted_target_set(\"custom-fact\", [\"custom-val\"]) <- role(\"test-role\")": false,
"custom_rule($x) <- role(\"test-role\"), fact($x), $x > 3": false,
"custom_fact(\"hello\") <- role(\"test-role\")": false,
}
for _, rule := range rules {
if _, ok := expectedStrings[rule.Text]; !ok {
t.Errorf("Unexpected rule generated: %q", rule.Text)
continue
}
expectedStrings[rule.Text] = true
// The text is what other implementations parse; it must round-trip here too.
if _, err := parser.FromStringRule(rule.Text); err != nil {
t.Errorf("rendered rule %q does not parse: %v", rule.Text, err)
}
}
for k, v := range expectedStrings {
if !v {
t.Errorf("Expected rule was not generated: %q", k)
}
}
if len(warnings) != 3 {
t.Fatalf("warnings = %q, want one for the unparseable entry and two for the bad peer IDs", warnings)
}
if !strings.Contains(strings.Join(warnings, "\n"), `"node:not-a-peer-id"`) {
t.Errorf("warnings = %q, want one naming the member/target that is not a peer ID", warnings)
}
// The text is the contract every member evaluates; it must yield the same
// rules here as the structured form does.
parsed, err := ParseDatalogRules(PolicyRuleTexts(rules))
if err != nil {
t.Fatalf("ParseDatalogRules: %v", err)
}
if len(parsed) != len(rules) {
t.Fatalf("parsed %d rules from text, built %d", len(parsed), len(rules))
}
for i := range rules {
if parsed[i].Head.String() != rules[i].Rule.Head.String() {
t.Errorf("rule %d head: text %s, built %s", i, parsed[i].Head.String(), rules[i].Rule.Head.String())
}
}
}
func TestParseDatalogRulesRejectsWholeSet(t *testing.T) {
_, err := ParseDatalogRules([]string{`role("a") <- user("b")`, `broken(`})
if err == nil {
t.Fatal("expected an error for an unparseable rule")
}
}
func TestValidateBindingMemberAndRoleName(t *testing.T) {
validMembers := []string{
SystemAuthenticated,
"email:[email protected]",
"email:*@example.com",
"user:system:serviceaccount:payments:*",
"user:spiffe://cluster.local/ns/payments/sa/*",
"group:eng-*",
"group:Engineering Team",
"group:Engineering *",
"group:Équipe Ingénierie",
"group:team;ops",
"idp_role:*-worker",
"node:12D3KooWA4Xop1JaT3MHxwYMkCepYsv4iPVopMXwCz5iHYdBfeSB",
}
for _, m := range validMembers {
if err := ValidateBindingMember(m, "payments"); err != nil {
t.Errorf("ValidateBindingMember(%q) unexpected error: %v", m, err)
}
}
invalidMembers := []string{
"",
"user:",
"unknown:alice",
"user:*",
"email:*",
"group:*",
"node:*",
"node:12D3KooW*",
"user:system:serviceaccount:*:worker",
"user:*middle*",
`user:foo"); role("admin") <- true; //`,
`user:alice\bob`,
"user:alice\nbob",
"user:alice\x00bob",
"user:alice\x7fbob",
}
for _, m := range invalidMembers {
if err := ValidateBindingMember(m, "payments"); err == nil {
t.Errorf("ValidateBindingMember(%q) expected error, got nil", m)
}
}
for _, validRole := range []string{"payments-worker_1", "Engineering Team", "Équipe;Ops"} {
if err := ValidateRoleName(validRole); err != nil {
t.Errorf("ValidateRoleName(%q) unexpected error: %v", validRole, err)
}
}
for _, badRole := range []string{"", " ", `admin") <- true; //`, `role\slash`, "role\nnewline"} {
if err := ValidateRoleName(badRole); err == nil {
t.Errorf("ValidateRoleName(%q) expected error, got nil", badRole)
}
}
}
func TestMatchBindingMemberValue(t *testing.T) {
candidates := []string{
"system:serviceaccount:payments:worker-a",
"[email protected]",
}
cases := []struct {
pattern string
want bool
}{
{"system:serviceaccount:payments:worker-a", true},
{"system:serviceaccount:payments:worker-b", false},
{"system:serviceaccount:payments:*", true},
{"system:serviceaccount:billing:*", false},
{"*@proj.iam.gserviceaccount.com", true},
{"*@other.iam.gserviceaccount.com", false},
{"*", false},
{"system:serviceaccount:*:worker-a", false},
{"", false},
}
for _, tc := range cases {
if got := MatchBindingMemberValue(candidates, tc.pattern); got != tc.want {
t.Errorf("MatchBindingMemberValue(%q) = %v, want %v", tc.pattern, got, tc.want)
}
}
}
func TestBuildPolicyRulesWildcardsAndInjectionDefense(t *testing.T) {
roles := []*PolicyRole{
{
Name: "payments",
AllowedServices: []string{"mcp:Echo"},
AllowedTargets: []string{"*", `node:bad"quote`, "bad fact:val"},
},
}
bindings := []*PolicyBinding{
{
Role: "payments",
Members: []string{
"user:system:serviceaccount:payments:*",
"email:*@proj.iam.gserviceaccount.com",
"group:Engineering Team",
"group:Équipe Ingénierie",
"group:team;ops",
"user:*",
"user:system:*:Invalid",
`user:foo")*`,
`user:exact"quote`,
`user:exact\slash`,
},
},
}
rules, warnings := BuildPolicyRules(roles, bindings)
if len(warnings) != 7 {
t.Fatalf("warnings = %v (len %d), want 7 warnings for rejected entries", warnings, len(warnings))
}
texts := PolicyRuleTexts(rules)
wantRules := []string{
`role("payments") <- user($v), $v.starts_with("system:serviceaccount:payments:")`,
`role("payments") <- email($v), $v.ends_with("@proj.iam.gserviceaccount.com")`,
`role("payments") <- group("Engineering Team")`,
`role("payments") <- group("Équipe Ingénierie")`,
`role("payments") <- group("team;ops")`,
}
for _, want := range wantRules {
if !slices.Contains(texts, want) {
t.Errorf("missing expected rule %q in %v", want, texts)
}
}
if _, err := ParseDatalogRules(texts); err != nil {
t.Fatalf("ParseDatalogRules failed on generated rules: %v", err)
}
}