Files
llmgw/internal/router/mcp_gateway_test.go
T
Ilker ManapandClaude Opus 5.5 4eb49d0e4c The cluster as a read-only MCP server, llmgw:admin
Its tools say what llmgw ctl does: cluster_status, list_nodes,
list_models, list_replicas, explain_placement, node_logs; none changes
anything. The admin API serves it at POST /api/v1/mcp, and the gateway
answers a server registered as llmgw:admin in its own process, so no
token is kept and each control plane serves it. ctl mcp add takes
--bearer-file for a token sent as Authorization: Bearer.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-20 17:18:28 +02:00

133 lines
5.3 KiB
Go

package router
import (
"crypto/sha256"
"strings"
"testing"
"time"
"gitea.mynodes.xyz/ilker/llmgw/internal/mcpclient/mcptest"
"gitea.mynodes.xyz/ilker/llmgw/internal/store"
)
// companyRouter is a gateway with one company MCP server, jira, and two keys:
// one granted jira.echo, one granted nothing.
func companyRouter(t *testing.T, srv *mcptest.Server) (*Router, string, string) {
t.Helper()
cfg := baseConfig()
cfg.Auth.Enabled = true
cfg.Auth.Store = t.TempDir() + "/store.db"
rt := newTestRouter(t, cfg)
ctx := t.Context()
org, _ := rt.store.CreateOrg(ctx, "acme")
team, _ := rt.store.CreateTeam(ctx, org, "eng")
project, _ := rt.store.CreateProject(ctx, team, "agents")
key := func(id, letter string) string {
secret := store.KeyPrefix + strings.Repeat(letter, 43)
sum := sha256.Sum256([]byte(secret))
if err := rt.store.CreateKey(ctx, store.Key{ID: id, Hash: sum[:], Prefix: letter, Name: id,
ProjectID: project, CreatedAt: time.Now()}); err != nil {
t.Fatal(err)
}
return secret
}
granted, plain := key("key-g", "g"), key("key-p", "p")
if err := rt.store.PutLimits(ctx, store.Limits{Scope: store.ScopeKey, ScopeID: "key-g", AllowedTools: []string{"jira.echo"}}); err != nil {
t.Fatal(err)
}
if err := rt.store.SetClusterSecret(ctx, "mcp/jira/Authorization", "Bearer service-token"); err != nil {
t.Fatal(err)
}
if err := rt.store.PutMCPServer(ctx, store.MCPServer{Name: "jira", URL: srv.URL, Description: "tickets", Enabled: true,
Headers: map[string]string{"X-Org": "acme"}, HeaderRefs: map[string]string{"Authorization": "store:mcp/jira/Authorization"}}); err != nil {
t.Fatal(err)
}
return rt, granted, plain
}
func TestACompanyToolIsServedThroughMCPToAKeyGrantedIt(t *testing.T) {
srv := mcptest.New()
defer srv.Close()
rt, granted, plain := companyRouter(t, srv)
h := rt.Handler()
list, _ := mcp(t, h, granted, "tools/list", map[string]any{}, false)
names := strings.Join(toolNames(list), ",")
if !strings.Contains(names, "jira.echo") || strings.Contains(names, "jira.fail") || !strings.Contains(names, "remember") {
t.Fatalf("the granted key sees %s", names)
}
res, _ := mcp(t, h, granted, "tools/call", map[string]any{"name": "jira.echo", "arguments": map[string]any{"text": "PROJ-1"}}, false)
if res["isError"] == true || !strings.Contains(toolResultText(res), "PROJ-1") {
t.Fatalf("the call: %v", res)
}
// With llmgw's credentials and the caller named, never the caller's key.
hdr := srv.Headers[0]
if hdr.Get("Authorization") != "Bearer service-token" || hdr.Get("X-Org") != "acme" ||
hdr.Get("X-Llmgw-Key") != "key-g" || strings.Contains(hdr.Get("Authorization"), store.KeyPrefix) {
t.Errorf("headers to the server: %v", hdr)
}
// A key granted nothing sees none of it, and cannot call it by name.
list, _ = mcp(t, h, plain, "tools/list", map[string]any{}, false)
if strings.Contains(strings.Join(toolNames(list), ","), "jira.") {
t.Errorf("an ungranted key sees %v", toolNames(list))
}
res, _ = mcp(t, h, plain, "tools/call", map[string]any{"name": "jira.echo", "arguments": map[string]any{"text": "x"}}, false)
if res["isError"] != true || len(srv.Calls) != 1 {
t.Errorf("an ungranted call: %v (server saw %d)", res, len(srv.Calls))
}
// Each is in the audit log, with the arguments' size and never their text.
events, err := rt.store.AuditEvents(t.Context(), store.AuditFilter{Contains: "jira.echo"})
if err != nil || len(events) != 2 {
t.Fatalf("audit %+v %v", events, err)
}
for _, e := range events {
if e.Source != "mcp" || strings.Contains(e.Detail, "PROJ-1") || !strings.Contains(e.Detail, "bytes") {
t.Errorf("audit event %+v", e)
}
}
}
func TestACompanyToolsProgressIsPassedOnToAStreamingClient(t *testing.T) {
srv := mcptest.New()
defer srv.Close()
srv.Stream = true
rt, granted, _ := companyRouter(t, srv)
res, events := mcp(t, rt.Handler(), granted, "tools/call", map[string]any{"name": "jira.echo",
"arguments": map[string]any{"text": "streamed"}, "_meta": map[string]any{"progressToken": "p1"}}, true)
if !strings.Contains(toolResultText(res), "streamed") || !strings.Contains(strings.Join(events, "\n"), "halfway") {
t.Errorf("result %v, events %v", res, events)
}
}
// toolResultText is a tool result's first text.
func toolResultText(res map[string]any) string {
content, _ := res["content"].([]any)
if len(content) == 0 {
return ""
}
text, _ := content[0].(map[string]any)["text"].(string)
return text
}
// A server registered as llmgw:admin is answered in this process by the
// handler the control plane gave, with no address to reach.
func TestTheClustersOwnMCPServerIsServedInProcess(t *testing.T) {
srv := mcptest.New()
defer srv.Close()
rt, granted, _ := companyRouter(t, srv)
rt.SetAdminMCP(srv.Config.Handler)
if err := rt.store.PutMCPServer(t.Context(), store.MCPServer{Name: "llmgw", URL: "llmgw:admin", Enabled: true}); err != nil {
t.Fatal(err)
}
if err := rt.store.PutLimits(t.Context(), store.Limits{Scope: store.ScopeKey, ScopeID: "key-g", AllowedTools: []string{"jira.echo", "llmgw.*"}}); err != nil {
t.Fatal(err)
}
rt.mcpgw.readAt = time.Time{}
res, _ := mcp(t, rt.Handler(), granted, "tools/call", map[string]any{"name": "llmgw.echo", "arguments": map[string]any{"text": "inside"}}, false)
if !strings.Contains(toolResultText(res), "inside") {
t.Errorf("result %v", res)
}
}