Files
archie/internal/tools/provider/memory/provider_test.go
T
sam f73b2d1c8c feat: memory manager sync/prefetch/scan/shutdown + broad in-flight epic work
Checkpoint commit covering concurrent work across several archie-core-abg
epics to avoid losing in-progress state:

- Memory manager (18.7-18.16): background sync pipeline, prefetch with
  timeout, memory-write notification, threat scanning, shutdown drain
  with abandoned-write tracking, frozen snapshot pattern. Wired
  ScanContent and NotifyMemoryToolWrite into HandleToolCall so scanning
  and notification actually apply to writes, not just exist as unused
  primitives.
- Fixed a literal unresolved merge-conflict that had been committed to
  internal/memory/scrubber/scrubber.go.
- Tool provider/registry, MCP client/transport (stdio, HTTP, SSE),
  multimodal results, disclosure.
- Pairing device auth store, rate limiting.
- Gateway compression, session store, tasks.
- Various workflow, plugin host, and agentexec updates.
2026-07-27 03:34:46 +10:00

124 lines
3.1 KiB
Go

package memory
import (
"context"
"testing"
corememory "github.com/samcharles93/archie-core/internal/memory"
"github.com/samcharles93/archie-core/internal/plugin"
"github.com/samcharles93/archie-core/internal/tools"
)
func TestProviderDiscoversExecutableMemoryTools(t *testing.T) {
backend := &fakeMemoryProvider{
available: true,
entries: []tools.ToolEntry{{
Name: "memory_search",
Description: "Search memory",
Schema: tools.JSONSchema{"type": "object"},
}},
result: "remembered",
}
manager, err := corememory.NewManager(backend, nil)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
if err := manager.Shutdown(); err != nil {
t.Errorf("memory manager shutdown: %v", err)
}
})
provider := New(manager)
if err := provider.Start(context.Background()); err != nil {
t.Fatal(err)
}
entries, err := provider.Discover(context.Background())
if err != nil {
t.Fatal(err)
}
if len(entries) != 1 || entries[0].Name != "memory_search" {
t.Fatalf("Discover() = %v, want memory_search", entryNames(entries))
}
if entries[0].Handler == nil {
t.Fatal("memory tool handler is nil")
}
got, err := entries[0].Handler(context.Background(), map[string]any{"query": "architecture"})
if err != nil {
t.Fatal(err)
}
if got != backend.result {
t.Fatalf("handler result = %v, want %v", got, backend.result)
}
if backend.calledName != "memory_search" || backend.calledArgs["query"] != "architecture" {
t.Fatalf("memory call = %q %#v", backend.calledName, backend.calledArgs)
}
}
func TestProviderLifecycleWithNilManager(t *testing.T) {
provider := New(nil)
if err := provider.Start(context.Background()); err == nil {
t.Fatal("Start() succeeded with nil manager")
}
if _, err := provider.Discover(context.Background()); err == nil {
t.Fatal("Discover() succeeded with nil manager")
}
if got := provider.Health(context.Background()).Status; got != plugin.HealthUnhealthy {
t.Fatalf("Health().Status = %q, want unhealthy", got)
}
if err := provider.Stop(context.Background()); err != nil {
t.Fatalf("Stop() = %v, want no-op", err)
}
}
func TestProviderSatisfiesToolProviderEngine(t *testing.T) {
var _ interface {
plugin.Module
Discover(context.Context) ([]tools.ToolEntry, error)
} = New(nil)
}
type fakeMemoryProvider struct {
available bool
entries []tools.ToolEntry
result any
callErr error
calledName string
calledArgs map[string]any
}
func (p *fakeMemoryProvider) Name() string {
return "fake-memory"
}
func (p *fakeMemoryProvider) IsAvailable() bool {
return p.available
}
func (p *fakeMemoryProvider) Initialize(string) error {
return nil
}
func (p *fakeMemoryProvider) GetToolSchemas() []tools.ToolEntry {
return p.entries
}
func (p *fakeMemoryProvider) HandleToolCall(name string, args map[string]any) (any, error) {
p.calledName = name
p.calledArgs = args
if p.callErr != nil {
return nil, p.callErr
}
return p.result, nil
}
func entryNames(entries []tools.ToolEntry) []string {
names := make([]string, len(entries))
for i, entry := range entries {
names[i] = entry.Name
}
return names
}
var _ corememory.ToolCallProvider = (*fakeMemoryProvider)(nil)