Files
archie/internal/tools/registry_test.go
T
sam 5c8f2f400a refactor(tools): delete unreachable AST-based tool discovery
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).
2026-09-15 10:23:17 +10:00

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")
}
}