Files
archie/internal/gateway/compress_command_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

172 lines
5.1 KiB
Go

package gateway
import (
"context"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/domain/messaging"
)
// /compress dispatch. Every case here is a command an operator can type, and
// the contract is that a command either does what it says or explains itself
// -- it never silently does something else to an irreplaceable history.
func TestCompressCommandDispatch(t *testing.T) {
tests := []struct {
name string
rest string
// wantApplied says the history must actually be rewritten.
wantApplied bool
// wantReply is a fragment the reply must contain.
wantReply string
// wantProtected, when non-zero, is the number of trailing messages
// that must survive alongside the summary.
wantProtected int
}{
{
// The preview's own closing line says "Run /compress to apply".
// Taking the preview branch here made that instruction a loop:
// the documented way to apply compression could never apply it.
name: "bare compress applies",
rest: "",
wantApplied: true,
wantReply: "Compressed:",
wantProtected: DefaultCompressionConfig().ProtectLast,
},
{
name: "--preview does not apply",
rest: "--preview",
wantReply: "preview",
},
{
name: "--dry-run does not apply",
rest: "--dry-run",
wantReply: "preview",
},
{
name: "here N protects N",
rest: "here 5",
wantApplied: true,
wantReply: "Compressed:",
wantProtected: 5,
},
{
// Previously fell through to a full default compression,
// rewriting history from a command that named no count.
name: "here without a count explains itself",
rest: "here",
wantReply: "Usage",
},
{
name: "here with a non-number explains itself",
rest: "here abc",
wantReply: "Usage",
},
{
// focus has no implementation: cfg was never modified, so this
// ran a full default compression and reported success.
name: "focus reports that it is unsupported",
rest: "focus auth",
wantReply: "not supported",
},
{
name: "focus without a topic explains itself",
rest: "focus",
wantReply: "Usage",
},
{
// Previously compressed the whole history.
name: "an unknown argument explains itself",
rest: "asdf",
wantReply: "Usage",
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
ctx := context.Background()
store := NewSessionStoreMemory()
t.Cleanup(func() { _ = store.Close() })
r, sessionID := routerOn(t, store, "chat-1")
const seeded = 40
seedForCompress(t, store, sessionID, seeded)
reply, err := r.handleCompress(ctx, inbound("chat-1", "").Message, tc.rest)
if err != nil {
t.Fatalf("handleCompress(%q): %v", tc.rest, err)
}
if !strings.Contains(strings.ToLower(reply), strings.ToLower(tc.wantReply)) {
t.Errorf("reply = %q, want it to contain %q", reply, tc.wantReply)
}
count, err := store.MessageCount(ctx, sessionID)
if err != nil {
t.Fatalf("MessageCount: %v", err)
}
if !tc.wantApplied {
if count != seeded {
t.Fatalf("history was rewritten by %q: count = %d, want the original %d",
"/compress "+tc.rest, count, seeded)
}
return
}
if count == seeded {
t.Fatalf("history was not compressed by %q: count is still %d", "/compress "+tc.rest, count)
}
if tc.wantProtected > 0 {
// head + summary + tail
want := DefaultCompressionConfig().ProtectFirst + 1 + tc.wantProtected
if count != want {
t.Errorf("count = %d, want %d (first %d + summary + last %d)",
count, want, DefaultCompressionConfig().ProtectFirst, tc.wantProtected)
}
}
})
}
}
// The preview reports a message count from the store but token figures from a
// fixed window, so on a long history the two halves of one sentence described
// different conversations -- and it advised against a compression that was in
// fact needed.
func TestCompressPreviewReadsTheWholeHistory(t *testing.T) {
ctx := context.Background()
store := NewSessionStoreMemory()
t.Cleanup(func() { _ = store.Close() })
r, sessionID := routerOn(t, store, "chat-1")
// Enough messages to exceed the old fixed 200-message read, with the
// bulk of the tokens outside that window.
seedForCompress(t, store, sessionID, 40)
for i := range 250 {
if err := store.SaveMessage(ctx, sessionID, messaging.Message{
Sender: "alice", Role: messaging.RoleUser, Text: "tiny", SourceID: pad(i), At: at(dur(1000 + i)),
}); err != nil {
t.Fatalf("SaveMessage: %v", err)
}
}
preview, err := r.compressPreview(ctx, sessionID)
if err != nil {
t.Fatalf("compressPreview: %v", err)
}
if strings.Contains(preview, "not needed") {
t.Fatalf("preview says compression is not needed, but applying it compresses: %q", preview)
}
applied, err := r.applyCompress(ctx, sessionID, DefaultCompressionConfig())
if err != nil {
t.Fatalf("applyCompress: %v", err)
}
if !strings.Contains(applied, "Compressed:") {
t.Fatalf("apply did not compress after the preview said it would: %q", applied)
}
}
func pad(i int) string {
return "late-" + string(rune('a'+i%26)) + string(rune('a'+(i/26)%26)) + string(rune('a'+(i/676)%26))
}