Files
archie/internal/gateway/compress_identity_test.go
T
sam 89d8dc0e7f feat(messaging): migrate gateway session persistence onto domain types
SessionStore message history now stores/loads domain/messaging.Message:
sender attribution, derived role, and conversation address are canonical
record fields. SQLite gains a role column with open-time backfill for
pre-migration databases. gateway.Message remains the channel-facing
transport; conversion lives in one boundary module. ChatContract,
gatewayrpc proto, and dashboard JSON are unchanged; the RPC client
splits into ChatContract (Client) and SessionStore (StoreClient) views.

Sessions stay SessionContext: UUID keys and platform/bot/title/branch
metadata have no lossless home in Conversation; keyed migration tracked
separately once Agent/user/binding ownership settles.

Refs: archie-core-d9dv
2026-09-08 21:28:19 +10:00

235 lines
7.3 KiB
Go

package gateway
import (
"context"
"fmt"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/domain/messaging"
)
// compressBackends provides the persistent store used by compression tests.
func compressBackends() map[string]func(t *testing.T) SessionStore {
return map[string]func(t *testing.T) SessionStore{
"sqlite": func(t *testing.T) SessionStore {
s, err := NewSQLiteSessionStoreMemory()
if err != nil {
t.Fatalf("NewSQLiteSessionStoreMemory: %v", err)
}
t.Cleanup(func() { _ = s.Close() })
return s
},
}
}
// routerOn builds a Router backed by store with an active session, and
// returns the session ID.
func routerOn(t *testing.T, store SessionStore, channelID string) (*Router, string) {
t.Helper()
r := NewRouter(nil, nil, "telegram")
r.InitSessions(store)
r.Identity = "archie"
sessionID, err := r.sessionTracker.resolve(context.Background(), "telegram", "archie", channelID, "")
if err != nil {
t.Fatalf("resolve: %v", err)
}
return r, sessionID
}
// seedForCompress fills a session with enough large messages to trip the
// default threshold, each carrying an upstream SourceID as Telegram does.
func seedForCompress(t *testing.T, store SessionStore, sessionID string, n int) []messaging.Message {
t.Helper()
// Large enough that n messages exceed 50% of a 128k context window
// (tokenEstimate is len/4, so n*bodyLen/4 must clear 64k).
body := make([]byte, 8000)
for i := range body {
body[i] = 'x'
}
for i := range n {
m := messaging.Message{
Sender: "alice",
Role: messaging.RoleUser,
Text: fmt.Sprintf("m%d %s", i, body),
SourceID: fmt.Sprintf("tg-%d", i),
At: at(dur(i)),
}
if err := store.SaveMessage(context.Background(), sessionID, m); err != nil {
t.Fatalf("SaveMessage %d: %v", i, err)
}
}
stored, err := store.RecentMessages(context.Background(), sessionID, n)
if err != nil {
t.Fatalf("RecentMessages: %v", err)
}
if len(stored) != n {
t.Fatalf("seeded %d messages, store has %d", n, len(stored))
}
return stored
}
// A message that survives compression is the same message. Rebuilding the
// protected head and tail as fresh records re-mints their canonical
// MessageID, drops the upstream SourceID and resets the timestamp, which
// silently breaks redelivery dedup for the rest of the session's life.
//
// Architecture: messaging-and-work-intake.md lines 88-90 (immutable
// application-generated MessageID) and 112-114 (immutable records).
func TestCompressPreservesRetainedMessageIdentity(t *testing.T) {
for name, newStore := range compressBackends() {
t.Run(name, func(t *testing.T) {
ctx := context.Background()
store := newStore(t)
r, sessionID := routerOn(t, store, "chat-1")
before := seedForCompress(t, store, sessionID, 40)
byText := make(map[string]messaging.Message, len(before))
for _, m := range before {
byText[m.Text] = m
}
if _, err := r.applyCompress(ctx, sessionID, DefaultCompressionConfig()); err != nil {
t.Fatalf("applyCompress: %v", err)
}
after, err := store.RecentMessages(ctx, sessionID, 1000)
if err != nil {
t.Fatalf("RecentMessages: %v", err)
}
retained := 0
for _, m := range after {
orig, ok := byText[m.Text]
if !ok {
continue // the summary, which is legitimately new
}
retained++
if m.ID != orig.ID {
t.Errorf("retained %q: MessageID = %q, want the original %q",
shortText(m.Text), m.ID, orig.ID)
}
if m.SourceID != orig.SourceID {
t.Errorf("retained %q: SourceID = %q, want the original %q",
shortText(m.Text), m.SourceID, orig.SourceID)
}
if !m.At.Equal(orig.At) {
t.Errorf("retained %q: At = %s, want the original %s",
shortText(m.Text), m.At, orig.At)
}
}
if retained == 0 {
t.Fatal("no original message survived compression: nothing was protected")
}
})
}
}
// The consequence of losing identity: after a compression, a redelivered
// upstream message appends a duplicate instead of being recognised. Telegram
// replays its undelivered queue after a restart, so this is the difference
// between a quiet reboot and a doubled conversation.
func TestCompressKeepsRedeliveryIdempotent(t *testing.T) {
for name, newStore := range compressBackends() {
t.Run(name, func(t *testing.T) {
ctx := context.Background()
store := newStore(t)
r, sessionID := routerOn(t, store, "chat-1")
before := seedForCompress(t, store, sessionID, 40)
last := before[len(before)-1]
// Redelivery is a no-op before compression.
if err := store.SaveMessage(ctx, sessionID, messaging.Message{
Sender: last.Sender, Role: last.Role, Text: last.Text, SourceID: last.SourceID, At: last.At,
}); err != nil {
t.Fatalf("redeliver before compress: %v", err)
}
preCount, err := store.MessageCount(ctx, sessionID)
if err != nil {
t.Fatalf("MessageCount: %v", err)
}
if preCount != len(before) {
t.Fatalf("redelivery before compress appended: count = %d, want %d", preCount, len(before))
}
if _, err := r.applyCompress(ctx, sessionID, DefaultCompressionConfig()); err != nil {
t.Fatalf("applyCompress: %v", err)
}
compressed, err := store.MessageCount(ctx, sessionID)
if err != nil {
t.Fatalf("MessageCount: %v", err)
}
// The same redelivery must still be a no-op afterwards.
if err := store.SaveMessage(ctx, sessionID, messaging.Message{
Sender: last.Sender, Role: last.Role, Text: last.Text, SourceID: last.SourceID, At: last.At,
}); err != nil {
t.Fatalf("redeliver after compress: %v", err)
}
got, err := store.MessageCount(ctx, sessionID)
if err != nil {
t.Fatalf("MessageCount: %v", err)
}
if got != compressed {
t.Errorf("redelivery after compress appended a duplicate: count = %d, want %d",
got, compressed)
}
})
}
}
// The summary describes the conversation; it is not something the user said.
// CompressHistory emits it with role "system", and the write-back must not
// let that fall through to the user, or the model replays "[Earlier
// conversation has been summarised...]" as if the human typed it.
func TestCompressSummaryIsNotAttributedToTheUser(t *testing.T) {
for name, newStore := range compressBackends() {
t.Run(name, func(t *testing.T) {
ctx := context.Background()
store := newStore(t)
r, sessionID := routerOn(t, store, "chat-1")
seedForCompress(t, store, sessionID, 40)
if _, err := r.applyCompress(ctx, sessionID, DefaultCompressionConfig()); err != nil {
t.Fatalf("applyCompress: %v", err)
}
after, err := store.RecentMessages(ctx, sessionID, 1000)
if err != nil {
t.Fatalf("RecentMessages: %v", err)
}
marker := DefaultCompressionConfig().SummaryMarker
found := false
for _, m := range after {
if !strings.Contains(m.Text, marker) {
continue
}
found = true
if m.Sender != r.Identity {
t.Errorf("summary Sender = %q, want the bot identity %q", m.Sender, r.Identity)
}
if m.Role != messaging.RoleAssistant {
t.Errorf("summary Role = %q, want assistant: consumers read the "+
"record's role, so any other value replays the summary as a "+
"user turn", m.Role)
}
}
if !found {
t.Fatal("no summary message found after compression")
}
})
}
}
func shortText(s string) string {
if len(s) > 12 {
return s[:12]
}
return s
}