Registry.Discover, DefaultRegistry and the go/ast extraction helpers have no production caller; static source discovery has no PRD and no consumer. Production registration goes through bootstrap.go's toolReg.Register and the provider Registry's RegisterBatch (tools-core-3).
383 lines
10 KiB
Go
383 lines
10 KiB
Go
package tools
|
|
|
|
import (
|
|
"errors"
|
|
"slices"
|
|
"testing"
|
|
)
|
|
|
|
func TestRegistryRegister(t *testing.T) {
|
|
t.Run("valid entry", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
err := r.Register(ToolEntry{Name: "hello", Handler: noopHandler})
|
|
if err != nil {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
if len(r.All()) != 1 {
|
|
t.Errorf("expected 1 tool, got %d", len(r.All()))
|
|
}
|
|
})
|
|
|
|
t.Run("duplicate name returns error", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
e := ToolEntry{Name: "dup", Handler: noopHandler}
|
|
if err := r.Register(e); err != nil {
|
|
t.Fatalf("first register: %v", err)
|
|
}
|
|
err := r.Register(e)
|
|
if err == nil {
|
|
t.Error("expected error for duplicate name")
|
|
}
|
|
if !errors.Is(err, ErrDuplicateTool) {
|
|
t.Errorf("expected ErrDuplicateTool, got %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("invalid entry returns validation error", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
err := r.Register(ToolEntry{Name: ""})
|
|
if err == nil {
|
|
t.Error("expected validation error for empty name")
|
|
}
|
|
})
|
|
|
|
t.Run("multiple tools", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
for _, name := range []string{"a", "b", "c"} {
|
|
if err := r.Register(ToolEntry{Name: name, Handler: noopHandler}); err != nil {
|
|
t.Fatalf("register %q: %v", name, err)
|
|
}
|
|
}
|
|
if len(r.All()) != 3 {
|
|
t.Errorf("expected 3 tools, got %d", len(r.All()))
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestRegistryGet(t *testing.T) {
|
|
t.Run("found", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
if err := r.Register(ToolEntry{Name: "hello", Description: "hi", Handler: noopHandler}); err != nil {
|
|
t.Fatalf("register: %v", err)
|
|
}
|
|
e, ok := r.Get("hello")
|
|
if !ok {
|
|
t.Fatal("expected found=true")
|
|
}
|
|
if e.Name != "hello" || e.Description != "hi" {
|
|
t.Errorf("Get returned %+v", e)
|
|
}
|
|
})
|
|
|
|
t.Run("not found", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
_, ok := r.Get("nonexistent")
|
|
if ok {
|
|
t.Error("expected found=false for unregistered name")
|
|
}
|
|
})
|
|
|
|
t.Run("returned entry is a defensive copy", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
if err := r.Register(ToolEntry{Name: "hello", Schema: JSONSchema{"type": "object"}, Handler: noopHandler}); err != nil {
|
|
t.Fatalf("register: %v", err)
|
|
}
|
|
e, _ := r.Get("hello")
|
|
e.Schema["type"] = "mutated"
|
|
e2, _ := r.Get("hello")
|
|
if e2.Schema["type"] != "object" {
|
|
t.Errorf("Get did not defensively copy: registry's schema was mutated to %v", e2.Schema["type"])
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestRegistryAll(t *testing.T) {
|
|
t.Run("empty registry", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
all := r.All()
|
|
if len(all) != 0 {
|
|
t.Errorf("expected 0 tools, got %d", len(all))
|
|
}
|
|
})
|
|
|
|
t.Run("returns copy of tools", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
_ = r.Register(ToolEntry{Name: "x", Handler: noopHandler})
|
|
all := r.All()
|
|
all[0].Name = "mutated"
|
|
// Original registry must be unaffected.
|
|
if r.All()[0].Name != "x" {
|
|
t.Error("All() should return independent copies")
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestRegistryByToolset(t *testing.T) {
|
|
r := NewRegistry()
|
|
_ = r.Register(ToolEntry{Name: "f1", Toolset: "file", Handler: noopHandler})
|
|
_ = r.Register(ToolEntry{Name: "f2", Toolset: "file", Handler: noopHandler})
|
|
_ = r.Register(ToolEntry{Name: "g1", Toolset: "git", Handler: noopHandler})
|
|
_ = r.Register(ToolEntry{Name: "u1", Toolset: "", Handler: noopHandler}) // ungrouped
|
|
|
|
t.Run("filters by toolset", func(t *testing.T) {
|
|
file := r.ByToolset("file")
|
|
if len(file) != 2 {
|
|
t.Errorf("expected 2 file tools, got %d", len(file))
|
|
}
|
|
names := toolNames(file)
|
|
slices.Sort(names)
|
|
if names[0] != "f1" || names[1] != "f2" {
|
|
t.Errorf("unexpected names: %v", names)
|
|
}
|
|
})
|
|
|
|
t.Run("no match returns empty", func(t *testing.T) {
|
|
none := r.ByToolset("nonexistent")
|
|
if len(none) != 0 {
|
|
t.Errorf("expected 0 tools, got %d", len(none))
|
|
}
|
|
})
|
|
|
|
t.Run("empty toolset matches ungrouped", func(t *testing.T) {
|
|
ungrouped := r.ByToolset("")
|
|
if len(ungrouped) != 1 {
|
|
t.Errorf("expected 1 ungrouped tool, got %d", len(ungrouped))
|
|
}
|
|
if ungrouped[0].Name != "u1" {
|
|
t.Errorf("unexpected name: %q", ungrouped[0].Name)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestRegistryAvailable(t *testing.T) {
|
|
r := NewRegistry()
|
|
_ = r.Register(ToolEntry{Name: "always", Handler: noopHandler})
|
|
_ = r.Register(ToolEntry{Name: "offline", Handler: noopHandler, CheckFn: func() bool { return false }})
|
|
_ = r.Register(ToolEntry{Name: "conditional", Handler: noopHandler, CheckFn: func() bool { return true }})
|
|
|
|
t.Run("returns only available tools", func(t *testing.T) {
|
|
avail := r.Available()
|
|
names := toolNames(avail)
|
|
if !slices.Contains(names, "always") {
|
|
t.Error("'always' should be available")
|
|
}
|
|
if !slices.Contains(names, "conditional") {
|
|
t.Error("'conditional' should be available")
|
|
}
|
|
if slices.Contains(names, "offline") {
|
|
t.Error("'offline' should not be available")
|
|
}
|
|
if len(avail) != 2 {
|
|
t.Errorf("expected 2 available tools, got %d", len(avail))
|
|
}
|
|
})
|
|
|
|
t.Run("dynamic availability reflected", func(t *testing.T) {
|
|
flag := true
|
|
_ = r.Register(ToolEntry{
|
|
Name: "toggle",
|
|
Handler: noopHandler,
|
|
CheckFn: func() bool { return flag },
|
|
})
|
|
if len(r.Available()) != 3 {
|
|
t.Errorf("expected 3 available (toggle is true), got %d", len(r.Available()))
|
|
}
|
|
flag = false
|
|
// Available() re-evaluates -- the closure captures &flag.
|
|
if len(r.Available()) != 2 {
|
|
t.Errorf("expected 2 available (toggle is now false), got %d", len(r.Available()))
|
|
}
|
|
})
|
|
}
|
|
|
|
// toolNames extracts names from a slice of ToolEntry.
|
|
func toolNames(entries []ToolEntry) []string {
|
|
names := make([]string, len(entries))
|
|
for i, e := range entries {
|
|
names[i] = e.Name
|
|
}
|
|
return names
|
|
}
|
|
|
|
func TestRegistryAvailableReentrySafety(t *testing.T) {
|
|
// Regression: Available() called CheckFn while holding RLock,
|
|
// which could deadlock if CheckFn re-entered the registry.
|
|
// After the fix, CheckFn is evaluated outside the lock, so
|
|
// calling All(), ByToolset(), or even Register() from inside
|
|
// CheckFn cannot deadlock.
|
|
r := NewRegistry()
|
|
_ = r.Register(ToolEntry{Name: "safe", Handler: noopHandler})
|
|
|
|
called := false
|
|
_ = r.Register(ToolEntry{
|
|
Name: "reentrant",
|
|
Handler: noopHandler,
|
|
CheckFn: func() bool {
|
|
called = true
|
|
// Call All() from inside CheckFn -- must not deadlock.
|
|
_ = r.All()
|
|
// Call ByToolset from inside CheckFn -- must not deadlock.
|
|
_ = r.ByToolset("")
|
|
// Call Register from inside CheckFn -- must not deadlock
|
|
// (was the original deadlock trigger when lock was held).
|
|
_ = r.Register(ToolEntry{Name: "nested-reg", Handler: noopHandler})
|
|
return true
|
|
},
|
|
})
|
|
|
|
avail := r.Available()
|
|
if !called {
|
|
t.Error("CheckFn was not called")
|
|
}
|
|
names := toolNames(avail)
|
|
if !slices.Contains(names, "reentrant") {
|
|
t.Error("reentrant tool should be available")
|
|
}
|
|
}
|
|
|
|
func TestRegistryRegisterDefensiveCopy(t *testing.T) {
|
|
// Regression: Register() stored the caller's Schema map and
|
|
// RequiresEnv slice without deep-copying, enabling data races.
|
|
r := NewRegistry()
|
|
|
|
schema := JSONSchema{"key": "original"}
|
|
env := []string{"ORIGINAL"}
|
|
e := ToolEntry{Name: "copy-test", Handler: noopHandler, Schema: schema, RequiresEnv: env}
|
|
|
|
if err := r.Register(e); err != nil {
|
|
t.Fatalf("register: %v", err)
|
|
}
|
|
|
|
// Mutate the original schema and env -- must not affect registry.
|
|
schema["key"] = "mutated"
|
|
env[0] = "MUTATED"
|
|
|
|
all := r.All()
|
|
if len(all) != 1 {
|
|
t.Fatalf("expected 1 tool, got %d", len(all))
|
|
}
|
|
if all[0].Schema["key"] != "original" {
|
|
t.Errorf("Schema[key] = %v, want 'original' -- caller mutation leaked into registry", all[0].Schema["key"])
|
|
}
|
|
if all[0].RequiresEnv[0] != "ORIGINAL" {
|
|
t.Errorf("RequiresEnv[0] = %q, want 'ORIGINAL' -- caller mutation leaked into registry", all[0].RequiresEnv[0])
|
|
}
|
|
}
|
|
|
|
// Ensure registry implements basic sanity at the package level.
|
|
func TestRegistryPackageLevelHelpers(t *testing.T) {
|
|
t.Run("Register and All via package helpers", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
e := ToolEntry{Name: "pkg_helper", Handler: noopHandler}
|
|
if err := r.Register(e); err != nil {
|
|
t.Fatalf("register: %v", err)
|
|
}
|
|
if len(r.All()) != 1 {
|
|
t.Error("expected 1 tool after register")
|
|
}
|
|
})
|
|
|
|
t.Run("ByToolset from empty reg", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
got := r.ByToolset("none")
|
|
if len(got) != 0 {
|
|
t.Errorf("expected 0, got %d", len(got))
|
|
}
|
|
})
|
|
|
|
t.Run("Available from empty reg", func(t *testing.T) {
|
|
r := NewRegistry()
|
|
got := r.Available()
|
|
if len(got) != 0 {
|
|
t.Errorf("expected 0, got %d", len(got))
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestRegistryRegisterBatchIsAtomic(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
existing []ToolEntry
|
|
batch []ToolEntry
|
|
wantErr bool
|
|
want []string
|
|
}{
|
|
{
|
|
name: "registers complete batch",
|
|
batch: []ToolEntry{
|
|
{Name: "one", Handler: noopHandler},
|
|
{Name: "two", Handler: noopHandler},
|
|
},
|
|
want: []string{"one", "two"},
|
|
},
|
|
{
|
|
name: "existing collision registers nothing",
|
|
existing: []ToolEntry{{Name: "taken", Handler: noopHandler}},
|
|
batch: []ToolEntry{
|
|
{Name: "new", Handler: noopHandler},
|
|
{Name: "taken", Handler: noopHandler},
|
|
},
|
|
wantErr: true,
|
|
want: []string{"taken"},
|
|
},
|
|
{
|
|
name: "duplicate inside batch registers nothing",
|
|
batch: []ToolEntry{
|
|
{Name: "same", Handler: noopHandler},
|
|
{Name: "same", Handler: noopHandler},
|
|
},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "invalid entry registers nothing",
|
|
batch: []ToolEntry{
|
|
{Name: "valid", Handler: noopHandler},
|
|
{Name: "invalid"},
|
|
},
|
|
wantErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
registry := NewRegistry()
|
|
for _, entry := range tt.existing {
|
|
if err := registry.Register(entry); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
err := registry.RegisterBatch(tt.batch)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Fatalf("RegisterBatch() error = %v, wantErr %t", err, tt.wantErr)
|
|
}
|
|
got := make([]string, 0, len(registry.All()))
|
|
for _, entry := range registry.All() {
|
|
got = append(got, entry.Name)
|
|
}
|
|
slices.Sort(got)
|
|
if !slices.Equal(got, tt.want) {
|
|
t.Fatalf("registered names = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRegistryUnregister(t *testing.T) {
|
|
registry := NewRegistry()
|
|
for _, name := range []string{"keep", "remove"} {
|
|
if err := registry.Register(ToolEntry{Name: name, Handler: noopHandler}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
registry.Unregister("remove", "unknown")
|
|
|
|
if _, ok := registry.Get("remove"); ok {
|
|
t.Fatal("removed tool remains registered")
|
|
}
|
|
if _, ok := registry.Get("keep"); !ok {
|
|
t.Fatal("unrelated tool was removed")
|
|
}
|
|
}
|