Files
archie/internal/gateway/session_tools_test.go
T

369 lines
12 KiB
Go

package gateway
import (
"context"
"fmt"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/tools"
)
// seedSessionAt persists one session directly, bypassing the tracker, with an
// explicit recency time so ordering tests are deterministic. Source fields are
// fixed so GetByChannel and List behave deterministically.
func seedSessionAt(store SessionStore, id, title string, at time.Time) SessionContext {
sc := SessionContext{
SessionID: id,
Source: SessionSource{
Platform: "test-gw",
BotUser: "archie",
ChannelID: "chat-1",
},
Title: title,
CreatedAt: at,
LastActiveAt: at,
}
_ = store.Save(context.Background(), sc)
return sc
}
// sessionTool pulls one entry out of the session tool set.
func sessionTool(t *testing.T, entries []tools.ToolEntry, name string) tools.ToolEntry {
t.Helper()
for _, e := range entries {
if e.Name == name {
return e
}
}
t.Fatalf("SessionTools() has no %q entry", name)
return tools.ToolEntry{}
}
func TestSessionToolListReturnsSessions(t *testing.T) {
store := newFakeSessionStore()
tr := newSessionTracker(store)
entry := sessionTool(t, SessionTools(store, tr, "test-gw", inbound("chat-1", "").Message), "session_list")
now := time.Now()
seedSessionAt(store, "sess-1", "one", now.Add(-3*time.Hour))
seedSessionAt(store, "sess-2", "two", now.Add(-2*time.Hour))
seedSessionAt(store, "sess-3", "", now.Add(-time.Hour))
out, err := entry.Handler(context.Background(), map[string]any{})
if err != nil {
t.Fatalf("handler: %v", err)
}
result, ok := out.(SessionListResult)
if !ok {
t.Fatalf("handler returned %T, want SessionListResult", out)
}
if len(result.Sessions) != 3 {
t.Fatalf("got %d sessions, want 3", len(result.Sessions))
}
// Newest first, per the tool contract.
if got := result.Sessions[0].ID; got != "sess-3" {
t.Errorf("first session = %q, want the newest (sess-3)", got)
}
seen := make(map[string]bool, len(result.Sessions))
for _, s := range result.Sessions {
seen[s.ID] = true
}
for _, id := range []string{"sess-1", "sess-2", "sess-3"} {
if !seen[id] {
t.Errorf("session %q missing from list", id)
}
}
}
func TestSessionToolListRespectsLimit(t *testing.T) {
store := newFakeSessionStore()
tr := newSessionTracker(store)
entry := sessionTool(t, SessionTools(store, tr, "test-gw", inbound("chat-1", "").Message), "session_list")
now := time.Now()
for i := range 5 {
seedSessionAt(store, fmt.Sprintf("sess-%d", i), "", now.Add(time.Duration(i)*time.Hour))
}
out, err := entry.Handler(context.Background(), map[string]any{"limit": float64(2)})
if err != nil {
t.Fatalf("handler: %v", err)
}
result, ok := out.(SessionListResult)
if !ok {
t.Fatalf("handler returned %T, want SessionListResult", out)
}
if len(result.Sessions) != 2 {
t.Fatalf("got %d sessions, want 2", len(result.Sessions))
}
// The two newest are kept, in order.
if got := result.Sessions[0].ID; got != "sess-4" {
t.Errorf("first = %q, want the newest sess-4", got)
}
if got := result.Sessions[1].ID; got != "sess-3" {
t.Errorf("second = %q, want sess-3", got)
}
}
func TestSessionToolResumeSwitchesActive(t *testing.T) {
store := newFakeSessionStore()
tr := newSessionTracker(store)
msg := Inbound{Message: messaging.Message{ConversationID: messaging.ConversationID{ChannelID: "chat-1", ThreadID: "thread-9"}, Role: messaging.RoleUser}}
entry := sessionTool(t, SessionTools(store, tr, "test-gw", msg.Message), "session_resume")
target := "resume-target"
seedSessionAt(store, target, "target session", time.Now())
// Start somewhere else so the switch is observable.
tr.setActive("chat-1", "thread-9", "other-session")
out, err := entry.Handler(context.Background(), map[string]any{"session_id": target})
if err != nil {
t.Fatalf("handler: %v", err)
}
result, ok := out.(SessionResumeResult)
if !ok {
t.Fatalf("handler returned %T, want SessionResumeResult", out)
}
if result.SessionID != target {
t.Errorf("session_id = %q, want %q", result.SessionID, target)
}
// The channel+thread come from the message captured at construction.
if got := tr.getActive("chat-1", "thread-9"); got != target {
t.Errorf("active = %q, want %q", got, target)
}
}
func TestSessionToolResumeRejectsUnknown(t *testing.T) {
store := newFakeSessionStore()
tr := newSessionTracker(store)
entry := sessionTool(t, SessionTools(store, tr, "test-gw", inbound("chat-1", "").Message), "session_resume")
_, err := entry.Handler(context.Background(), map[string]any{"session_id": "does-not-exist"})
if err == nil {
t.Fatal("handler error = nil, want a refusal")
}
if !strings.Contains(err.Error(), "no session matching") {
t.Errorf("error = %q, want a 'no session matching' refusal", err)
}
}
func TestSessionToolTitleSetsTitle(t *testing.T) {
store := newFakeSessionStore()
tr := newSessionTracker(store)
entry := sessionTool(t, SessionTools(store, tr, "test-gw", inbound("chat-1", "").Message), "session_title")
target := "title-target"
seedSessionAt(store, target, "old title", time.Now())
if _, err := entry.Handler(context.Background(), map[string]any{
"session_id": target,
"title": "new title",
}); err != nil {
t.Fatalf("handler: %v", err)
}
sc, err := store.Get(context.Background(), target)
if err != nil {
t.Fatalf("Get: %v", err)
}
if sc == nil {
t.Fatal("session not found")
}
if sc.Title != "new title" {
t.Errorf("stored title = %q, want %q", sc.Title, "new title")
}
}
func TestSessionToolTitleReportsPrevious(t *testing.T) {
store := newFakeSessionStore()
tr := newSessionTracker(store)
entry := sessionTool(t, SessionTools(store, tr, "test-gw", inbound("chat-1", "").Message), "session_title")
target := "title-prev"
seedSessionAt(store, target, "before", time.Now())
out, err := entry.Handler(context.Background(), map[string]any{
"session_id": target,
"title": "after",
})
if err != nil {
t.Fatalf("handler: %v", err)
}
result, ok := out.(SessionTitleResult)
if !ok {
t.Fatalf("handler returned %T, want SessionTitleResult", out)
}
if result.PreviousTitle != "before" {
t.Errorf("previous_title = %q, want %q", result.PreviousTitle, "before")
}
if result.Title != "after" {
t.Errorf("title = %q, want %q", result.Title, "after")
}
}
func TestSessionToolDeleteRemovesSession(t *testing.T) {
store := newFakeSessionStore()
tr := newSessionTracker(store)
entry := sessionTool(t, SessionTools(store, tr, "test-gw", inbound("chat-1", "").Message), "session_delete")
target := "delete-target"
seedSessionAt(store, target, "doomed", time.Now())
out, err := entry.Handler(context.Background(), map[string]any{"session_id": target})
if err != nil {
t.Fatalf("handler: %v", err)
}
result, ok := out.(SessionDeleteResult)
if !ok {
t.Fatalf("handler returned %T, want SessionDeleteResult", out)
}
if result.SessionID != target {
t.Errorf("session_id = %q, want %q", result.SessionID, target)
}
sc, err := store.Get(context.Background(), target)
if err != nil {
t.Fatalf("Get: %v", err)
}
if sc != nil {
t.Error("session still present after delete")
}
}
func TestSessionToolDeleteClearsTracker(t *testing.T) {
store := newFakeSessionStore()
tr := newSessionTracker(store)
entry := sessionTool(t, SessionTools(store, tr, "test-gw", inbound("chat-1", "").Message), "session_delete")
target := "delete-active"
seedSessionAt(store, target, "active", time.Now())
// Active under a flat key and a thread key; forget must sweep both.
tr.setActive("chat-1", "", target)
tr.setActive("chat-1", "thread-2", target)
if _, err := entry.Handler(context.Background(), map[string]any{"session_id": target}); err != nil {
t.Fatalf("handler: %v", err)
}
if got := tr.getActive("chat-1", ""); got != "" {
t.Errorf("flat active = %q, want empty", got)
}
if got := tr.getActive("chat-1", "thread-2"); got != "" {
t.Errorf("thread active = %q, want empty", got)
}
}
func TestSessionToolClassifications(t *testing.T) {
store := newFakeSessionStore()
tr := newSessionTracker(store)
entries := SessionTools(store, tr, "test-gw", inbound("chat-1", "").Message)
if len(entries) != 5 {
t.Fatalf("got %d tools, want 5", len(entries))
}
tests := []struct {
name string
idempotent bool
mutating bool
approval bool
}{
{name: "session_list", idempotent: true},
{name: "session_transcript", idempotent: true},
{name: "session_resume", mutating: true},
{name: "session_title", mutating: true},
{name: "session_delete", mutating: true, approval: true},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
e := sessionTool(t, entries, tc.name)
if e.Toolset != "session" {
t.Errorf("toolset = %q, want %q", e.Toolset, "session")
}
if got := e.Classification.IsIdempotent(); got != tc.idempotent {
t.Errorf("idempotent = %v, want %v", got, tc.idempotent)
}
if got := e.Classification.IsMutating(); got != tc.mutating {
t.Errorf("mutating = %v, want %v", got, tc.mutating)
}
if got := e.Classification.IsApprovalRequired(); got != tc.approval {
t.Errorf("requires_approval = %v, want %v", got, tc.approval)
}
})
}
}
func TestSessionToolNilStoreOmitsTools(t *testing.T) {
if entries := SessionTools(nil, nil, "test-gw", inbound("chat-1", "").Message); len(entries) != 0 {
t.Errorf("SessionTools(nil, ...) = %d entries, want 0", len(entries))
}
}
// TestSessionToolNilTrackerOmitsTrackerTools checks that a tracker-dependent
// tool is not advertised when no tracker is wired, matching the TaskTools rule
// that a nil backend omits its tool rather than registering one that always
// fails.
func TestSessionToolNilTrackerOmitsTrackerTools(t *testing.T) {
store := newFakeSessionStore()
entries := SessionTools(store, nil, "test-gw", inbound("chat-1", "").Message)
var names []string
for _, e := range entries {
names = append(names, e.Name)
}
if len(entries) != 3 {
t.Fatalf("got %d tools (%v), want the 3 store-only tools", len(entries), names)
}
for _, name := range names {
switch name {
case "session_resume", "session_delete":
t.Errorf("%q needs the tracker and must not be advertised without one", name)
}
}
}
func TestSessionToolTranscriptExportsSession(t *testing.T) {
store := newFakeSessionStore()
tr := newSessionTracker(store)
entry := sessionTool(t, SessionTools(store, tr, "test-gw", inbound("chat-1", "").Message), "session_transcript")
seedSessionAt(store, "transcript-target", "target session", time.Now())
// Add some messages
now := time.Now()
for i := range 5 {
msg := messaging.Message{
ID: messaging.MessageID(fmt.Sprintf("msg-%d", i)),
ConversationID: messaging.ConversationID{ChannelID: "chat-1", ThreadID: "thread-1"},
SourceID: fmt.Sprintf("src-%d", i),
Role: messaging.RoleUser,
Text: fmt.Sprintf("User message %d", i),
At: now.Add(time.Duration(i) * time.Minute),
}
if err := store.SaveMessage(context.Background(), "transcript-target", msg); err != nil {
t.Fatalf("SaveMessage: %v", err)
}
}
out, err := entry.Handler(context.Background(), map[string]any{"session_id": "transcript-target"})
if err != nil {
t.Fatalf("handler: %v", err)
}
result, ok := out.(sessionTranscriptResult)
if !ok {
t.Fatalf("handler returned %T, want sessionTranscriptResult", out)
}
if result.SessionID != "transcript-target" {
t.Errorf("session_id = %q, want transcript-target", result.SessionID)
}
if result.MessageCount != 5 {
t.Errorf("message_count = %d, want 5", result.MessageCount)
}
if result.SizeBytes <= 0 {
t.Errorf("size_bytes = %d, want > 0", result.SizeBytes)
}
if result.FilePath == "" {
t.Error("file_path is empty")
}
}