249 lines
7.2 KiB
Go
249 lines
7.2 KiB
Go
package registry
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strconv"
|
|
"sync"
|
|
"testing"
|
|
|
|
"git.yeij.top/AskaEth/Cyrene_v2/pkg/plugins/sdk"
|
|
)
|
|
|
|
// regTool is a mock Tool for registry tests.
|
|
type regTool struct{ name string }
|
|
|
|
func (t regTool) Name() string { return t.name }
|
|
func (t regTool) Description() string { return "desc " + t.name }
|
|
func (t regTool) Parameters() (map[string]any, error) { return map[string]any{}, nil }
|
|
func (t regTool) Execute(_ context.Context, _ any) (any, error) { return nil, nil }
|
|
|
|
// regSkill is a mock Skill for registry tests.
|
|
type regSkill struct{ name string }
|
|
|
|
func (s regSkill) Name() string { return s.name }
|
|
func (s regSkill) Description() string { return "desc " + s.name }
|
|
func (s regSkill) Prompt() string { return "prompt" }
|
|
func (s regSkill) Steps() []sdk.Step { return []sdk.Step{{Name: "s1", Prompt: "p1"}} }
|
|
func (s regSkill) Refs() []sdk.Ref { return nil }
|
|
func (s regSkill) Guardrails() []sdk.Guardrail { return nil }
|
|
|
|
// regChannel is a mock Channel for registry tests.
|
|
type regChannel struct{ name string }
|
|
|
|
func (c regChannel) Name() string { return c.name }
|
|
func (c regChannel) Connect(_ context.Context, _ any) error { return nil }
|
|
func (c regChannel) Disconnect(_ context.Context) error { return nil }
|
|
func (c regChannel) IsConnected() bool { return true }
|
|
func (c regChannel) HealthCheck(_ context.Context) error { return nil }
|
|
|
|
func TestNew_Empty(t *testing.T) {
|
|
t.Parallel()
|
|
r := New()
|
|
if got := r.List(KindTool); len(got) != 0 {
|
|
t.Fatalf("List(KindTool) = %v, want empty", got)
|
|
}
|
|
if _, err := r.Get("missing"); !errors.Is(err, ErrNotFound) {
|
|
t.Fatalf("Get(missing) error = %v, want ErrNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestRegister_Get(t *testing.T) {
|
|
t.Parallel()
|
|
r := New()
|
|
if err := r.Register(Capability{Name: "t1", Kind: KindTool, Description: "d", Value: regTool{name: "t1"}}); err != nil {
|
|
t.Fatalf("Register: %v", err)
|
|
}
|
|
got, err := r.Get("t1")
|
|
if err != nil {
|
|
t.Fatalf("Get: %v", err)
|
|
}
|
|
if got.Name != "t1" || got.Kind != KindTool || got.Description != "d" {
|
|
t.Fatalf("Get = %+v, want name=t1 kind=tool desc=d", got)
|
|
}
|
|
}
|
|
|
|
func TestRegister_Duplicate(t *testing.T) {
|
|
t.Parallel()
|
|
r := New()
|
|
cap := Capability{Name: "dup", Kind: KindTool, Value: regTool{name: "dup"}}
|
|
if err := r.Register(cap); err != nil {
|
|
t.Fatalf("first Register: %v", err)
|
|
}
|
|
err := r.Register(Capability{Name: "dup", Kind: KindSkill, Value: regSkill{name: "dup"}})
|
|
if !errors.Is(err, ErrDuplicate) {
|
|
t.Fatalf("second Register error = %v, want ErrDuplicate", err)
|
|
}
|
|
}
|
|
|
|
func TestRegister_InvalidArgument(t *testing.T) {
|
|
t.Parallel()
|
|
r := New()
|
|
tests := []struct {
|
|
name string
|
|
cap Capability
|
|
}{
|
|
{name: "empty name", cap: Capability{Kind: KindTool, Value: regTool{name: "x"}}},
|
|
{name: "unknown kind", cap: Capability{Name: "x", Kind: "bogus", Value: regTool{name: "x"}}},
|
|
{name: "nil value", cap: Capability{Name: "x", Kind: KindTool}},
|
|
}
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if err := r.Register(tt.cap); !errors.Is(err, ErrInvalidArgument) {
|
|
t.Fatalf("Register(%+v) error = %v, want ErrInvalidArgument", tt.cap, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGet_NotFound(t *testing.T) {
|
|
t.Parallel()
|
|
r := New()
|
|
got, err := r.Get("nope")
|
|
if !errors.Is(err, ErrNotFound) {
|
|
t.Fatalf("Get error = %v, want ErrNotFound", err)
|
|
}
|
|
if got != (Capability{}) {
|
|
t.Fatalf("Get returned %+v on error, want zero Capability", got)
|
|
}
|
|
}
|
|
|
|
func TestList_ByKind(t *testing.T) {
|
|
t.Parallel()
|
|
r := New()
|
|
caps := []Capability{
|
|
{Name: "t1", Kind: KindTool, Value: regTool{name: "t1"}},
|
|
{Name: "s1", Kind: KindSkill, Value: regSkill{name: "s1"}},
|
|
{Name: "c1", Kind: KindChannel, Value: regChannel{name: "c1"}},
|
|
{Name: "m1", Kind: KindMCP, Value: "mcp"},
|
|
{Name: "i1", Kind: KindIoT, Value: "iot"},
|
|
}
|
|
for _, c := range caps {
|
|
if err := r.Register(c); err != nil {
|
|
t.Fatalf("Register(%s): %v", c.Name, err)
|
|
}
|
|
}
|
|
if got := r.List(KindTool); len(got) != 1 || got[0].Name != "t1" {
|
|
t.Fatalf("List(KindTool) = %+v, want [t1]", got)
|
|
}
|
|
if got := r.List(KindMCP); len(got) != 1 || got[0].Name != "m1" {
|
|
t.Fatalf("List(KindMCP) = %+v, want [m1]", got)
|
|
}
|
|
if got := r.List(""); len(got) != len(caps) {
|
|
t.Fatalf("List(\"\") length = %d, want %d", len(got), len(caps))
|
|
}
|
|
}
|
|
|
|
func TestRegister_SDKWrappers(t *testing.T) {
|
|
t.Parallel()
|
|
r := New()
|
|
|
|
if err := r.RegisterTool(regTool{name: "calc"}); err != nil {
|
|
t.Fatalf("RegisterTool: %v", err)
|
|
}
|
|
tool, err := r.Get("calc")
|
|
if err != nil {
|
|
t.Fatalf("Get tool: %v", err)
|
|
}
|
|
if tool.Kind != KindTool {
|
|
t.Fatalf("tool kind = %q, want %q", tool.Kind, KindTool)
|
|
}
|
|
if got := tool.Value.(sdk.Tool).Name(); got != "calc" {
|
|
t.Fatalf("tool Value.Name() = %q, want calc", got)
|
|
}
|
|
|
|
if err := r.RegisterSkill(regSkill{name: "review"}); err != nil {
|
|
t.Fatalf("RegisterSkill: %v", err)
|
|
}
|
|
skill, err := r.Get("review")
|
|
if err != nil {
|
|
t.Fatalf("Get skill: %v", err)
|
|
}
|
|
if skill.Kind != KindSkill {
|
|
t.Fatalf("skill kind = %q, want %q", skill.Kind, KindSkill)
|
|
}
|
|
if got := skill.Value.(sdk.Skill).Name(); got != "review" {
|
|
t.Fatalf("skill Value.Name() = %q, want review", got)
|
|
}
|
|
|
|
if err := r.RegisterChannel(regChannel{name: "telegram"}); err != nil {
|
|
t.Fatalf("RegisterChannel: %v", err)
|
|
}
|
|
channel, err := r.Get("telegram")
|
|
if err != nil {
|
|
t.Fatalf("Get channel: %v", err)
|
|
}
|
|
if channel.Kind != KindChannel {
|
|
t.Fatalf("channel kind = %q, want %q", channel.Kind, KindChannel)
|
|
}
|
|
if got := channel.Value.(sdk.Channel).Name(); got != "telegram" {
|
|
t.Fatalf("channel Value.Name() = %q, want telegram", got)
|
|
}
|
|
}
|
|
|
|
func TestRegister_NilSDKValue(t *testing.T) {
|
|
t.Parallel()
|
|
r := New()
|
|
tests := []struct {
|
|
name string
|
|
call func() error
|
|
}{
|
|
{name: "tool", call: func() error { return r.RegisterTool(nil) }},
|
|
{name: "skill", call: func() error { return r.RegisterSkill(nil) }},
|
|
{name: "channel", call: func() error { return r.RegisterChannel(nil) }},
|
|
}
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
err := tt.call()
|
|
if !errors.Is(err, ErrInvalidArgument) {
|
|
t.Fatalf("err = %v, want ErrInvalidArgument", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRegistry_ConcurrentSafety(t *testing.T) {
|
|
t.Parallel()
|
|
r := New()
|
|
|
|
const workers = 8
|
|
const perWorker = 100
|
|
var wg sync.WaitGroup
|
|
for w := 0; w < workers; w++ {
|
|
wg.Add(1)
|
|
go func(w int) {
|
|
defer wg.Done()
|
|
for i := 0; i < perWorker; i++ {
|
|
name := kn(w, i)
|
|
if err := r.RegisterTool(regTool{name: name}); err != nil {
|
|
t.Errorf("RegisterTool(%s): %v", name, err)
|
|
return
|
|
}
|
|
if _, err := r.Get(name); err != nil {
|
|
t.Errorf("Get(%s): %v", name, err)
|
|
}
|
|
// Concurrent reads and a miss do not race with writes.
|
|
_ = r.List("")
|
|
_, _ = r.Get("missing-" + name)
|
|
}
|
|
}(w)
|
|
}
|
|
wg.Wait()
|
|
|
|
if got := len(r.List("")); got != workers*perWorker {
|
|
t.Fatalf("registered %d capabilities, want %d", got, workers*perWorker)
|
|
}
|
|
if _, err := r.Get(kn(workers-1, perWorker-1)); err != nil {
|
|
t.Fatalf("Get last capability: %v", err)
|
|
}
|
|
}
|
|
|
|
// kn builds a capability name unique to a worker/iteration pair.
|
|
func kn(w, i int) string {
|
|
return "cap" + strconv.Itoa(w) + "-" + strconv.Itoa(i)
|
|
}
|