WeKnora/internal/plugin/activate/mcp_test.go

238 lines
7.6 KiB
Go

package activate
import (
"context"
"errors"
"testing"
"time"
"github.com/Tencent/WeKnora/internal/plugin/install"
"github.com/Tencent/WeKnora/internal/plugin/plugintest"
"github.com/Tencent/WeKnora/internal/plugin/reconcile"
"github.com/Tencent/WeKnora/internal/plugin/registry"
"github.com/Tencent/WeKnora/internal/plugin/tenancy"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
const searchManifest = `schemaVersion: 1
id: acme.search
version: 1.0.0
name: { en-US: ACME Search }
publisher: { id: acme }
runtime: { type: declarative }
config: { tenant: tenant.yaml, system: system.yaml }
contributes:
mcpServers:
- id: search
name: ACME Search
mcp:
url: https://mcp.acme.example/mcp
headers:
Authorization: Bearer ${config.api_key}
X-Region: ${system.region}
`
type env struct {
ctx context.Context
mcp *MCPServers
tenancy *tenancy.Service
installer *install.Service
stored *fakeMCPRepo
repo *mcpRepository
}
// fakeMCPRepo stores one ordinary service per tenant.
type fakeMCPRepo struct {
updates int
saved *types.MCPMetadata
}
func (f *fakeMCPRepo) own(tenantID uint64) *types.MCPService {
return &types.MCPService{ID: "stored", TenantID: tenantID, Name: "Mine", Enabled: true}
}
func (f *fakeMCPRepo) Create(context.Context, *types.MCPService) error { return nil }
func (f *fakeMCPRepo) GetByID(_ context.Context, t uint64, id string) (*types.MCPService, error) {
if id == "stored" {
return f.own(t), nil
}
return nil, nil
}
func (f *fakeMCPRepo) List(_ context.Context, t uint64) ([]*types.MCPService, error) {
return []*types.MCPService{f.own(t)}, nil
}
func (f *fakeMCPRepo) ListEnabled(_ context.Context, t uint64) ([]*types.MCPService, error) {
return []*types.MCPService{f.own(t)}, nil
}
func (f *fakeMCPRepo) ListByIDs(_ context.Context, t uint64, ids []string) ([]*types.MCPService, error) {
for _, id := range ids {
if id == "stored" {
return []*types.MCPService{f.own(t)}, nil
}
}
return nil, nil
}
func (f *fakeMCPRepo) Update(context.Context, *types.MCPService) error { f.updates++; return nil }
func (f *fakeMCPRepo) Delete(context.Context, uint64, string) error { return nil }
func setup(t *testing.T) *env {
t.Helper()
ctx := context.Background()
plugins, store, reg := plugintest.NewMemRepo(), &plugintest.MemStore{}, registry.New()
ten := tenancy.NewService(reg, &plugintest.MemTenantSettings{})
mcp := NewMCPServers()
mcp.Bind(ten, plugins)
r := reconcile.New(reconcile.Options{
Repo: plugins, Store: store, Registry: reg, CacheDir: t.TempDir(), Activators: []reconcile.Activator{mcp},
})
installer := install.NewService(plugins, store, r, "")
pkg := plugintest.Zip(t, map[string]string{
"plugin.yaml": searchManifest,
"tenant.yaml": "type: object\nproperties: { api_key: { type: string, x-secret: true } }\nrequired: [api_key]\n",
"system.yaml": "type: object\nproperties: { region: { type: string } }\n",
})
if _, err := installer.Install(ctx, install.Request{Data: pkg}); err != nil {
t.Fatal(err)
}
stored := &fakeMCPRepo{}
return &env{
ctx: ctx, mcp: mcp, tenancy: ten, installer: installer, stored: stored,
repo: mcp.Repository(stored).(*mcpRepository),
}
}
func TestPluginMCPServiceFollowsTenantSwitchAndConfig(t *testing.T) {
e := setup(t)
list, _ := e.repo.List(e.ctx, 1)
if len(list) != 1 {
t.Fatalf("a plugin the tenant has not enabled must stay hidden, got %d services", len(list))
}
if err := e.tenancy.SetEnabled(e.ctx, 1, "acme.search", true, "u"); err != nil {
t.Fatal(err)
}
list, _ = e.repo.List(e.ctx, 1)
if len(list) != 2 {
t.Fatalf("want stored + plugin service, got %d", len(list))
}
svc := list[1]
if svc.PluginID != "acme.search" || !svc.IsBuiltin || svc.Enabled || svc.PluginError == "" {
t.Fatalf("an unconfigured plugin service must be listed disabled: %+v", svc)
}
enabled, _ := e.repo.ListEnabled(e.ctx, 1)
if len(enabled) != 1 {
t.Fatal("agents must not get an unconfigured plugin service")
}
if _, err := e.installer.SetSystemConfig(e.ctx, "acme.search", map[string]any{"region": "eu"}); err != nil {
t.Fatal(err)
}
if _, err := e.tenancy.SetConfig(e.ctx, 1, "acme.search", map[string]any{"api_key": "k-1"}, "u"); err != nil {
t.Fatal(err)
}
got, err := e.repo.GetByID(e.ctx, 1, svc.ID)
if err != nil || got == nil || !got.Enabled {
t.Fatalf("GetByID = %+v, %v", got, err)
}
if got.Headers["Authorization"] != "Bearer k-1" || got.Headers["X-Region"] != "eu" {
t.Fatalf("headers = %v", got.Headers)
}
if !got.UpdatedAt.After(svc.UpdatedAt) {
t.Fatal("changing configuration must move UpdatedAt so the MCP client reconnects")
}
byIDs, _ := e.repo.ListByIDs(e.ctx, 1, []string{"stored", svc.ID})
if len(byIDs) != 2 {
t.Fatalf("ListByIDs = %d", len(byIDs))
}
// Each tenant has its own service ID and configuration.
if err := e.tenancy.SetEnabled(e.ctx, 2, "acme.search", true, "u"); err != nil {
t.Fatal(err)
}
other, _ := e.repo.List(e.ctx, 2)
if other[1].ID == svc.ID || other[1].Enabled {
t.Fatalf("tenant 2 = %+v", other[1])
}
if err := e.repo.Update(e.ctx, got); !errors.Is(err, ErrPluginService) {
t.Fatalf("Update = %v", err)
}
if err := e.repo.Delete(e.ctx, 1, svc.ID); !errors.Is(err, ErrPluginService) {
t.Fatalf("Delete = %v", err)
}
if _, err := e.installer.SetEnabled(e.ctx, "acme.search", false); err != nil {
t.Fatal(err)
}
if list, _ := e.repo.List(e.ctx, 1); len(list) != 1 {
t.Fatal("disabling the plugin platform-wide must remove its services")
}
}
func (f *fakeMCPRepo) GetMetadata(_ context.Context, _ uint64, id, _ string) (*types.MCPMetadata, error) {
if f.saved != nil && f.saved.ServiceID == id {
return f.saved, nil
}
return nil, nil
}
func (f *fakeMCPRepo) ListMetadataSummaries(context.Context, uint64, []string) ([]*types.MCPMetadataSummary, error) {
if f.saved == nil {
return nil, nil
}
return []*types.MCPMetadataSummary{{ServiceID: f.saved.ServiceID}}, nil
}
func (f *fakeMCPRepo) SaveMetadata(_ context.Context, m *types.MCPMetadata) error {
f.saved = m
return nil
}
// Agents discover MCP tools through stored directory snapshots. Plugin
// services have no row to reference, so the wrapper keeps theirs.
func TestPluginMCPDirectories(t *testing.T) {
e := setup(t)
if err := e.tenancy.SetEnabled(e.ctx, 1, "acme.search", true, "u"); err != nil {
t.Fatal(err)
}
meta, ok := e.mcp.Repository(e.stored).(interfaces.MCPMetadataRepository)
if !ok {
t.Fatal("the wrapped repository hides directory storage")
}
id := serviceID(1, "acme.search/search")
older := time.Now().Add(-time.Minute)
first := &types.MCPMetadata{
TenantID: 1, ServiceID: id, Tools: []*types.MCPTool{{Name: "search"}}, SyncedAt: time.Now(),
}
if err := meta.SaveMetadata(e.ctx, first); err != nil {
t.Fatal(err)
}
// An older refresh arriving late does not win.
_ = meta.SaveMetadata(e.ctx, &types.MCPMetadata{TenantID: 1, ServiceID: id, SyncedAt: older})
got, err := meta.GetMetadata(e.ctx, 1, id, "")
if err != nil || got == nil || len(got.Tools) != 1 {
t.Fatalf("plugin directory = %+v, %v", got, err)
}
if other, _ := meta.GetMetadata(e.ctx, 2, id, ""); other != nil {
t.Fatal("another workspace reads the directory")
}
if err := meta.SaveMetadata(e.ctx, &types.MCPMetadata{TenantID: 1, ServiceID: "stored"}); err != nil ||
e.stored.saved == nil {
t.Fatalf("stored services' directories go to the database: %v", err)
}
sums, _ := meta.ListMetadataSummaries(e.ctx, 1, []string{""})
if len(sums) != 2 {
t.Fatalf("summaries = %d", len(sums))
}
if err := e.mcp.Deactivate(e.ctx, "acme.search"); err != nil {
t.Fatal(err)
}
if len(e.mcp.directories) != 0 {
t.Fatal("an unloaded plugin keeps its directories")
}
}