Files
archie/internal/memory/manager_test.go
T

1057 lines
31 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package memory
import (
"context"
"errors"
"sync"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/tools"
)
// mockProvider implements every interface in the memory package so tests can
// verify that the MemoryManager correctly discovers and dispatches to optional
// behavior via type assertion.
type mockProvider struct {
nameVal string
availableVal bool
toolSchemasVal []tools.ToolEntry
toolCallHandler func(name string, args map[string]any) (any, error)
mu sync.Mutex
// call counters for assertion
initCalls int
shutdownCalls int
prefetchCalls int
queuePrefetchCalls int
syncTurnCalls int
systemPromptCalls int
turnStartCalls int
sessionEndCalls int
sessionSwitchCalls int
preCompressCalls int
memoryWriteCalls int
delegationCalls int
saveConfigCalls int
getConfigSchemaCalls int
backupPathsCalls int
handleToolCallCalls int
// last args
lastSessionID string
lastOldSessionID string
lastNewSessionID string
lastUserMsg string
lastAssistantMsg string
lastPrefetchQuery string
lastQueuePrefetchQuery string
lastMemoryContent string
lastMemorySessionID string
lastToolName string
lastToolArgs map[string]any
lastSaveValues map[string]any
lastSaveHermesHome string
lastConfigSchema map[string]any
lastBackupPaths []string
// hookDone is signalled for each hook goroutine that completes.
// Tests use it instead of time.Sleep for reliable synchronization.
hookDone chan string
}
func newMockProvider(name string) *mockProvider {
return &mockProvider{
nameVal: name,
availableVal: true,
hookDone: make(chan string, 50),
toolSchemasVal: []tools.ToolEntry{
{
Name: name + "_tool",
Description: "A test tool for " + name,
Schema: tools.JSONSchema{"type": "object"},
},
},
}
}
// ── MemoryProvider ──────────────────────────────────────────────────────
func (m *mockProvider) Name() string { return m.nameVal }
func (m *mockProvider) IsAvailable() bool { return m.availableVal }
func (m *mockProvider) Initialize(sessionID string) error {
m.mu.Lock()
m.initCalls++
m.lastSessionID = sessionID
m.mu.Unlock()
return nil
}
func (m *mockProvider) GetToolSchemas() []tools.ToolEntry { return m.toolSchemasVal }
// ── SystemPromptProvider ────────────────────────────────────────────────
func (m *mockProvider) SystemPromptBlock() string {
m.mu.Lock()
m.systemPromptCalls++
m.mu.Unlock()
return "mock system prompt block for " + m.nameVal
}
// ── PrefetchProvider ────────────────────────────────────────────────────
func (m *mockProvider) Prefetch(query string) (string, error) {
m.mu.Lock()
m.prefetchCalls++
m.lastPrefetchQuery = query
m.mu.Unlock()
return "prefetch result for: " + query, nil
}
func (m *mockProvider) QueuePrefetch(query string) error {
m.mu.Lock()
m.queuePrefetchCalls++
m.lastQueuePrefetchQuery = query
m.mu.Unlock()
return nil
}
// ── SyncTurnProvider ────────────────────────────────────────────────────
func (m *mockProvider) SyncTurn(userMsg, assistantMsg string) error {
m.mu.Lock()
m.syncTurnCalls++
m.lastUserMsg = userMsg
m.lastAssistantMsg = assistantMsg
m.mu.Unlock()
return nil
}
// ── ToolCallProvider ────────────────────────────────────────────────────
func (m *mockProvider) HandleToolCall(name string, args map[string]any) (any, error) {
m.mu.Lock()
m.handleToolCallCalls++
m.lastToolName = name
m.lastToolArgs = args
m.mu.Unlock()
if m.toolCallHandler != nil {
return m.toolCallHandler(name, args)
}
return map[string]any{"result": "ok", "provider": m.nameVal}, nil
}
// ── ShutdownProvider ────────────────────────────────────────────────────
func (m *mockProvider) Shutdown() error {
m.mu.Lock()
m.shutdownCalls++
m.mu.Unlock()
return nil
}
// ── Lifecycle hooks ─────────────────────────────────────────────────────
func (m *mockProvider) OnTurnStart(sessionID string) error {
m.mu.Lock()
m.turnStartCalls++
m.lastSessionID = sessionID
m.mu.Unlock()
m.hookDone <- "turnStart:" + m.nameVal
return nil
}
func (m *mockProvider) OnSessionEnd(sessionID string) error {
m.mu.Lock()
m.sessionEndCalls++
m.lastSessionID = sessionID
m.mu.Unlock()
m.hookDone <- "sessionEnd:" + m.nameVal
return nil
}
func (m *mockProvider) OnSessionSwitch(oldSessionID, newSessionID string) error {
m.mu.Lock()
m.sessionSwitchCalls++
m.lastOldSessionID = oldSessionID
m.lastNewSessionID = newSessionID
m.mu.Unlock()
m.hookDone <- "sessionSwitch:" + m.nameVal
return nil
}
func (m *mockProvider) OnPreCompress(sessionID string) error {
m.mu.Lock()
m.preCompressCalls++
m.lastSessionID = sessionID
m.mu.Unlock()
m.hookDone <- "preCompress:" + m.nameVal
return nil
}
func (m *mockProvider) OnMemoryWrite(sessionID string, content string) error {
m.mu.Lock()
m.memoryWriteCalls++
m.lastMemorySessionID = sessionID
m.lastMemoryContent = content
m.mu.Unlock()
m.hookDone <- "memoryWrite:" + m.nameVal
return nil
}
func (m *mockProvider) OnDelegation(sessionID string) error {
m.mu.Lock()
m.delegationCalls++
m.lastSessionID = sessionID
m.mu.Unlock()
m.hookDone <- "delegation:" + m.nameVal
return nil
}
// ── Config helpers ──────────────────────────────────────────────────────
func (m *mockProvider) GetConfigSchema() map[string]any {
m.mu.Lock()
m.getConfigSchemaCalls++
m.mu.Unlock()
return map[string]any{
"type": "object",
"properties": map[string]any{},
}
}
func (m *mockProvider) SaveConfig(values map[string]any, hermesHome string) error {
m.mu.Lock()
m.saveConfigCalls++
m.lastSaveValues = values
m.lastSaveHermesHome = hermesHome
m.mu.Unlock()
return nil
}
// ── Backup paths ────────────────────────────────────────────────────────
func (m *mockProvider) BackupPaths() []string {
m.mu.Lock()
m.backupPathsCalls++
m.mu.Unlock()
return []string{"/var/data/" + m.nameVal}
}
// ── Compile-time checks ─────────────────────────────────────────────────
//
// Verify mockProvider satisfies every interface in the package.
var _ MemoryProvider = (*mockProvider)(nil)
var _ SystemPromptProvider = (*mockProvider)(nil)
var _ PrefetchProvider = (*mockProvider)(nil)
var _ SyncTurnProvider = (*mockProvider)(nil)
var _ ToolCallProvider = (*mockProvider)(nil)
var _ ShutdownProvider = (*mockProvider)(nil)
var _ TurnStartHook = (*mockProvider)(nil)
var _ SessionEndHook = (*mockProvider)(nil)
var _ SessionSwitchHook = (*mockProvider)(nil)
var _ PreCompressHook = (*mockProvider)(nil)
var _ MemoryWriteHook = (*mockProvider)(nil)
var _ DelegationHook = (*mockProvider)(nil)
var _ ConfigSchemaProvider = (*mockProvider)(nil)
var _ SaveConfigProvider = (*mockProvider)(nil)
var _ BackupProvider = (*mockProvider)(nil)
// ── Tests ───────────────────────────────────────────────────────────────
func TestNewManager(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager(builtin, nil) returned error: %v", err)
}
if mgr == nil {
t.Fatal("NewManager returned nil manager")
}
if got := mgr.Builtin(); got != builtin {
t.Errorf("Builtin() = %v, want %v", got, builtin)
}
if got := mgr.External(); got != nil {
t.Errorf("External() = %v, want nil", got)
}
}
func TestNewManager_WithExternal(t *testing.T) {
builtin := newMockProvider("builtin")
ext := newMockProvider("external")
mgr, err := NewManager(builtin, ext)
if err != nil {
t.Fatalf("NewManager(builtin, ext) returned error: %v", err)
}
if got := mgr.External(); got != ext {
t.Errorf("External() = %v, want %v", got, ext)
}
}
func TestNewManager_RegisterExternal(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
ext := newMockProvider("external")
if err := mgr.RegisterExternal(ext); err != nil {
t.Fatalf("RegisterExternal() returned error: %v", err)
}
if got := mgr.External(); got != ext {
t.Errorf("External() = %v, want %v", got, ext)
}
}
func TestNewManager_RegisterSecondExternal_ReturnsError(t *testing.T) {
builtin := newMockProvider("builtin")
ext1 := newMockProvider("ext1")
mgr, err := NewManager(builtin, ext1)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
ext2 := newMockProvider("ext2")
err = mgr.RegisterExternal(ext2)
if err == nil {
t.Fatal("expected error when registering second external provider, got nil")
}
if !errors.Is(err, ErrExternalAlreadyRegistered) {
t.Errorf("expected ErrExternalAlreadyRegistered, got: %v", err)
}
}
func TestNewManager_NilBuiltin(t *testing.T) {
mgr, err := NewManager(nil, nil)
if err != nil {
t.Fatalf("NewManager(nil, nil) returned error: %v", err)
}
if mgr == nil {
t.Fatal("NewManager returned nil")
}
if mgr.Builtin() != nil {
t.Errorf("Builtin() = %v, want nil", mgr.Builtin())
}
}
func TestManager_GetToolSchemas_MergesAllProviders(t *testing.T) {
builtin := newMockProvider("builtin")
ext := newMockProvider("external")
// Give the external provider different tools so we can distinguish
ext.toolSchemasVal = []tools.ToolEntry{
{Name: "ext_tool_1", Description: "External tool 1"},
{Name: "ext_tool_2", Description: "External tool 2"},
}
mgr, err := NewManager(builtin, ext)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
schemas := mgr.GetToolSchemas()
if len(schemas) != 3 {
t.Fatalf("GetToolSchemas() returned %d schemas, want 3", len(schemas))
}
// Verify both providers' tools are present
names := make(map[string]bool)
for _, s := range schemas {
names[s.Name] = true
}
if !names["builtin_tool"] {
t.Error("missing builtin_tool in merged schemas")
}
if !names["ext_tool_1"] {
t.Error("missing ext_tool_1 in merged schemas")
}
if !names["ext_tool_2"] {
t.Error("missing ext_tool_2 in merged schemas")
}
// Verify injected handlers are present (Finding 2 fix)
for _, s := range schemas {
if s.Handler == nil {
t.Errorf("ToolEntry %q has nil Handler — GetToolSchemas must inject handlers", s.Name)
}
}
}
func TestManager_GetToolSchemas_HandlersAreFunctional(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
schemas := mgr.GetToolSchemas()
if len(schemas) != 1 {
t.Fatalf("GetToolSchemas() returned %d schemas, want 1", len(schemas))
}
// Actually call the injected handler to verify the wiring works
result, err := schemas[0].Handler(context.Background(), map[string]any{"key": "val"})
if err != nil {
t.Fatalf("Handler() returned error: %v", err)
}
resultMap, ok := result.(map[string]any)
if !ok {
t.Fatalf("Handler() result is %T, want map[string]any", result)
}
if resultMap["provider"] != "builtin" {
t.Errorf("result provider = %q, want %q", resultMap["provider"], "builtin")
}
// Verify the mock's HandleToolCall was called through the injected handler
builtin.mu.Lock()
if builtin.handleToolCallCalls != 1 {
t.Errorf("HandleToolCall called %d times via injected handler, want 1", builtin.handleToolCallCalls)
}
builtin.mu.Unlock()
}
func TestManager_GetToolSchemas_EmptyProviders(t *testing.T) {
mgr, err := NewManager(nil, nil)
if err != nil {
t.Fatalf("NewManager(nil, nil) returned error: %v", err)
}
schemas := mgr.GetToolSchemas()
if schemas == nil {
t.Error("GetToolSchemas() returned nil, want empty slice")
}
if len(schemas) != 0 {
t.Errorf("GetToolSchemas() returned %d schemas, want 0", len(schemas))
}
}
func TestManager_GetToolSchemas_UnavailableProviderExcluded(t *testing.T) {
builtin := newMockProvider("builtin")
ext := newMockProvider("external")
ext.availableVal = false // external provider is unavailable
mgr, err := NewManager(builtin, ext)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
schemas := mgr.GetToolSchemas()
if len(schemas) != 1 {
t.Fatalf("GetToolSchemas() returned %d schemas, want 1 (only builtin)", len(schemas))
}
if schemas[0].Name != "builtin_tool" {
t.Errorf("got tool %q, want builtin_tool", schemas[0].Name)
}
}
func TestManager_HandleToolCall_RoutesToCorrectProvider(t *testing.T) {
builtin := newMockProvider("builtin")
ext := newMockProvider("external")
ext.toolSchemasVal = []tools.ToolEntry{
{Name: "ext_tool", Description: "External tool"},
}
mgr, err := NewManager(builtin, ext)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
// Call a tool that belongs to the external provider
result, err := mgr.HandleToolCall("ext_tool", map[string]any{"key": "value"})
if err != nil {
t.Fatalf("HandleToolCall() returned error: %v", err)
}
resultMap, ok := result.(map[string]any)
if !ok {
t.Fatalf("HandleToolCall() result is %T, want map[string]any", result)
}
if resultMap["provider"] != "external" {
t.Errorf("result provider = %q, want %q", resultMap["provider"], "external")
}
// Verify the external provider received the call
ext.mu.Lock()
defer ext.mu.Unlock()
if ext.handleToolCallCalls != 1 {
t.Errorf("external HandleToolCall called %d times, want 1", ext.handleToolCallCalls)
}
if ext.lastToolName != "ext_tool" {
t.Errorf("last tool name = %q, want %q", ext.lastToolName, "ext_tool")
}
}
func TestManager_HandleToolCall_BuiltinRouting(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
_, err = mgr.HandleToolCall("builtin_tool", map[string]any{})
if err != nil {
t.Fatalf("HandleToolCall() returned error: %v", err)
}
builtin.mu.Lock()
defer builtin.mu.Unlock()
if builtin.handleToolCallCalls != 1 {
t.Errorf("builtin HandleToolCall called %d times, want 1", builtin.handleToolCallCalls)
}
}
func TestManager_HandleToolCall_UnknownTool(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
_, err = mgr.HandleToolCall("nonexistent_tool", nil)
if err == nil {
t.Fatal("expected error for unknown tool, got nil")
}
if !errors.Is(err, ErrToolNotFound) {
t.Errorf("expected ErrToolNotFound, got: %v", err)
}
}
func TestManager_HandleToolCall_ProviderDoesNotImplementToolCall(t *testing.T) {
// Create a minimal provider that only implements MemoryProvider (not ToolCallProvider)
minimal := &minimalProvider{nameVal: "minimal", availableVal: true}
mgr, err := NewManager(nil, minimal)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
_, err = mgr.HandleToolCall("minimal_tool", nil)
if err == nil {
t.Fatal("expected error when provider doesn't implement ToolCallProvider, got nil")
}
}
func TestManager_TypeAssertions_DetectsOptionalInterfaces(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
// The mock implements everything — verify the manager detects this
if !mgr.HasSystemPrompt() {
t.Error("HasSystemPrompt() = false, want true")
}
if !mgr.HasPrefetch() {
t.Error("HasPrefetch() = false, want true")
}
if !mgr.HasSyncTurn() {
t.Error("HasSyncTurn() = false, want true")
}
if !mgr.HasShutdown() {
t.Error("HasShutdown() = false, want true")
}
}
func TestManager_TypeAssertions_NoOptionalInterfaces(t *testing.T) {
minimal := &minimalProvider{nameVal: "minimal", availableVal: true}
mgr, err := NewManager(minimal, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
if mgr.HasSystemPrompt() {
t.Error("HasSystemPrompt() = true, want false for minimal provider")
}
if mgr.HasPrefetch() {
t.Error("HasPrefetch() = true, want false for minimal provider")
}
if mgr.HasSyncTurn() {
t.Error("HasSyncTurn() = true, want false for minimal provider")
}
if mgr.HasShutdown() {
t.Error("HasShutdown() = true, want false for minimal provider")
}
}
// waitForHooks waits for all hook goroutines to complete. Mock hook methods
// finish in nanoseconds (lock + increment + unlock + channel send), so a brief
// sleep is more than sufficient for the scheduler to dispatch them. Using a
// buffered channel of size 50 ensures no goroutine blocks on send even under
// extreme load.
func waitForHooks(t *testing.T, expected int, providers ...*mockProvider) {
t.Helper()
// Poll-and-sleep: drain what we can non-blocking, then sleep briefly
// for stragglers. This avoids the flakiness of a single time.Sleep
// while being simpler than reflect.Select multiplexing.
deadline := time.Now().Add(5 * time.Second)
received := 0
for received < expected && time.Now().Before(deadline) {
drained := false
for _, p := range providers {
select {
case <-p.hookDone:
received++
drained = true
default:
}
if drained {
break
}
}
if !drained {
time.Sleep(time.Millisecond)
}
}
if received < expected {
t.Errorf("timed out waiting for hooks: got %d/%d signals", received, expected)
}
}
func TestManager_LifecycleHooks_AllCalled(t *testing.T) {
builtin := newMockProvider("builtin")
ext := newMockProvider("external")
mgr, err := NewManager(builtin, ext)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
sessionID := "session-123"
newSessionID := "session-456"
// Call all lifecycle hooks through the manager
mgr.OnTurnStart(sessionID)
mgr.OnSessionEnd(sessionID)
mgr.OnSessionSwitch(sessionID, newSessionID)
mgr.OnPreCompress(sessionID)
mgr.OnMemoryWrite(sessionID, "test content")
mgr.OnDelegation(sessionID)
// Wait for all 12 goroutines (6 hooks × 2 providers) to complete
waitForHooks(t, 12, builtin, ext)
// Verify builtin received all hook calls
builtin.mu.Lock()
if builtin.turnStartCalls != 1 {
t.Errorf("builtin turnStartCalls = %d, want 1", builtin.turnStartCalls)
}
if builtin.sessionEndCalls != 1 {
t.Errorf("builtin sessionEndCalls = %d, want 1", builtin.sessionEndCalls)
}
if builtin.sessionSwitchCalls != 1 {
t.Errorf("builtin sessionSwitchCalls = %d, want 1", builtin.sessionSwitchCalls)
}
if builtin.preCompressCalls != 1 {
t.Errorf("builtin preCompressCalls = %d, want 1", builtin.preCompressCalls)
}
if builtin.memoryWriteCalls != 1 {
t.Errorf("builtin memoryWriteCalls = %d, want 1", builtin.memoryWriteCalls)
}
if builtin.delegationCalls != 1 {
t.Errorf("builtin delegationCalls = %d, want 1", builtin.delegationCalls)
}
builtin.mu.Unlock()
// Verify external received ALL hook calls (Finding 10 fix)
ext.mu.Lock()
if ext.turnStartCalls != 1 {
t.Errorf("external turnStartCalls = %d, want 1", ext.turnStartCalls)
}
if ext.sessionEndCalls != 1 {
t.Errorf("external sessionEndCalls = %d, want 1", ext.sessionEndCalls)
}
if ext.sessionSwitchCalls != 1 {
t.Errorf("external sessionSwitchCalls = %d, want 1", ext.sessionSwitchCalls)
}
if ext.preCompressCalls != 1 {
t.Errorf("external preCompressCalls = %d, want 1", ext.preCompressCalls)
}
if ext.memoryWriteCalls != 1 {
t.Errorf("external memoryWriteCalls = %d, want 1", ext.memoryWriteCalls)
}
if ext.delegationCalls != 1 {
t.Errorf("external delegationCalls = %d, want 1", ext.delegationCalls)
}
ext.mu.Unlock()
}
func TestManager_LifecycleHooks_MinimalProvider(t *testing.T) {
// Minimal providers that don't implement hooks should not panic
minimal := &minimalProvider{nameVal: "minimal", availableVal: true}
mgr, err := NewManager(minimal, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
// These should not panic even though the provider doesn't implement hooks
mgr.OnTurnStart("s1")
mgr.OnSessionEnd("s1")
mgr.OnSessionSwitch("s1", "s2")
mgr.OnPreCompress("s1")
mgr.OnMemoryWrite("s1", "content")
mgr.OnDelegation("s1")
}
func TestManager_LifecycleHooks_PanicRecovery(t *testing.T) {
// A provider whose hook panics should not crash the test process
panicky := &panickyProvider{nameVal: "panicky", availableVal: true}
mgr, err := NewManager(panicky, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
// These must not panic the test
mgr.OnTurnStart("s1")
mgr.OnSessionEnd("s1")
mgr.OnSessionSwitch("s1", "s2")
mgr.OnPreCompress("s1")
mgr.OnMemoryWrite("s1", "content")
mgr.OnDelegation("s1")
// If we reached here without panicking, the recovery works
}
func TestManager_Shutdown(t *testing.T) {
builtin := newMockProvider("builtin")
ext := newMockProvider("external")
mgr, err := NewManager(builtin, ext)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
if err := mgr.Shutdown(); err != nil {
t.Fatalf("Shutdown() returned error: %v", err)
}
builtin.mu.Lock()
if builtin.shutdownCalls != 1 {
t.Errorf("builtin shutdownCalls = %d, want 1", builtin.shutdownCalls)
}
builtin.mu.Unlock()
ext.mu.Lock()
if ext.shutdownCalls != 1 {
t.Errorf("external shutdownCalls = %d, want 1", ext.shutdownCalls)
}
ext.mu.Unlock()
}
func TestManager_Shutdown_NoShutdownProviders(t *testing.T) {
minimal := &minimalProvider{nameVal: "minimal", availableVal: true}
mgr, err := NewManager(minimal, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
// Should not panic or error
if err := mgr.Shutdown(); err != nil {
t.Fatalf("Shutdown() returned error: %v", err)
}
}
func TestManager_Shutdown_UnavailableProviderStillShutDown(t *testing.T) {
// Finding 7 fix: shutdown must include providers even if IsAvailable() == false
builtin := newMockProvider("builtin")
builtin.availableVal = false // unavailable but still holding resources
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
if err := mgr.Shutdown(); err != nil {
t.Fatalf("Shutdown() returned error: %v", err)
}
builtin.mu.Lock()
if builtin.shutdownCalls != 1 {
t.Errorf("unavailable provider shutdown was NOT called (shutdownCalls=%d), want 1 — resources may leak",
builtin.shutdownCalls)
}
builtin.mu.Unlock()
}
func TestManager_GetConfigSchema_Aggregates(t *testing.T) {
builtin := newMockProvider("builtin")
ext := newMockProvider("external")
mgr, err := NewManager(builtin, ext)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
schemas := mgr.GetConfigSchemas()
if len(schemas) != 2 {
t.Fatalf("GetConfigSchemas() returned %d schemas, want 2", len(schemas))
}
if _, ok := schemas["builtin"]; !ok {
t.Error("missing builtin in config schemas")
}
if _, ok := schemas["external"]; !ok {
t.Error("missing external in config schemas")
}
}
func TestManager_SaveConfig(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
values := map[string]any{"key": "value"}
if err := mgr.SaveConfig("builtin", values, "/tmp/hermes"); err != nil {
t.Fatalf("SaveConfig() returned error: %v", err)
}
builtin.mu.Lock()
if builtin.saveConfigCalls != 1 {
t.Errorf("saveConfigCalls = %d, want 1", builtin.saveConfigCalls)
}
builtin.mu.Unlock()
}
func TestManager_SaveConfig_UnknownProvider(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
err = mgr.SaveConfig("nonexistent", map[string]any{}, "/tmp/hermes")
if err == nil {
t.Fatal("expected error for unknown provider, got nil")
}
}
func TestManager_SaveConfig_ProviderLacksSaveConfig(t *testing.T) {
minimal := &minimalProvider{nameVal: "minimal", availableVal: true}
mgr, err := NewManager(minimal, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
err = mgr.SaveConfig("minimal", map[string]any{}, "/tmp/hermes")
if err == nil {
t.Fatal("expected error when provider lacks SaveConfigProvider, got nil")
}
}
func TestManager_BackupPaths_Aggregates(t *testing.T) {
builtin := newMockProvider("builtin")
ext := newMockProvider("external")
mgr, err := NewManager(builtin, ext)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
paths := mgr.BackupPaths()
if len(paths) != 2 {
t.Fatalf("BackupPaths() returned %d paths, want 2", len(paths))
}
}
func TestManager_BackupPaths_NoBackupProviders(t *testing.T) {
minimal := &minimalProvider{nameVal: "minimal", availableVal: true}
mgr, err := NewManager(minimal, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
paths := mgr.BackupPaths()
if paths == nil {
t.Error("BackupPaths() returned nil, want empty slice")
}
if len(paths) != 0 {
t.Errorf("BackupPaths() returned %d paths, want 0", len(paths))
}
}
func TestManager_Prefetch(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
result, err := mgr.Prefetch("test query")
if err != nil {
t.Fatalf("Prefetch() returned error: %v", err)
}
if result == "" {
t.Error("Prefetch() returned empty result")
}
}
func TestManager_QueuePrefetch(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
if err := mgr.QueuePrefetch("background query"); err != nil {
t.Fatalf("QueuePrefetch() returned error: %v", err)
}
builtin.mu.Lock()
if builtin.queuePrefetchCalls != 1 {
t.Errorf("queuePrefetchCalls = %d, want 1", builtin.queuePrefetchCalls)
}
builtin.mu.Unlock()
}
func TestManager_SyncTurn(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
if err := mgr.SyncTurn("user msg", "assistant msg"); err != nil {
t.Fatalf("SyncTurn() returned error: %v", err)
}
builtin.mu.Lock()
if builtin.syncTurnCalls != 1 {
t.Errorf("syncTurnCalls = %d, want 1", builtin.syncTurnCalls)
}
builtin.mu.Unlock()
}
func TestManager_SystemPromptBlock(t *testing.T) {
builtin := newMockProvider("builtin")
mgr, err := NewManager(builtin, nil)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
block := mgr.SystemPromptBlock()
if block == "" {
t.Error("SystemPromptBlock() returned empty string")
}
}
func TestManager_Initialize(t *testing.T) {
builtin := newMockProvider("builtin")
ext := newMockProvider("external")
mgr, err := NewManager(builtin, ext)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
if err := mgr.Initialize("session-42"); err != nil {
t.Fatalf("Initialize() returned error: %v", err)
}
builtin.mu.Lock()
if builtin.initCalls != 1 {
t.Errorf("builtin initCalls = %d, want 1", builtin.initCalls)
}
if builtin.lastSessionID != "session-42" {
t.Errorf("builtin sessionID = %q, want %q", builtin.lastSessionID, "session-42")
}
builtin.mu.Unlock()
ext.mu.Lock()
if ext.initCalls != 1 {
t.Errorf("external initCalls = %d, want 1", ext.initCalls)
}
ext.mu.Unlock()
}
func TestManager_DuplicateToolNames_FirstWins(t *testing.T) {
// Finding 8 fix: duplicate tool names should be deterministic (first wins)
builtin := newMockProvider("builtin")
builtin.toolSchemasVal = []tools.ToolEntry{
{Name: "shared_tool", Description: "Builtin version"},
}
ext := newMockProvider("external")
ext.toolSchemasVal = []tools.ToolEntry{
{Name: "shared_tool", Description: "External version"},
}
mgr, err := NewManager(builtin, ext)
if err != nil {
t.Fatalf("NewManager returned error: %v", err)
}
// HandleToolCall should route to builtin (first wins)
result, err := mgr.HandleToolCall("shared_tool", nil)
if err != nil {
t.Fatalf("HandleToolCall() returned error: %v", err)
}
resultMap, ok := result.(map[string]any)
if !ok {
t.Fatalf("HandleToolCall() result is %T, want map[string]any", result)
}
if resultMap["provider"] != "builtin" {
t.Errorf("duplicate tool routed to %q, want %q (first-wins)", resultMap["provider"], "builtin")
}
}
// ── minimalProvider ─────────────────────────────────────────────────────
//
// A provider that only implements the required MemoryProvider interface.
// Used to test graceful nil/empty handling for optional interfaces.
type minimalProvider struct {
nameVal string
availableVal bool
}
func (p *minimalProvider) Name() string { return p.nameVal }
func (p *minimalProvider) IsAvailable() bool { return p.availableVal }
func (p *minimalProvider) Initialize(sessionID string) error { return nil }
func (p *minimalProvider) GetToolSchemas() []tools.ToolEntry {
return []tools.ToolEntry{
{Name: p.nameVal + "_tool", Description: "Minimal tool for " + p.nameVal},
}
}
var _ MemoryProvider = (*minimalProvider)(nil)
// ── panickyProvider ─────────────────────────────────────────────────────
//
// A provider whose hook methods panic. Used to verify that safeGo recovery
// prevents hook panics from crashing the process (Finding 1 fix).
type panickyProvider struct {
nameVal string
availableVal bool
}
func (p *panickyProvider) Name() string { return p.nameVal }
func (p *panickyProvider) IsAvailable() bool { return p.availableVal }
func (p *panickyProvider) Initialize(sessionID string) error { return nil }
func (p *panickyProvider) GetToolSchemas() []tools.ToolEntry {
return []tools.ToolEntry{
{Name: p.nameVal + "_tool", Description: "Panicky tool"},
}
}
// Every hook panics — safeGo must recover each one.
func (p *panickyProvider) OnTurnStart(sessionID string) error {
panic("OnTurnStart panicked")
}
func (p *panickyProvider) OnSessionEnd(sessionID string) error {
panic("OnSessionEnd panicked")
}
func (p *panickyProvider) OnSessionSwitch(oldSessionID, newSessionID string) error {
panic("OnSessionSwitch panicked")
}
func (p *panickyProvider) OnPreCompress(sessionID string) error {
panic("OnPreCompress panicked")
}
func (p *panickyProvider) OnMemoryWrite(sessionID string, content string) error {
panic("OnMemoryWrite panicked")
}
func (p *panickyProvider) OnDelegation(sessionID string) error {
panic("OnDelegation panicked")
}
var _ MemoryProvider = (*panickyProvider)(nil)
var _ TurnStartHook = (*panickyProvider)(nil)
var _ SessionEndHook = (*panickyProvider)(nil)
var _ SessionSwitchHook = (*panickyProvider)(nil)
var _ PreCompressHook = (*panickyProvider)(nil)
var _ MemoryWriteHook = (*panickyProvider)(nil)
var _ DelegationHook = (*panickyProvider)(nil)