Files
archie/internal/gateway/turn_test.go
T
sam 7c8f625f0e feat(gateway): flip channel boundary onto messaging.Message
Replaced gateway.Message as the currency at the channel-facing boundary
with the canonical internal/domain/messaging.Message. Channel adapters
now build the record directly (RoleUser, ConversationID, Sender) and the
Router hands it back unchanged, so nothing converts between two shapes in
process. gateway.Message is deleted; the dashboard route that had no home
in the record lives in a new Inbound envelope (Message + transport-only
Page), which reaches the system prompt and is never persisted.

Role is now set at construction instead of derived at the store boundary,
and the assistant reply is a direct messaging.Message (RoleAssistant,
Sender=botUser). The gRPC proto is unchanged: pb.Message still carries no
role, and both sides keep deriving it from the owning session's bot
identity via gateway.RoleForSender (ToStoredMessage/FromStoredMessage are
deleted).

Adds tests that the old shape could not express: Page reaches the system
prompt but not the persisted record, and a channel-built Inbound round-trips
with the Role the channel set.

Refs: archie-core-9g5e
2026-09-09 01:05:36 +10:00

359 lines
13 KiB
Go

package gateway
import (
"context"
"errors"
"fmt"
"log/slog"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/tools"
)
type turnTestModel struct {
prepared *turnTestPreparedModel
prepareErr error
gotExtra []tools.ToolEntry
}
func (m *turnTestModel) Prepare(_ context.Context, req TurnPrepareContext) (PreparedTurnModel, error) {
m.gotExtra = append([]tools.ToolEntry(nil), req.Extra...)
if m.prepareErr != nil {
return nil, m.prepareErr
}
return m.prepared, nil
}
type turnTestPreparedModel struct {
reply string
toolInfo []ToolSummary
toolTokens int
generateN int
generateErr error
generate func(context.Context) (string, error)
// generateStream lets a test drive the reported progress -- text and
// tool activity -- rather than only the returned reply.
generateStream func(TurnStream) (string, error)
lastRequest TurnModelRequest
}
func (m *turnTestPreparedModel) ToolSummaries() []ToolSummary {
return append([]ToolSummary(nil), m.toolInfo...)
}
func (m *turnTestPreparedModel) ToolSchemaTokens() int {
return m.toolTokens
}
func (m *turnTestPreparedModel) Generate(ctx context.Context, req TurnModelRequest, stream TurnStream) (string, error) {
m.generateN++
m.lastRequest = req
if m.generateStream != nil {
return m.generateStream(stream)
}
if m.generate != nil {
return m.generate(ctx)
}
if m.generateErr != nil {
return "", m.generateErr
}
if stream != nil {
stream.Delta(m.reply)
}
return m.reply, nil
}
type turnTestEvents struct {
published []events.Event
}
func (b *turnTestEvents) Publish(event events.Event) {
b.published = append(b.published, event)
}
func TestTurnRunnerPersistsOneTurnAndPublishesCompletion(t *testing.T) {
store := NewSessionStoreMemory()
router := NewRouter(nil, nil, "telegram")
router.Identity = "archie"
router.InitSessions(store)
prepared := &turnTestPreparedModel{
reply: "answer",
toolInfo: []ToolSummary{{Name: "turn_tool", Description: "test tool"}},
toolTokens: 12,
}
model := &turnTestModel{prepared: prepared}
eventsBus := &turnTestEvents{}
runner := NewTurnRunner(TurnRunnerConfig{
Router: router,
Sessions: store,
Models: &fakeModelManager{models: []string{"test/model"}, activeModel: "test/model"},
Personas: NewPersonaRegistry(DefaultPersonas()),
Model: model,
Bus: eventsBus,
BotUser: "archie",
Channel: "telegram",
Operator: "Sam",
Log: slog.New(slog.DiscardHandler),
})
var streamed string
reply, err := runner.Run(context.Background(), Inbound{Message: messaging.Message{SourceID: "source-1", ConversationID: messaging.ConversationID{ChannelID: "chat-1"}, Sender: "user", Role: messaging.RoleUser, Text: "hello"}}, DeltaFunc(func(delta string) { streamed += delta }))
if err != nil {
t.Fatalf("Run() error = %v", err)
}
if reply != "answer" || streamed != "answer" {
t.Fatalf("reply = %q, streamed = %q", reply, streamed)
}
history, err := store.RecentMessages(context.Background(), "chat-1", 10)
if err != nil {
t.Fatalf("RecentMessages() error = %v", err)
}
if len(history) != 2 {
t.Fatalf("history length = %d, want 2", len(history))
}
if history[0].Text != "hello" || history[1].Text != "answer" {
t.Fatalf("history = %#v, want inbound then assistant", history)
}
if prepared.generateN != 1 {
t.Fatalf("Generate calls = %d, want 1", prepared.generateN)
}
if len(model.gotExtra) == 0 {
t.Fatal("Prepare received no session tools")
}
if len(prepared.lastRequest.Messages) < 2 || prepared.lastRequest.Messages[0].Role != "system" {
t.Fatalf("model request messages = %#v, want system prompt and history", prepared.lastRequest.Messages)
}
if len(eventsBus.published) != 1 || eventsBus.published[0].Kind != events.KindTurnCompleted {
t.Fatalf("published events = %#v, want one turn_completed event", eventsBus.published)
}
turn, ok, err := runner.Ledger.GetTurn(context.Background(), CanonicalTurnID("chat-1", "source-1"))
if err != nil || !ok {
t.Fatalf("GetTurn() = %#v, %v, %v; want completed turn", turn, ok, err)
}
if turn.Status != TurnStatusCompleted || turn.ResponseText != "answer" || turn.InputMessageID == "" || turn.AssistantMessageID == "" {
t.Fatalf("persisted turn = %#v, want completed IDs and response", turn)
}
}
func TestTurnRunnerGenerationFailureLeavesInboundWithoutReply(t *testing.T) {
store := NewSessionStoreMemory()
router := NewRouter(nil, nil, "telegram")
router.Identity = "archie"
router.InitSessions(store)
prepared := &turnTestPreparedModel{generateErr: errors.New("provider unavailable")}
bus := &turnTestEvents{}
runner := NewTurnRunner(TurnRunnerConfig{
Router: router,
Sessions: store,
Models: &fakeModelManager{models: []string{"test/model"}, activeModel: "test/model"},
Personas: NewPersonaRegistry(DefaultPersonas()),
Model: &turnTestModel{prepared: prepared},
Bus: bus,
BotUser: "archie",
Channel: "telegram",
})
_, err := runner.Run(context.Background(), Inbound{Message: messaging.Message{SourceID: "source-1", ConversationID: messaging.ConversationID{ChannelID: "chat-1"}, Sender: "user", Role: messaging.RoleUser, Text: "hello"}}, nil)
if err == nil || !strings.Contains(err.Error(), "provider unavailable") {
t.Fatalf("Run() error = %v, want provider error", err)
}
history, err := store.RecentMessages(context.Background(), "chat-1", 10)
if err != nil {
t.Fatalf("RecentMessages() error = %v", err)
}
if len(history) != 1 || history[0].Text != "hello" {
t.Fatalf("history after failed generation = %#v, want inbound only", history)
}
if len(bus.published) != 0 {
t.Fatalf("published events = %#v, want none", bus.published)
}
turn, ok, err := runner.Ledger.GetTurn(context.Background(), CanonicalTurnID("chat-1", "source-1"))
if err != nil || !ok || turn.Status != TurnStatusFailed || turn.Error == "" {
t.Fatalf("failed turn = %#v, %v, %v; want persisted failure", turn, ok, err)
}
}
func TestTurnRunnerCancellationPersistsCancelledState(t *testing.T) {
store := NewSessionStoreMemory()
router := NewRouter(nil, nil, "telegram")
router.Identity = "archie"
router.InitSessions(store)
runCtx, cancel := context.WithCancel(context.Background())
defer cancel()
prepared := &turnTestPreparedModel{generate: func(context.Context) (string, error) {
cancel()
return "", context.Canceled
}}
runner := NewTurnRunner(TurnRunnerConfig{
Router: router,
Sessions: store,
Models: &fakeModelManager{models: []string{"test/model"}, activeModel: "test/model"},
Personas: NewPersonaRegistry(DefaultPersonas()),
Model: &turnTestModel{prepared: prepared},
BotUser: "archie",
Channel: "telegram",
})
_, err := runner.Run(runCtx, Inbound{Message: messaging.Message{SourceID: "source-cancel", ConversationID: messaging.ConversationID{ChannelID: "chat-cancel"}, Sender: "user", Role: messaging.RoleUser, Text: "hello"}}, nil)
if !errors.Is(err, context.Canceled) {
t.Fatalf("Run() error = %v, want context.Canceled", err)
}
turn, ok, err := runner.Ledger.GetTurn(context.Background(), CanonicalTurnID("chat-cancel", "source-cancel"))
if err != nil || !ok || turn.Status != TurnStatusCancelled {
t.Fatalf("cancelled turn = %#v, %v, %v; want persisted cancellation", turn, ok, err)
}
}
func TestTurnRunnerRecoversTurnOwnedByPreviousProcess(t *testing.T) {
store := NewSessionStoreMemory()
router := NewRouter(nil, nil, "telegram")
router.Identity = "archie"
router.InitSessions(store)
turnID := CanonicalTurnID("chat-recover", "source-recover")
ledger, ok := store.(TurnLedger)
if !ok {
t.Fatalf("store is %T, want TurnLedger", store)
}
if _, claim, err := ledger.ClaimTurn(context.Background(), TurnRecord{
TurnID: turnID, SessionID: "chat-recover", SourceID: "source-recover",
OwnerID: "previous-process", Status: TurnStatusAccepted,
}); err != nil || claim != TurnClaimOwned {
t.Fatalf("seed ClaimTurn() = %q, %v", claim, err)
}
runner := NewTurnRunner(TurnRunnerConfig{
Router: router,
Sessions: store,
Models: &fakeModelManager{models: []string{"test/model"}, activeModel: "test/model"},
Personas: NewPersonaRegistry(DefaultPersonas()),
Model: &turnTestModel{prepared: &turnTestPreparedModel{reply: "recovered"}},
OwnerID: "new-process",
BotUser: "archie",
Channel: "telegram",
})
got, err := runner.Run(context.Background(), Inbound{Message: messaging.Message{SourceID: "source-recover", ConversationID: messaging.ConversationID{ChannelID: "chat-recover"}, Sender: "user", Role: messaging.RoleUser, Text: "resume me"}}, nil)
if err != nil || got != "recovered" {
t.Fatalf("Run() = %q, %v; want recovered response", got, err)
}
turn, ok, err := runner.Ledger.GetTurn(context.Background(), turnID)
if err != nil || !ok || turn.Status != TurnStatusCompleted || turn.Attempt != 2 || turn.OwnerID != "new-process" {
t.Fatalf("recovered turn = %#v, %v, %v; want attempt 2 completed by new process", turn, ok, err)
}
}
func TestTurnRunnerPreparationFailureLeavesInboundWithoutReply(t *testing.T) {
store := NewSessionStoreMemory()
router := NewRouter(nil, nil, "telegram")
router.Identity = "archie"
router.InitSessions(store)
runner := NewTurnRunner(TurnRunnerConfig{
Router: router,
Sessions: store,
Models: &fakeModelManager{models: []string{"test/model"}, activeModel: "test/model"},
Personas: NewPersonaRegistry(DefaultPersonas()),
Model: &turnTestModel{prepareErr: errors.New("tool setup failed")},
BotUser: "archie",
Channel: "telegram",
})
_, err := runner.Run(context.Background(), Inbound{Message: messaging.Message{SourceID: "source-1", ConversationID: messaging.ConversationID{ChannelID: "chat-1"}, Sender: "user", Role: messaging.RoleUser, Text: "hello"}}, nil)
if err == nil || !strings.Contains(err.Error(), "tool setup failed") {
t.Fatalf("Run() error = %v, want tool setup error", err)
}
history, err := store.RecentMessages(context.Background(), "chat-1", 10)
if err != nil {
t.Fatalf("RecentMessages() error = %v", err)
}
if len(history) != 1 || history[0].Text != "hello" {
t.Fatalf("history after failed preparation = %#v, want inbound only", history)
}
turn, ok, err := runner.Ledger.GetTurn(context.Background(), CanonicalTurnID("chat-1", "source-1"))
if err != nil || !ok || turn.Status != TurnStatusFailed || turn.Error == "" {
t.Fatalf("failed preparation turn = %#v, %v, %v; want persisted failure", turn, ok, err)
}
}
func TestTurnRunnerReplaysCompletedDuplicateOutsideRecentWindow(t *testing.T) {
store := NewSessionStoreMemory()
router := NewRouter(nil, nil, "telegram")
router.Identity = "archie"
router.InitSessions(store)
prepared := &turnTestPreparedModel{reply: "answer"}
model := &turnTestModel{prepared: prepared}
runner := NewTurnRunner(TurnRunnerConfig{
Router: router,
Sessions: store,
Models: &fakeModelManager{models: []string{"test/model"}, activeModel: "test/model"},
Personas: NewPersonaRegistry(DefaultPersonas()),
Model: model,
BotUser: "archie",
Channel: "telegram",
})
msg := Inbound{Message: messaging.Message{SourceID: "source-1", ConversationID: messaging.ConversationID{ChannelID: "chat-1"}, Sender: "user", Role: messaging.RoleUser, Text: "hello"}}
if _, err := runner.Run(context.Background(), msg, nil); err != nil {
t.Fatalf("first Run() error = %v", err)
}
for i := range 110 {
if err := store.SaveMessage(context.Background(), "chat-1", messaging.Message{SourceID: fmt.Sprintf("later-%d", i), Sender: "user", Role: messaging.RoleUser, Text: "later"}); err != nil {
t.Fatalf("SaveMessage(%d) error = %v", i, err)
}
}
reply, err := runner.Run(context.Background(), msg, nil)
if err != nil {
t.Fatalf("duplicate Run() error = %v", err)
}
if reply != "answer" {
t.Fatalf("duplicate reply = %q, want answer", reply)
}
if model.prepared.generateN != 1 {
t.Fatalf("Generate calls = %d, want 1", model.prepared.generateN)
}
}
func TestTurnRunnerReplaysCompletedDuplicateWithoutGenerating(t *testing.T) {
store := NewSessionStoreMemory()
router := NewRouter(nil, nil, "telegram")
router.Identity = "archie"
router.InitSessions(store)
prepared := &turnTestPreparedModel{reply: "answer"}
runner := NewTurnRunner(TurnRunnerConfig{
Router: router,
Sessions: store,
Models: &fakeModelManager{models: []string{"test/model"}, activeModel: "test/model"},
Personas: NewPersonaRegistry(DefaultPersonas()),
Model: &turnTestModel{prepared: prepared},
BotUser: "archie",
Channel: "telegram",
})
msg := Inbound{Message: messaging.Message{SourceID: "source-1", ConversationID: messaging.ConversationID{ChannelID: "chat-1"}, Sender: "user", Role: messaging.RoleUser, Text: "hello"}}
if _, err := runner.Run(context.Background(), msg, nil); err != nil {
t.Fatalf("first Run() error = %v", err)
}
var replay string
reply, err := runner.Run(context.Background(), msg, DeltaFunc(func(delta string) { replay += delta }))
if err != nil {
t.Fatalf("duplicate Run() error = %v", err)
}
if reply != "answer" || replay != "answer" {
t.Fatalf("duplicate reply = %q, replay = %q", reply, replay)
}
if prepared.generateN != 1 {
t.Fatalf("Generate calls = %d, want 1", prepared.generateN)
}
history, err := store.RecentMessages(context.Background(), "chat-1", 10)
if err != nil {
t.Fatalf("RecentMessages() error = %v", err)
}
if len(history) != 2 {
t.Fatalf("history length after duplicate = %d, want 2", len(history))
}
}