5713231 landed with golangci-lint red: scanSearchMessages was an exact copy
of scanMessages bar two error strings (dupl), and the pre-role schema
migration test seeded its fixture with db.Exec (noctx). task check has been
failing on main since.
Collapse the two scanners into one -- SearchMessages already selects the same
column order the history reads do, which the deleted function's own comment
said -- and seed the fixture through ExecContext.
No behaviour change: the gateway suite passes unchanged.
1268 lines
44 KiB
Go
1268 lines
44 KiB
Go
package gateway
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
|
)
|
|
|
|
func newTestSQLiteStore(t *testing.T) SessionStore {
|
|
t.Helper()
|
|
st, err := NewSQLiteSessionStoreMemory()
|
|
if err != nil {
|
|
t.Fatalf("NewSQLiteSessionStoreMemory: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = st.Close() })
|
|
return st
|
|
}
|
|
|
|
func sqliteBase() time.Time { return time.Date(2026, 8, 3, 12, 0, 0, 0, time.UTC) }
|
|
|
|
func TestSQLiteSessionStoreRecentTurnsReturnsReplayableToolHistory(t *testing.T) {
|
|
st := newTestSQLiteStore(t)
|
|
ledger, ok := st.(TurnLedger)
|
|
if !ok {
|
|
t.Fatalf("store is %T, want TurnLedger", st)
|
|
}
|
|
turn, claim, err := ledger.ClaimTurn(t.Context(), TurnRecord{
|
|
TurnID: "turn-history", SessionID: "session-history", SourceID: "source-history", OwnerID: "owner",
|
|
ToolCalls: []ToolCallEvent{{Name: "shell", Output: "exit 0"}},
|
|
})
|
|
if err != nil || claim != TurnClaimOwned {
|
|
t.Fatalf("ClaimTurn() = %#v, %v, %v", turn, claim, err)
|
|
}
|
|
turn.Status = TurnStatusCompleted
|
|
turn.ResponseText = "answer"
|
|
turn.UpdatedAt = time.Now().UTC()
|
|
if err := ledger.SaveTurn(t.Context(), turn); err != nil {
|
|
t.Fatalf("SaveTurn() error = %v", err)
|
|
}
|
|
history, ok := st.(TurnHistory)
|
|
if !ok {
|
|
t.Fatalf("store is %T, want TurnHistory", st)
|
|
}
|
|
got, err := history.RecentTurns(t.Context(), "session-history", 10)
|
|
if err != nil || len(got) != 1 || len(got[0].ToolCalls) != 1 || got[0].ResponseText != "answer" {
|
|
t.Fatalf("RecentTurns() = %#v, %v; want one replayable turn", got, err)
|
|
}
|
|
}
|
|
|
|
// TestOpenSQLiteSessionStoreMigratesPreExistingTurnsTable simulates a
|
|
// database created before the tool_calls column existed: CREATE TABLE IF NOT
|
|
// EXISTS leaves such a table alone, so opening it must add the column rather
|
|
// than fail or silently keep the old shape.
|
|
func TestOpenSQLiteSessionStoreMigratesPreExistingTurnsTable(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "legacy.db")
|
|
raw, err := sql.Open("sqlite", sqliteSessionDSN(path))
|
|
if err != nil {
|
|
t.Fatalf("sql.Open() error = %v", err)
|
|
}
|
|
if _, err := raw.ExecContext(t.Context(), `CREATE TABLE turns (
|
|
turn_id TEXT PRIMARY KEY,
|
|
session_id TEXT NOT NULL,
|
|
source_id TEXT NOT NULL DEFAULT '',
|
|
status TEXT NOT NULL,
|
|
attempt INTEGER NOT NULL DEFAULT 0,
|
|
owner_id TEXT NOT NULL DEFAULT '',
|
|
input_message_id TEXT NOT NULL DEFAULT '',
|
|
assistant_message_id TEXT NOT NULL DEFAULT '',
|
|
partial_text TEXT NOT NULL DEFAULT '',
|
|
response_text TEXT NOT NULL DEFAULT '',
|
|
error TEXT NOT NULL DEFAULT '',
|
|
created_at INTEGER NOT NULL,
|
|
updated_at INTEGER NOT NULL
|
|
)`); err != nil {
|
|
t.Fatalf("create legacy turns table: %v", err)
|
|
}
|
|
if _, err := raw.ExecContext(t.Context(), `INSERT INTO turns (
|
|
turn_id, session_id, source_id, status, attempt, owner_id,
|
|
input_message_id, assistant_message_id, partial_text, response_text,
|
|
error, created_at, updated_at
|
|
) VALUES ('legacy-turn', 'legacy-session', 'legacy-source', 'completed', 1, 'owner',
|
|
'', 'assistant-1', '', 'legacy answer', '', 0, 0)`); err != nil {
|
|
t.Fatalf("insert legacy turn row: %v", err)
|
|
}
|
|
if err := raw.Close(); err != nil {
|
|
t.Fatalf("close legacy handle: %v", err)
|
|
}
|
|
|
|
store, err := OpenSQLiteSessionStore(path)
|
|
if err != nil {
|
|
t.Fatalf("OpenSQLiteSessionStore() on legacy schema error = %v", err)
|
|
}
|
|
defer func() { _ = store.Close() }()
|
|
ledger, ok := store.(TurnLedger)
|
|
if !ok {
|
|
t.Fatalf("store is %T, want TurnLedger", store)
|
|
}
|
|
turn, ok, err := ledger.GetTurn(t.Context(), "legacy-turn")
|
|
if err != nil || !ok {
|
|
t.Fatalf("GetTurn() after migration = %#v, %v, %v; want the legacy row", turn, ok, err)
|
|
}
|
|
if turn.ResponseText != "legacy answer" || len(turn.ToolCalls) != 0 {
|
|
t.Fatalf("migrated turn = %#v, want legacy text with no tool calls", turn)
|
|
}
|
|
|
|
// Reopening a second time must not fail on the "duplicate column name"
|
|
// the migration produces once the column already exists.
|
|
if err := store.Close(); err != nil {
|
|
t.Fatalf("Close() error = %v", err)
|
|
}
|
|
reopened, err := OpenSQLiteSessionStore(path)
|
|
if err != nil {
|
|
t.Fatalf("second OpenSQLiteSessionStore() error = %v", err)
|
|
}
|
|
_ = reopened.Close()
|
|
}
|
|
|
|
func TestSQLiteSessionStoreRejectsExcessiveSearchQueries(t *testing.T) {
|
|
st := newTestSQLiteStore(t)
|
|
tests := []struct {
|
|
name string
|
|
query string
|
|
}{
|
|
{name: "bytes", query: strings.Repeat("a", 4097)},
|
|
{name: "terms", query: strings.Repeat("word ", 65)},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if _, err := st.SearchMessages(t.Context(), "sess", MessageQuery{Query: tt.query}); err == nil {
|
|
t.Fatal("SearchMessages accepted an excessive query")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestOpenSQLiteSessionStoreAppliesPragmasWithTrailingQueryDelimiter(t *testing.T) {
|
|
st, err := OpenSQLiteSessionStore(filepath.Join(t.TempDir(), "messages.db") + "?")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = st.Close() })
|
|
sqliteStore, ok := st.(*sqliteSessionStore)
|
|
if !ok {
|
|
t.Fatalf("store type = %T, want *sqliteSessionStore", st)
|
|
}
|
|
var mode string
|
|
if err := sqliteStore.db.QueryRowContext(t.Context(), `PRAGMA journal_mode`).Scan(&mode); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if mode != "wal" {
|
|
t.Fatalf("journal_mode = %q, want wal", mode)
|
|
}
|
|
}
|
|
|
|
func TestSQLiteSessionStoreThreadIDRoundTrip(t *testing.T) {
|
|
st := newTestSQLiteStore(t)
|
|
want := SessionContext{
|
|
SessionID: "sess-thread",
|
|
Source: SessionSource{
|
|
Platform: "telegram", BotUser: "archie", ChannelID: "-100123", ThreadID: "5",
|
|
},
|
|
CreatedAt: sqliteBase(), LastActiveAt: sqliteBase(),
|
|
}
|
|
if err := st.Save(t.Context(), want); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := st.Get(t.Context(), want.SessionID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got == nil || got.Source.ThreadID != want.Source.ThreadID || got.Source.ChannelID != want.Source.ChannelID {
|
|
t.Fatalf("Get = %+v, want thread %q channel %q", got, want.Source.ThreadID, want.Source.ChannelID)
|
|
}
|
|
}
|
|
|
|
func TestMessageIDsAreUnique(t *testing.T) {
|
|
const count = 10_000
|
|
seen := make(map[string]struct{}, count)
|
|
for range count {
|
|
id := newMessageID("sess", "")
|
|
if _, exists := seen[id]; exists {
|
|
t.Fatalf("duplicate message ID %q", id)
|
|
}
|
|
seen[id] = struct{}{}
|
|
}
|
|
}
|
|
|
|
func TestCanonicalMessageIDComponentsAreInjectivelyEncoded(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
firstSession string
|
|
firstSource string
|
|
secondSession string
|
|
secondSource string
|
|
}{
|
|
{
|
|
name: "separator can occur in session",
|
|
firstSession: "a\x00b",
|
|
firstSource: "c",
|
|
secondSession: "a",
|
|
secondSource: "b\x00c",
|
|
},
|
|
{
|
|
name: "empty session does not alias prefixed source",
|
|
firstSession: "",
|
|
firstSource: "a\x00b",
|
|
secondSession: "\x00a",
|
|
secondSource: "b",
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
first := CanonicalMessageID(tc.firstSession, tc.firstSource)
|
|
second := CanonicalMessageID(tc.secondSession, tc.secondSource)
|
|
if first == second {
|
|
t.Fatalf("CanonicalMessageID(%q, %q) = CanonicalMessageID(%q, %q) = %q",
|
|
tc.firstSession, tc.firstSource, tc.secondSession, tc.secondSource, first)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSQLiteSessionStoreRecognisesLegacyCanonicalIDOnRedelivery(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
store := newTestSQLiteStore(t)
|
|
ctx := t.Context()
|
|
const (
|
|
sessionID = "a\x00b"
|
|
sourceID = "source"
|
|
)
|
|
legacyID := uuid.NewSHA1(messageIDNamespace, []byte(sessionID+"\x00"+sourceID)).String()
|
|
if _, err := sqliteStoreDB(t, store).ExecContext(ctx, `
|
|
INSERT INTO messages (message_id, session_id, source_id, sender, text, ts)
|
|
VALUES (?, ?, ?, 'alice', 'original', ?)`,
|
|
legacyID, sessionID, sourceID, time.Now().Add(-time.Minute).UnixMilli()); err != nil {
|
|
t.Fatalf("seed legacy message: %v", err)
|
|
}
|
|
|
|
if err := store.SaveMessage(ctx, sessionID, messaging.Message{
|
|
ID: messaging.MessageID(CanonicalMessageID(sessionID, sourceID)),
|
|
SourceID: sourceID, Sender: "alice", Role: messaging.RoleUser, Text: "redelivered",
|
|
}); err != nil {
|
|
t.Fatalf("SaveMessage(redelivery): %v", err)
|
|
}
|
|
messages, err := store.RecentMessages(ctx, sessionID, 10)
|
|
if err != nil {
|
|
t.Fatalf("RecentMessages: %v", err)
|
|
}
|
|
if len(messages) != 1 {
|
|
t.Fatalf("redelivery produced %d messages, want 1", len(messages))
|
|
}
|
|
if string(messages[0].ID) != legacyID || messages[0].Text != "original" {
|
|
t.Fatalf("legacy message changed on redelivery: %#v", messages[0])
|
|
}
|
|
}
|
|
|
|
func TestSQLiteSessionStoreFindPriorReplyRecognisesLegacyCanonicalID(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
store := newTestSQLiteStore(t)
|
|
ctx := t.Context()
|
|
const (
|
|
sessionID = "a\x00b"
|
|
sourceID = "source"
|
|
identity = "archie"
|
|
)
|
|
legacyID := uuid.NewSHA1(messageIDNamespace, []byte(sessionID+"\x00"+sourceID)).String()
|
|
inputAt := time.Now().Add(-time.Minute).UnixMilli()
|
|
statements := []struct {
|
|
id string
|
|
source string
|
|
sender string
|
|
text string
|
|
at int64
|
|
}{
|
|
{id: legacyID, source: sourceID, sender: "alice", text: "question", at: inputAt},
|
|
{id: "reply", sender: identity, text: "answer", at: inputAt + 1},
|
|
}
|
|
for _, row := range statements {
|
|
if _, err := sqliteStoreDB(t, store).ExecContext(ctx, `
|
|
INSERT INTO messages (message_id, session_id, source_id, sender, text, ts)
|
|
VALUES (?, ?, ?, ?, ?, ?)`,
|
|
row.id, sessionID, row.source, row.sender, row.text, row.at); err != nil {
|
|
t.Fatalf("seed %s: %v", row.id, err)
|
|
}
|
|
}
|
|
|
|
replayStore, ok := store.(TurnReplayStore)
|
|
if !ok {
|
|
t.Fatalf("store is %T, want TurnReplayStore", store)
|
|
}
|
|
got, err := replayStore.FindPriorReply(ctx, sessionID, sourceID, identity)
|
|
if err != nil {
|
|
t.Fatalf("FindPriorReply: %v", err)
|
|
}
|
|
if got != "answer" {
|
|
t.Fatalf("FindPriorReply = %q, want legacy reply", got)
|
|
}
|
|
}
|
|
|
|
func TestSQLiteSessionStoreCapsFutureMessageTimestamp(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
store := newTestSQLiteStore(t)
|
|
ctx := t.Context()
|
|
now := time.Now().UTC()
|
|
if err := store.SaveMessage(ctx, "sess", messaging.Message{
|
|
Sender: "alice", Role: messaging.RoleUser, Text: "future", At: now.Add(24 * time.Hour),
|
|
}); err != nil {
|
|
t.Fatalf("SaveMessage(future): %v", err)
|
|
}
|
|
if err := store.SaveMessage(ctx, "sess", messaging.Message{
|
|
Sender: "alice", Role: messaging.RoleUser, Text: "current", At: now,
|
|
}); err != nil {
|
|
t.Fatalf("SaveMessage(current): %v", err)
|
|
}
|
|
|
|
messages, err := store.RecentMessages(ctx, "sess", 10)
|
|
if err != nil {
|
|
t.Fatalf("RecentMessages: %v", err)
|
|
}
|
|
if len(messages) != 2 {
|
|
t.Fatalf("RecentMessages returned %d messages, want 2", len(messages))
|
|
}
|
|
if messages[0].At.After(time.Now().UTC().Add(time.Minute)) {
|
|
t.Fatalf("future timestamp was persisted as %s", messages[0].At)
|
|
}
|
|
if !messages[1].At.After(messages[0].At) {
|
|
t.Fatalf("current message timestamp %s does not follow capped future timestamp %s",
|
|
messages[1].At, messages[0].At)
|
|
}
|
|
}
|
|
|
|
func TestSQLiteSessionStoreRepairsPersistedFutureTimestampsOnReopen(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx := t.Context()
|
|
path := filepath.Join(t.TempDir(), "future.db")
|
|
store, err := OpenSQLiteSessionStore(path)
|
|
if err != nil {
|
|
t.Fatalf("OpenSQLiteSessionStore: %v", err)
|
|
}
|
|
now := time.Now().UTC()
|
|
rows := []struct {
|
|
id string
|
|
text string
|
|
at time.Time
|
|
}{
|
|
{id: "past", text: "past", at: now.Add(-time.Minute)},
|
|
{id: "future-1", text: "future-1", at: now.Add(24 * time.Hour)},
|
|
{id: "future-2", text: "future-2", at: now.Add(25 * time.Hour)},
|
|
}
|
|
for _, row := range rows {
|
|
if _, err := sqliteStoreDB(t, store).ExecContext(ctx, `
|
|
INSERT INTO messages (message_id, session_id, sender, text, ts)
|
|
VALUES (?, 'sess', 'alice', ?, ?)`, row.id, row.text, row.at.UnixMilli()); err != nil {
|
|
t.Fatalf("seed %s: %v", row.id, err)
|
|
}
|
|
}
|
|
if err := store.Close(); err != nil {
|
|
t.Fatalf("Close seeded store: %v", err)
|
|
}
|
|
|
|
reopened, err := OpenSQLiteSessionStore(path)
|
|
if err != nil {
|
|
t.Fatalf("reopen store: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = reopened.Close() })
|
|
if err := reopened.SaveMessage(ctx, "sess", messaging.Message{
|
|
Sender: "alice", Role: messaging.RoleUser, Text: "current", At: time.Now().UTC(),
|
|
}); err != nil {
|
|
t.Fatalf("SaveMessage(current): %v", err)
|
|
}
|
|
|
|
messages, err := reopened.RecentMessages(ctx, "sess", 10)
|
|
if err != nil {
|
|
t.Fatalf("RecentMessages: %v", err)
|
|
}
|
|
want := []string{"past", "future-1", "future-2", "current"}
|
|
if got := texts(messages); !equal(got, want) {
|
|
t.Fatalf("history = %v, want %v", got, want)
|
|
}
|
|
for i := 1; i < len(messages); i++ {
|
|
if !messages[i].At.After(messages[i-1].At) {
|
|
t.Fatalf("timestamp %d (%s) does not follow %d (%s)",
|
|
i, messages[i].At, i-1, messages[i-1].At)
|
|
}
|
|
}
|
|
if messages[len(messages)-1].At.After(time.Now().UTC().Add(time.Second)) {
|
|
t.Fatalf("repaired history remains pinned in the future: last timestamp %s",
|
|
messages[len(messages)-1].At)
|
|
}
|
|
}
|
|
|
|
func TestSQLiteMessageTimestampRoundTrips(t *testing.T) {
|
|
st := newTestSQLiteStore(t)
|
|
want := sqliteBase().Add(90*time.Minute + 123*time.Millisecond)
|
|
if err := st.SaveMessage(t.Context(), "sess", messaging.Message{Sender: "user", Role: messaging.RoleUser, Text: "hello", At: want}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := st.RecentMessages(t.Context(), "sess", 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 1 || !got[0].At.Equal(want) {
|
|
t.Fatalf("RecentMessages = %+v, want timestamp %s", got, want)
|
|
}
|
|
}
|
|
|
|
func TestSQLiteMessageTimestampsIncreaseAcrossStoreHandles(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "messages.db")
|
|
stores := make([]SessionStore, 2)
|
|
for i := range stores {
|
|
var err error
|
|
stores[i], err = OpenSQLiteSessionStore(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer func(store SessionStore) { _ = store.Close() }(stores[i])
|
|
}
|
|
|
|
const perStore = 100
|
|
wantTime := sqliteBase()
|
|
var wg sync.WaitGroup
|
|
for storeIndex, st := range stores {
|
|
for messageIndex := range perStore {
|
|
wg.Go(func() {
|
|
err := st.SaveMessage(t.Context(), "sess", messaging.Message{
|
|
ID: messaging.MessageID(fmt.Sprintf("%d-%d", storeIndex, messageIndex)),
|
|
Sender: "user", Role: messaging.RoleUser,
|
|
Text: "concurrent",
|
|
At: wantTime,
|
|
})
|
|
if err != nil {
|
|
t.Errorf("SaveMessage: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
wg.Wait()
|
|
|
|
messages, err := stores[0].RecentMessages(t.Context(), "sess", perStore*len(stores))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(messages) != perStore*len(stores) {
|
|
t.Fatalf("messages = %d, want %d", len(messages), perStore*len(stores))
|
|
}
|
|
for i := 1; i < len(messages); i++ {
|
|
if !messages[i].At.After(messages[i-1].At) {
|
|
t.Fatalf("timestamp %d (%s) is not after timestamp %d (%s)", i, messages[i].At, i-1, messages[i-1].At)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestSQLiteSessionStore_DeleteIsAtomic pins invariant 4: Delete removes the
|
|
// session and its messages together.
|
|
func TestSQLiteSessionStore_DeleteIsAtomic(t *testing.T) {
|
|
ctx := context.Background()
|
|
st := newTestSQLiteStore(t)
|
|
|
|
sc := SessionContext{
|
|
SessionID: "sess-del", Source: SessionSource{Platform: "web", ChannelID: "c"},
|
|
CreatedAt: sqliteBase(), LastActiveAt: sqliteBase(),
|
|
}
|
|
if err := st.Save(ctx, sc); err != nil {
|
|
t.Fatalf("Save: %v", err)
|
|
}
|
|
if err := st.SaveMessage(ctx, "sess-del", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: "hi", At: sqliteBase()}); err != nil {
|
|
t.Fatalf("SaveMessage: %v", err)
|
|
}
|
|
|
|
if err := st.Delete(ctx, "sess-del"); err != nil {
|
|
t.Fatalf("Delete: %v", err)
|
|
}
|
|
|
|
got, err := st.Get(ctx, "sess-del")
|
|
if err != nil {
|
|
t.Fatalf("Get: %v", err)
|
|
}
|
|
if got != nil {
|
|
t.Error("expected session to be gone")
|
|
}
|
|
count, err := st.MessageCount(ctx, "sess-del")
|
|
if err != nil {
|
|
t.Fatalf("MessageCount: %v", err)
|
|
}
|
|
if count != 0 {
|
|
t.Errorf("expected messages to be gone, got count %d", count)
|
|
}
|
|
|
|
// Deleting a non-existent session is a no-op.
|
|
if err := st.Delete(ctx, "nonexistent"); err != nil {
|
|
t.Errorf("Delete nonexistent: %v", err)
|
|
}
|
|
}
|
|
|
|
// TestSQLiteSessionStore_SearchPagingAndTruncated pins invariant 6: Limit is
|
|
// a page size (not a cap), paging is honoured via Offset/NextOffset/HasMore,
|
|
// and Truncated is always false (SQLite has a real total count).
|
|
func TestSQLiteSessionStore_SearchPagingAndTruncated(t *testing.T) {
|
|
ctx := context.Background()
|
|
st := newTestSQLiteStore(t)
|
|
|
|
const total = 30
|
|
for i := range total {
|
|
m := messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: "needle common", At: sqliteBase().Add(time.Duration(i) * time.Second)}
|
|
if err := st.SaveMessage(ctx, "sess", m); err != nil {
|
|
t.Fatalf("SaveMessage %d: %v", i, err)
|
|
}
|
|
}
|
|
|
|
seen := map[string]bool{}
|
|
offset := 0
|
|
pages := 0
|
|
for {
|
|
page, err := st.SearchMessages(ctx, "sess", MessageQuery{Query: "needle", Limit: 7, Offset: offset})
|
|
if err != nil {
|
|
t.Fatalf("SearchMessages offset=%d: %v", offset, err)
|
|
}
|
|
if page.Truncated {
|
|
t.Errorf("expected Truncated=false for SQLite backend")
|
|
}
|
|
for _, m := range page.Messages {
|
|
if seen[string(m.ID)] {
|
|
t.Errorf("duplicate message across pages: %s", string(m.ID))
|
|
}
|
|
seen[string(m.ID)] = true
|
|
}
|
|
pages++
|
|
if !page.HasMore {
|
|
break
|
|
}
|
|
offset = page.NextOffset
|
|
if pages > total {
|
|
t.Fatal("paging did not terminate")
|
|
}
|
|
}
|
|
if len(seen) != total {
|
|
t.Errorf("expected to see all %d matches across pages, got %d", total, len(seen))
|
|
}
|
|
}
|
|
|
|
func TestSQLiteSessionStore_ErrorPaths(t *testing.T) {
|
|
ctx := context.Background()
|
|
st := newTestSQLiteStore(t)
|
|
if err := st.Close(); err != nil {
|
|
t.Fatalf("Close: %v", err)
|
|
}
|
|
|
|
t.Run("Save after close", func(t *testing.T) {
|
|
if err := st.Save(ctx, SessionContext{SessionID: "x"}); err == nil {
|
|
t.Error("expected error saving to a closed store")
|
|
}
|
|
})
|
|
t.Run("Get after close", func(t *testing.T) {
|
|
if _, err := st.Get(ctx, "x"); err == nil {
|
|
t.Error("expected error getting from a closed store")
|
|
}
|
|
})
|
|
t.Run("SaveMessage after close", func(t *testing.T) {
|
|
if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: "hi"}); err == nil {
|
|
t.Error("expected error saving message to a closed store")
|
|
}
|
|
})
|
|
t.Run("SearchMessages after close", func(t *testing.T) {
|
|
if _, err := st.SearchMessages(ctx, "sess", MessageQuery{Query: "hi"}); err == nil {
|
|
t.Error("expected error searching a closed store")
|
|
}
|
|
})
|
|
t.Run("Delete after close", func(t *testing.T) {
|
|
if err := st.Delete(ctx, "sess"); err == nil {
|
|
t.Error("expected error deleting from a closed store")
|
|
}
|
|
})
|
|
t.Run("ReplaceMessages after close", func(t *testing.T) {
|
|
if err := st.ReplaceMessages(ctx, "sess", nil, nil); err == nil {
|
|
t.Error("expected error replacing messages on a closed store")
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestOpenSQLiteSessionStore_CreatesFile(t *testing.T) {
|
|
dir := t.TempDir()
|
|
path := dir + "/sub/dir/sessions.db"
|
|
|
|
st, err := OpenSQLiteSessionStore(path)
|
|
if err != nil {
|
|
t.Fatalf("OpenSQLiteSessionStore: %v", err)
|
|
}
|
|
defer func() { _ = st.Close() }()
|
|
|
|
ctx := context.Background()
|
|
sc := SessionContext{SessionID: "s1", Source: SessionSource{Platform: "web", ChannelID: "c"}, CreatedAt: sqliteBase(), LastActiveAt: sqliteBase()}
|
|
if err := st.Save(ctx, sc); err != nil {
|
|
t.Fatalf("Save: %v", err)
|
|
}
|
|
got, err := st.Get(ctx, "s1")
|
|
if err != nil {
|
|
t.Fatalf("Get: %v", err)
|
|
}
|
|
if got == nil {
|
|
t.Fatal("expected session to persist to the created file")
|
|
}
|
|
}
|
|
|
|
// ── Adversarial file-backed coverage (bead 8u8.1) ───────────────────────────
|
|
//
|
|
// These tests are deliberately SQLite-only. They prove two properties the
|
|
// shared 19-group conformance suite cannot: file-backed durability across
|
|
// close+reopen (with the trigger-maintained FTS index intact and a clean
|
|
// PRAGMA quick_check), and transaction rollback under injected
|
|
// mid-operation failures. They reach into sqliteSessionStore internals -- the
|
|
// raw *sql.DB -- to install deterministic abort triggers and run PRAGMA
|
|
// checks, which the SessionStore interface does not expose.
|
|
|
|
// sqliteStoreDB exposes the raw handle behind a store for SQLite-specific
|
|
// tests. The store pins its pool to one connection and serializes writes
|
|
// with its own mutex, so a test touching this handle between operations is
|
|
// safe and deterministic.
|
|
// TestSQLiteSessionStore_MigratesPreRoleDatabase pins the upgrade path for
|
|
// databases written before the messaging migration added the role column:
|
|
// opening backfills roles from the sender-vs-bot identity the boundary
|
|
// applies to new writes, so old histories keep their assistant/user
|
|
// distinction and sender search keeps working.
|
|
func TestSQLiteSessionStore_MigratesPreRoleDatabase(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "old.db")
|
|
db, err := sql.Open("sqlite", sqliteSessionDSN(path))
|
|
if err != nil {
|
|
t.Fatalf("open raw db: %v", err)
|
|
}
|
|
oldMessages := strings.Replace(sqliteSessionSchema,
|
|
"\tsender TEXT NOT NULL DEFAULT '',\n\trole TEXT NOT NULL DEFAULT '',\n",
|
|
"\tsender TEXT NOT NULL DEFAULT '',\n", 1)
|
|
if _, err := db.ExecContext(t.Context(), oldMessages); err != nil {
|
|
t.Fatalf("create old schema: %v", err)
|
|
}
|
|
millis := sqliteBase().UnixMilli()
|
|
if _, err := db.ExecContext(t.Context(), `INSERT INTO sessions (session_id, platform, bot_user, channel_id, created_at, last_active_at)
|
|
VALUES ('sess-old', 'telegram', 'archie', 'chat-1', ?, ?)`, millis, millis); err != nil {
|
|
t.Fatalf("seed old session: %v", err)
|
|
}
|
|
if _, err := db.ExecContext(t.Context(), `INSERT INTO messages (message_id, session_id, source_id, sender, text, ts) VALUES
|
|
('m-user', 'sess-old', 'tg-1', 'alice', 'hello', ?),
|
|
('m-assistant', 'sess-old', '', 'archie', 'hi', ?)`, millis, millis+1); err != nil {
|
|
t.Fatalf("seed old messages: %v", err)
|
|
}
|
|
if err := db.Close(); err != nil {
|
|
t.Fatalf("close raw db: %v", err)
|
|
}
|
|
|
|
st, err := OpenSQLiteSessionStore(path)
|
|
if err != nil {
|
|
t.Fatalf("reopen old database: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = st.Close() })
|
|
|
|
hist, err := st.RecentMessages(context.Background(), "sess-old", 10)
|
|
if err != nil {
|
|
t.Fatalf("RecentMessages: %v", err)
|
|
}
|
|
if len(hist) != 2 {
|
|
t.Fatalf("history = %d messages, want 2", len(hist))
|
|
}
|
|
if hist[0].Role != messaging.RoleUser || hist[0].Sender != "alice" {
|
|
t.Errorf("user message = %+v, want role user from alice", hist[0])
|
|
}
|
|
if hist[1].Role != messaging.RoleAssistant || hist[1].Sender != "archie" {
|
|
t.Errorf("assistant message = %+v, want role assistant from archie", hist[1])
|
|
}
|
|
page, err := st.SearchMessages(context.Background(), "sess-old", MessageQuery{Query: "alice", Limit: 10})
|
|
if err != nil {
|
|
t.Fatalf("SearchMessages: %v", err)
|
|
}
|
|
if len(page.Messages) != 1 {
|
|
t.Errorf("sender search = %d matches, want 1", len(page.Messages))
|
|
}
|
|
}
|
|
|
|
func sqliteStoreDB(t *testing.T, st SessionStore) *sql.DB {
|
|
t.Helper()
|
|
s, ok := st.(*sqliteSessionStore)
|
|
if !ok {
|
|
t.Fatalf("store is %T, want *sqliteSessionStore", st)
|
|
}
|
|
return s.db
|
|
}
|
|
|
|
// installAbortTrigger deterministically fails the statement that matches
|
|
// clause by raising ABORT from a BEFORE trigger. Because the trigger fires
|
|
// mid-transaction (after earlier statements in the same transaction have
|
|
// already run), a correct store must roll the whole transaction back for the
|
|
// abort to be invisible to later reads.
|
|
func installAbortTrigger(t *testing.T, st SessionStore, clause string) {
|
|
t.Helper()
|
|
_, err := sqliteStoreDB(t, st).ExecContext(context.Background(),
|
|
`CREATE TRIGGER test_forced_abort `+clause+` BEGIN
|
|
SELECT RAISE(ABORT, 'forced test abort');
|
|
END`)
|
|
if err != nil {
|
|
t.Fatalf("install abort trigger: %v", err)
|
|
}
|
|
}
|
|
|
|
// TestSQLiteSessionStore_CloseReopenDurability proves that a file-backed
|
|
// store persists SessionContext fields and canonical message identity
|
|
// (MessageID, SourceID, sender, text, timestamp) across a close+reopen
|
|
// cycle, that the trigger-maintained FTS index survives with it, and that
|
|
// PRAGMA quick_check reports the file intact.
|
|
func TestSQLiteSessionStore_CloseReopenDurability(t *testing.T) {
|
|
ctx := context.Background()
|
|
path := filepath.Join(t.TempDir(), "sessions.db")
|
|
|
|
st, err := OpenSQLiteSessionStore(path)
|
|
if err != nil {
|
|
t.Fatalf("OpenSQLiteSessionStore: %v", err)
|
|
}
|
|
|
|
wantSC := SessionContext{
|
|
SessionID: "sess-durable",
|
|
Source: SessionSource{
|
|
Platform: "telegram", BotUser: "archie", ChannelID: "chat-42", ThreadID: "topic-7",
|
|
},
|
|
Title: "durable title",
|
|
ParentSessionID: "sess-parent",
|
|
BranchName: "feature/x",
|
|
CreatedAt: sqliteBase(),
|
|
LastActiveAt: sqliteBase().Add(time.Minute),
|
|
}
|
|
if err := st.Save(ctx, wantSC); err != nil {
|
|
t.Fatalf("Save: %v", err)
|
|
}
|
|
|
|
wantMsgs := []messaging.Message{
|
|
{ID: "canonical-1", SourceID: "tg-1001", Sender: "alice", Role: messaging.RoleUser, Text: "first durable message", At: sqliteBase().Add(time.Second)},
|
|
{ID: "canonical-2", SourceID: "tg-1002", Sender: "bob", Role: messaging.RoleUser, Text: "second durable message", At: sqliteBase().Add(2 * time.Second)},
|
|
}
|
|
for _, m := range wantMsgs {
|
|
if err := st.SaveMessage(ctx, "sess-durable", m); err != nil {
|
|
t.Fatalf("SaveMessage %q: %v", string(m.ID), err)
|
|
}
|
|
}
|
|
if err := st.Close(); err != nil {
|
|
t.Fatalf("Close: %v", err)
|
|
}
|
|
|
|
st2, err := OpenSQLiteSessionStore(path)
|
|
if err != nil {
|
|
t.Fatalf("reopen OpenSQLiteSessionStore: %v", err)
|
|
}
|
|
defer func() { _ = st2.Close() }()
|
|
|
|
got, err := st2.Get(ctx, "sess-durable")
|
|
if err != nil {
|
|
t.Fatalf("Get after reopen: %v", err)
|
|
}
|
|
if got == nil {
|
|
t.Fatal("expected session to survive close+reopen")
|
|
}
|
|
if *got != wantSC {
|
|
t.Errorf("session after reopen:\n got %+v\nwant %+v", *got, wantSC)
|
|
}
|
|
|
|
hist, err := st2.RecentMessages(ctx, "sess-durable", 10)
|
|
if err != nil {
|
|
t.Fatalf("RecentMessages after reopen: %v", err)
|
|
}
|
|
if len(hist) != len(wantMsgs) {
|
|
t.Fatalf("history after reopen: got %d messages, want %d", len(hist), len(wantMsgs))
|
|
}
|
|
for i, m := range hist {
|
|
want := wantMsgs[i]
|
|
if m.ID != want.ID || m.SourceID != want.SourceID ||
|
|
m.Sender != want.Sender || m.Role != want.Role || m.Text != want.Text || !m.At.Equal(want.At) {
|
|
t.Errorf("message %d after reopen:\n got %+v\nwant %+v", i, m, want)
|
|
}
|
|
}
|
|
|
|
// The FTS index is trigger-maintained, so it must survive reopen too.
|
|
page, err := st2.SearchMessages(ctx, "sess-durable", MessageQuery{Query: "durable"})
|
|
if err != nil {
|
|
t.Fatalf("SearchMessages after reopen: %v", err)
|
|
}
|
|
if len(page.Messages) != len(wantMsgs) {
|
|
t.Errorf("search after reopen: got %d matches, want %d", len(page.Messages), len(wantMsgs))
|
|
}
|
|
|
|
var check string
|
|
if err := sqliteStoreDB(t, st2).QueryRowContext(ctx, "PRAGMA quick_check").Scan(&check); err != nil {
|
|
t.Fatalf("PRAGMA quick_check: %v", err)
|
|
}
|
|
if check != "ok" {
|
|
t.Errorf("PRAGMA quick_check = %q, want ok", check)
|
|
}
|
|
}
|
|
|
|
// TestSQLiteSessionStore_DeleteAbortRollsBack pins that Delete rolls its
|
|
// transaction back when a statement fails mid-operation: the messages DELETE
|
|
// has already run inside the transaction when the sessions DELETE trips the
|
|
// abort trigger, so the rollback must restore the session, its history, its
|
|
// count, and its search results.
|
|
func TestSQLiteSessionStore_DeleteAbortRollsBack(t *testing.T) {
|
|
ctx := context.Background()
|
|
st := newTestSQLiteStore(t)
|
|
|
|
sc := SessionContext{
|
|
SessionID: "sess-del-abort",
|
|
Source: SessionSource{Platform: "web", ChannelID: "c"},
|
|
Title: "keep me",
|
|
CreatedAt: sqliteBase(), LastActiveAt: sqliteBase(),
|
|
}
|
|
if err := st.Save(ctx, sc); err != nil {
|
|
t.Fatalf("Save: %v", err)
|
|
}
|
|
seed := []messaging.Message{
|
|
{Sender: "alice", Role: messaging.RoleUser, Text: "alpha", At: sqliteBase()},
|
|
{Sender: "bob", Role: messaging.RoleUser, Text: "beta", At: sqliteBase().Add(time.Second)},
|
|
{Sender: "carol", Role: messaging.RoleUser, Text: "gamma", At: sqliteBase().Add(2 * time.Second)},
|
|
}
|
|
for _, m := range seed {
|
|
if err := st.SaveMessage(ctx, "sess-del-abort", m); err != nil {
|
|
t.Fatalf("SaveMessage: %v", err)
|
|
}
|
|
}
|
|
|
|
installAbortTrigger(t, st, `BEFORE DELETE ON sessions WHEN old.session_id = 'sess-del-abort'`)
|
|
|
|
if err := st.Delete(ctx, "sess-del-abort"); err == nil {
|
|
t.Fatal("expected Delete to fail from the forced abort trigger")
|
|
}
|
|
|
|
got, err := st.Get(ctx, "sess-del-abort")
|
|
if err != nil {
|
|
t.Fatalf("Get after failed Delete: %v", err)
|
|
}
|
|
if got == nil || *got != sc {
|
|
t.Errorf("session after failed Delete: got %+v, want %+v", got, sc)
|
|
}
|
|
|
|
hist, err := st.RecentMessages(ctx, "sess-del-abort", 10)
|
|
if err != nil {
|
|
t.Fatalf("RecentMessages after failed Delete: %v", err)
|
|
}
|
|
if len(hist) != len(seed) {
|
|
t.Fatalf("history after failed Delete: got %d messages, want %d", len(hist), len(seed))
|
|
}
|
|
for i, m := range hist {
|
|
if m.Text != seed[i].Text || m.Sender != seed[i].Sender {
|
|
t.Errorf("message %d after failed Delete: got %+v, want text %q from %q", i, m, seed[i].Text, seed[i].Sender)
|
|
}
|
|
}
|
|
|
|
count, err := st.MessageCount(ctx, "sess-del-abort")
|
|
if err != nil {
|
|
t.Fatalf("MessageCount after failed Delete: %v", err)
|
|
}
|
|
if count != len(seed) {
|
|
t.Errorf("count after failed Delete: got %d, want %d", count, len(seed))
|
|
}
|
|
|
|
// The FTS index must match the rolled-back history.
|
|
page, err := st.SearchMessages(ctx, "sess-del-abort", MessageQuery{Query: "beta"})
|
|
if err != nil {
|
|
t.Fatalf("SearchMessages after failed Delete: %v", err)
|
|
}
|
|
if len(page.Messages) != 1 {
|
|
t.Errorf("search after failed Delete: got %d matches, want 1", len(page.Messages))
|
|
}
|
|
}
|
|
|
|
// TestSQLiteSessionStore_ReplaceMessagesAbortRollsBack pins that
|
|
// ReplaceMessages rolls its transaction back when the delete-old step fails
|
|
// mid-operation: the replacement inserts have already landed in the
|
|
// transaction when the abort fires, so the rollback must remove the
|
|
// replacement and restore the original history, count, and search results.
|
|
func TestSQLiteSessionStore_ReplaceMessagesAbortRollsBack(t *testing.T) {
|
|
ctx := context.Background()
|
|
st := newTestSQLiteStore(t)
|
|
|
|
seed := []messaging.Message{
|
|
{ID: "m-0", SourceID: "s-0", Sender: "alice", Role: messaging.RoleUser, Text: "alpha", At: sqliteBase()},
|
|
{ID: "m-1", SourceID: "s-1", Sender: "bob", Role: messaging.RoleUser, Text: "beta", At: sqliteBase().Add(time.Second)},
|
|
{ID: "m-2", SourceID: "s-2", Sender: "carol", Role: messaging.RoleUser, Text: "gamma", At: sqliteBase().Add(2 * time.Second)},
|
|
}
|
|
if err := st.SaveMessages(ctx, "sess-replace-abort", seed); err != nil {
|
|
t.Fatalf("SaveMessages: %v", err)
|
|
}
|
|
|
|
// Guard an original row so the abort fires only after the replacement
|
|
// inserts have landed inside the transaction.
|
|
installAbortTrigger(t, st, `BEFORE DELETE ON messages WHEN old.message_id = 'm-1'`)
|
|
|
|
replacement := []messaging.Message{{Sender: "summarizer", Role: messaging.RoleUser, Text: "merged summary", At: sqliteBase().Add(time.Hour)}}
|
|
if err := st.ReplaceMessages(ctx, "sess-replace-abort", replacement, supersededIDs(ctx, t, st, "sess-replace-abort")); err == nil {
|
|
t.Fatal("expected ReplaceMessages to fail from the forced abort trigger")
|
|
}
|
|
|
|
hist, err := st.RecentMessages(ctx, "sess-replace-abort", 10)
|
|
if err != nil {
|
|
t.Fatalf("RecentMessages after failed ReplaceMessages: %v", err)
|
|
}
|
|
if len(hist) != len(seed) {
|
|
t.Fatalf("history after failed ReplaceMessages: got %d messages, want %d", len(hist), len(seed))
|
|
}
|
|
for i, m := range hist {
|
|
if string(m.ID) != string(seed[i].ID) || m.Text != seed[i].Text || m.Sender != seed[i].Sender {
|
|
t.Errorf("message %d after failed ReplaceMessages: got %+v, want %+v", i, m, seed[i])
|
|
}
|
|
}
|
|
|
|
count, err := st.MessageCount(ctx, "sess-replace-abort")
|
|
if err != nil {
|
|
t.Fatalf("MessageCount after failed ReplaceMessages: %v", err)
|
|
}
|
|
if count != len(seed) {
|
|
t.Errorf("count after failed ReplaceMessages: got %d, want %d", count, len(seed))
|
|
}
|
|
|
|
page, err := st.SearchMessages(ctx, "sess-replace-abort", MessageQuery{Query: "beta"})
|
|
if err != nil {
|
|
t.Fatalf("SearchMessages after failed ReplaceMessages: %v", err)
|
|
}
|
|
if len(page.Messages) != 1 {
|
|
t.Errorf("search 'beta' after failed ReplaceMessages: got %d matches, want 1", len(page.Messages))
|
|
}
|
|
page, err = st.SearchMessages(ctx, "sess-replace-abort", MessageQuery{Query: "summary"})
|
|
if err != nil {
|
|
t.Fatalf("SearchMessages after failed ReplaceMessages: %v", err)
|
|
}
|
|
if len(page.Messages) != 0 {
|
|
t.Errorf("search 'summary' after failed ReplaceMessages: got %d matches, want 0 (replacement must be rolled back)", len(page.Messages))
|
|
}
|
|
}
|
|
|
|
// ── FTS lifecycle and literal-query semantics (bead 8u8.4) ──────────────────
|
|
//
|
|
// The shared 19-group conformance suite (sessionstore_conformance_test.go)
|
|
// proves behaviour through the SessionStore interface, but two properties are
|
|
// SQLite-specific and cannot be expressed there: the trigger-maintained FTS5
|
|
// index must stay consistent as history mutates, and free-text queries must
|
|
// survive hostile input. These tests are SQLite-only and assert exact
|
|
// results -- not merely the absence of panics.
|
|
|
|
// sameTexts compares two text slices as sets: same length, same members,
|
|
// order-insensitive. FTS pages are ranked by bm25, so order is a ranking
|
|
// detail rather than part of the match contract.
|
|
func sameTexts(a, b []string) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
seen := make(map[string]int, len(a))
|
|
for _, s := range a {
|
|
seen[s]++
|
|
}
|
|
for _, s := range b {
|
|
seen[s]--
|
|
if seen[s] < 0 {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// ftsIntegrityErr runs the documented FTS5 external-content integrity
|
|
// check (`INSERT INTO ...(table, rank) VALUES('integrity-check', 1)`) against
|
|
// the store's raw handle and returns any error it reports. A consistent
|
|
// index reports no error; a stale entry -- a content row deleted without the
|
|
// AFTER DELETE trigger firing -- reports "database disk image is malformed".
|
|
// Search/count joins can never surface such an entry because they only see
|
|
// index rows whose content row still exists, so this is the one check that
|
|
// detects an orphaned index.
|
|
func ftsIntegrityErr(t *testing.T, st SessionStore) error {
|
|
t.Helper()
|
|
_, err := sqliteStoreDB(t, st).ExecContext(context.Background(),
|
|
`INSERT INTO messages_fts(messages_fts, rank) VALUES('integrity-check', 1)`)
|
|
return err
|
|
}
|
|
|
|
// TestSQLiteSessionStore_FTSStaysCorrectThroughMutations pins that the FTS5
|
|
// index follows every message mutation: DeleteRecentMessages removes the
|
|
// newest documents, ReplaceMessages swaps the whole document set, and Delete
|
|
// clears the session -- with search results and counts tracking the surviving
|
|
// history and never leaking across sessions.
|
|
func TestSQLiteSessionStore_FTSStaysCorrectThroughMutations(t *testing.T) {
|
|
// Sessions "a" and "b" share the term "needle", so any cross-session
|
|
// leak in search or count is caught; "marker" lives only in "b".
|
|
seedA := []string{"needle alpha", "filler one", "needle beta", "filler two"}
|
|
seedB := []string{"needle gamma", "distinct marker"}
|
|
|
|
tests := []struct {
|
|
name string
|
|
mutate func(ctx context.Context, t *testing.T, st SessionStore) error
|
|
wantA []string // session a history after the mutation
|
|
wantANeedle []string // session a search "needle"
|
|
wantACount int
|
|
wantAMarker []string // session a search "marker" (only in b)
|
|
wantBNeedle []string // session b search "needle" (must stay intact)
|
|
wantBCount int
|
|
}{
|
|
{
|
|
name: "DeleteRecentMessages prunes the index newest-first",
|
|
mutate: func(ctx context.Context, t *testing.T, st SessionStore) error {
|
|
deleted, err := st.DeleteRecentMessages(ctx, "a", 2)
|
|
if err == nil && deleted != 2 {
|
|
t.Errorf("deleted %d messages, want 2", deleted)
|
|
}
|
|
return err
|
|
},
|
|
wantA: []string{"needle alpha", "filler one"},
|
|
wantANeedle: []string{"needle alpha"},
|
|
wantACount: 2,
|
|
wantAMarker: nil,
|
|
wantBNeedle: []string{"needle gamma"},
|
|
wantBCount: 2,
|
|
},
|
|
{
|
|
name: "ReplaceMessages swaps the document set",
|
|
mutate: func(ctx context.Context, t *testing.T, st SessionStore) error {
|
|
return st.ReplaceMessages(ctx, "a", []messaging.Message{{
|
|
Sender: "summarizer", Role: messaging.RoleUser, Text: "merged needle summary", At: sqliteBase().Add(time.Hour),
|
|
}}, supersededIDs(ctx, t, st, "a"))
|
|
},
|
|
wantA: []string{"merged needle summary"},
|
|
wantANeedle: []string{"merged needle summary"},
|
|
wantACount: 1,
|
|
wantAMarker: nil,
|
|
wantBNeedle: []string{"needle gamma"},
|
|
wantBCount: 2,
|
|
},
|
|
{
|
|
name: "Delete clears the session's index",
|
|
mutate: func(ctx context.Context, t *testing.T, st SessionStore) error {
|
|
return st.Delete(ctx, "a")
|
|
},
|
|
wantA: nil,
|
|
wantANeedle: nil,
|
|
wantACount: 0,
|
|
wantAMarker: nil,
|
|
wantBNeedle: []string{"needle gamma"},
|
|
wantBCount: 2,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
// Subtest-local context: mutation closures receive it as a
|
|
// parameter instead of capturing the outer function's.
|
|
ctx := context.Background()
|
|
st := newTestSQLiteStore(t)
|
|
|
|
for i, text := range seedA {
|
|
if err := st.SaveMessage(ctx, "a", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil {
|
|
t.Fatalf("SaveMessage a %q: %v", text, err)
|
|
}
|
|
}
|
|
for i, text := range seedB {
|
|
if err := st.SaveMessage(ctx, "b", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil {
|
|
t.Fatalf("SaveMessage b %q: %v", text, err)
|
|
}
|
|
}
|
|
|
|
if err := tc.mutate(ctx, t, st); err != nil {
|
|
t.Fatalf("mutate: %v", err)
|
|
}
|
|
|
|
// The index must be internally consistent with the surviving
|
|
// history, not merely join-visible: an orphaned entry would be
|
|
// invisible to the search/count joins below, so check the index
|
|
// itself after every mutation.
|
|
if err := ftsIntegrityErr(t, st); err != nil {
|
|
t.Fatalf("FTS5 integrity check after %q: %v", tc.name, err)
|
|
}
|
|
|
|
hist, err := st.RecentMessages(ctx, "a", 100)
|
|
if err != nil {
|
|
t.Fatalf("RecentMessages a: %v", err)
|
|
}
|
|
if !equal(texts(hist), tc.wantA) {
|
|
t.Errorf("session a history = %v, want %v", texts(hist), tc.wantA)
|
|
}
|
|
|
|
assertSearch := func(session, term string, want []string) {
|
|
t.Helper()
|
|
page, err := st.SearchMessages(ctx, session, MessageQuery{Query: term, Limit: 100})
|
|
if err != nil {
|
|
t.Fatalf("SearchMessages(%s, %q): %v", session, term, err)
|
|
}
|
|
if !sameTexts(texts(page.Messages), want) {
|
|
t.Errorf("search %s %q = %v, want %v", session, term, texts(page.Messages), want)
|
|
}
|
|
if page.Truncated || page.HasMore {
|
|
t.Errorf("search %s %q: Truncated=%v HasMore=%v, want false/false", session, term, page.Truncated, page.HasMore)
|
|
}
|
|
}
|
|
|
|
assertSearch("a", "needle", tc.wantANeedle)
|
|
assertSearch("a", "marker", tc.wantAMarker)
|
|
assertSearch("b", "needle", tc.wantBNeedle)
|
|
|
|
for _, sc := range []struct {
|
|
session string
|
|
want int
|
|
}{
|
|
{"a", tc.wantACount}, {"b", tc.wantBCount},
|
|
} {
|
|
count, err := st.MessageCount(ctx, sc.session)
|
|
if err != nil {
|
|
t.Fatalf("MessageCount %s: %v", sc.session, err)
|
|
}
|
|
if count != sc.want {
|
|
t.Errorf("MessageCount %s = %d, want %d", sc.session, count, sc.want)
|
|
}
|
|
}
|
|
|
|
histB, err := st.RecentMessages(ctx, "b", 100)
|
|
if err != nil {
|
|
t.Fatalf("RecentMessages b: %v", err)
|
|
}
|
|
if !equal(texts(histB), seedB) {
|
|
t.Errorf("session b history = %v, want untouched %v", texts(histB), seedB)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestSQLiteSessionStore_FTSIntegrityCheckDetectsOrphanedIndex proves the
|
|
// integrity check used by the lifecycle test is load-bearing: with the AFTER
|
|
// DELETE trigger temporarily dropped, a store mutation leaves a stale
|
|
// messages_fts entry that the check must report, while the same mutation with
|
|
// the trigger intact leaves a consistent index.
|
|
func TestSQLiteSessionStore_FTSIntegrityCheckDetectsOrphanedIndex(t *testing.T) {
|
|
t.Run("stale index entry fails the check", func(t *testing.T) {
|
|
ctx := context.Background()
|
|
st := newTestSQLiteStore(t)
|
|
|
|
for i, text := range []string{"needle one", "needle two"} {
|
|
if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil {
|
|
t.Fatalf("SaveMessage: %v", err)
|
|
}
|
|
}
|
|
|
|
// Bypass the AFTER DELETE trigger so the index keeps a row for the
|
|
// deleted message.
|
|
if _, err := sqliteStoreDB(t, st).ExecContext(ctx, `DROP TRIGGER messages_ad`); err != nil {
|
|
t.Fatalf("drop delete trigger: %v", err)
|
|
}
|
|
if _, err := st.DeleteRecentMessages(ctx, "sess", 1); err != nil {
|
|
t.Fatalf("DeleteRecentMessages: %v", err)
|
|
}
|
|
|
|
if err := ftsIntegrityErr(t, st); err == nil {
|
|
t.Fatal("FTS5 integrity check passed despite a stale index entry (delete trigger bypassed)")
|
|
}
|
|
})
|
|
|
|
t.Run("trigger-maintained delete keeps the index consistent", func(t *testing.T) {
|
|
ctx := context.Background()
|
|
st := newTestSQLiteStore(t)
|
|
|
|
for i, text := range []string{"needle one", "needle two"} {
|
|
if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil {
|
|
t.Fatalf("SaveMessage: %v", err)
|
|
}
|
|
}
|
|
if _, err := st.DeleteRecentMessages(ctx, "sess", 1); err != nil {
|
|
t.Fatalf("DeleteRecentMessages: %v", err)
|
|
}
|
|
|
|
if err := ftsIntegrityErr(t, st); err != nil {
|
|
t.Fatalf("FTS5 integrity check failed after trigger-maintained delete: %v", err)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestSQLiteSessionStore_HostileQueriesAreLiteral pins that free-text input
|
|
// is never executed as FTS5 query syntax: column filters, the NEAR operator,
|
|
// prefix wildcards, and boolean operators must all be treated as literal
|
|
// terms (or, for a bare "*", an empty phrase) without syntax errors. Each
|
|
// row asserts the exact match set, not merely the absence of a panic.
|
|
func TestSQLiteSessionStore_HostileQueriesAreLiteral(t *testing.T) {
|
|
ctx := context.Background()
|
|
st := newTestSQLiteStore(t)
|
|
|
|
seed := []string{
|
|
"text:hello here", // phrase (text, hello)
|
|
"hello there", // would match a raw "text:hello" column filter
|
|
"hello world",
|
|
`hello "world quote`, // unmatched-quote input must still find this
|
|
"near a b", // phrase (near, a) AND token b
|
|
"a far b", // would match a raw NEAR(a b) operator
|
|
"star * symbol", // "*" is a separator: never a token, never matches
|
|
"needle or elsewhere",
|
|
"needle elsewhere", // would match a raw OR query
|
|
"needle",
|
|
"alpha beta gamma", // both AND terms present
|
|
"alpha alone",
|
|
"beta alone",
|
|
}
|
|
for i, text := range seed {
|
|
if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil {
|
|
t.Fatalf("SaveMessage %q: %v", text, err)
|
|
}
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
query string
|
|
want []string
|
|
}{
|
|
{"column syntax is a literal phrase, not a column filter", "text:hello", []string{"text:hello here"}},
|
|
{"unmatched quote is literal, not a syntax error", `hello "world`, []string{"hello world", `hello "world quote`}},
|
|
{"NEAR syntax is literal, not the NEAR operator", "NEAR(a b)", []string{"near a b"}},
|
|
{"bare wildcard is an empty phrase, not a prefix operator", "*", nil},
|
|
{"OR is a literal term, not the boolean operator", "needle OR elsewhere", []string{"needle or elsewhere"}},
|
|
{"multi-term query pins AND semantics", "alpha beta", []string{"alpha beta gamma"}},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
page, err := st.SearchMessages(ctx, "sess", MessageQuery{Query: tc.query, Limit: 100})
|
|
if err != nil {
|
|
t.Fatalf("SearchMessages(%q): %v", tc.query, err)
|
|
}
|
|
if !sameTexts(texts(page.Messages), tc.want) {
|
|
t.Errorf("query %q matched %v, want %v", tc.query, texts(page.Messages), tc.want)
|
|
}
|
|
if page.Truncated || page.HasMore {
|
|
t.Errorf("query %q: Truncated=%v HasMore=%v, want false/false", tc.query, page.Truncated, page.HasMore)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestFTSMatchQueryEscapesHostileInput pins the exact MATCH expression the
|
|
// store generates: every whitespace-separated term becomes a quoted phrase
|
|
// (embedded quotes doubled), joined by explicit AND, so user input can never
|
|
// reach the FTS5 parser as query syntax.
|
|
func TestFTSMatchQueryEscapesHostileInput(t *testing.T) {
|
|
tests := []struct{ in, want string }{
|
|
{"", ""},
|
|
{" ", ""},
|
|
{"alpha beta", `"alpha" AND "beta"`},
|
|
{"needle OR elsewhere", `"needle" AND "OR" AND "elsewhere"`},
|
|
{"text:hello", `"text:hello"`},
|
|
{`hello "world`, `"hello" AND """world"`},
|
|
{"NEAR(a b)", `"NEAR(a" AND "b)"`},
|
|
{"*", `"*"`},
|
|
}
|
|
for _, tc := range tests {
|
|
if got := ftsMatchQuery(tc.in); got != tc.want {
|
|
t.Errorf("ftsMatchQuery(%q) = %q, want %q", tc.in, got, tc.want)
|
|
}
|
|
}
|
|
}
|