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) } } // TestSQLiteSessionStore_SenderIDRoundTrips proves the channel-native // participant identifier survives both history reads -- the ordered // RecentMessages and the ranked SearchMessages -- and that a record with no // sender id round-trips as empty rather than erroring. func TestSQLiteSessionStore_SenderIDRoundTrips(t *testing.T) { st := newTestSQLiteStore(t) ctx := context.Background() if err := st.SaveMessage(ctx, "sess", messaging.Message{ SourceID: "tg-1", Sender: "alice", SenderID: "u-42", Role: messaging.RoleUser, Text: "hello there", At: sqliteBase(), }); err != nil { t.Fatalf("SaveMessage: %v", err) } if err := st.SaveMessage(ctx, "sess", messaging.Message{ Sender: "archie", Role: messaging.RoleAssistant, Text: "hi", At: sqliteBase().Add(time.Second), }); err != nil { t.Fatalf("SaveMessage(no sender id): %v", err) } hist, err := st.RecentMessages(ctx, "sess", 10) if err != nil { t.Fatalf("RecentMessages: %v", err) } if len(hist) != 2 { t.Fatalf("RecentMessages = %d messages, want 2", len(hist)) } if hist[0].SenderID != "u-42" { t.Errorf("RecentMessages()[0].SenderID = %q, want %q", hist[0].SenderID, "u-42") } if hist[1].SenderID != "" { t.Errorf("RecentMessages()[1].SenderID = %q, want empty", hist[1].SenderID) } page, err := st.SearchMessages(ctx, "sess", MessageQuery{Query: "hello", Limit: 10}) if err != nil { t.Fatalf("SearchMessages: %v", err) } if len(page.Messages) != 1 || page.Messages[0].SenderID != "u-42" { t.Errorf("SearchMessages() = %+v, want one match with SenderID u-42", page.Messages) } } 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\tsender_id 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)) } } // TestSQLiteSessionStore_MigratesPreSenderIDDatabase simulates a database // created before sender_id existed: a role-era schema with no sender_id // column. Opening it must add the column with an empty default, leave the // existing rows readable, and stay clean across a second open. func TestSQLiteSessionStore_MigratesPreSenderIDDatabase(t *testing.T) { path := filepath.Join(t.TempDir(), "old-sender.db") db, err := sql.Open("sqlite", sqliteSessionDSN(path)) if err != nil { t.Fatalf("open raw db: %v", err) } oldMessages := strings.Replace(sqliteSessionSchema, "\tsender_id 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, role, text, ts) VALUES ('m-user', 'sess-old', 'tg-1', 'alice', 'user', 'hello', ?)`, millis); err != nil { t.Fatalf("seed old message: %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) != 1 { t.Fatalf("history = %d messages, want 1", len(hist)) } if hist[0].Sender != "alice" || hist[0].SenderID != "" { t.Errorf("migrated message = %+v, want sender alice with empty SenderID", hist[0]) } // The second open takes the duplicate-column path; it must not fail. again, err := OpenSQLiteSessionStore(path) if err != nil { t.Fatalf("second reopen: %v", err) } t.Cleanup(func() { _ = again.Close() }) if _, err := again.RecentMessages(context.Background(), "sess-old", 10); err != nil { t.Fatalf("RecentMessages after second reopen: %v", err) } } 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) } } }