Files
pages/internal/store/search_test.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

322 lines
11 KiB
Go

package store_test
import (
"context"
"fmt"
"strings"
"testing"
"pageswiki/internal/db"
"pageswiki/internal/store"
)
func TestSearchUsesLatestTextRevisionAndCurrentPath(t *testing.T) {
database, err := db.Open(t.TempDir() + "/pages.db")
if err != nil {
t.Fatal(err)
}
defer database.Close()
if err := db.Migrate(database); err != nil {
t.Fatal(err)
}
st := store.New(database)
objectUUID, err := st.CreatePageAtPath("/docs/guide")
if err != nil {
t.Fatal(err)
}
if _, err := st.SaveRevisionContent(
objectUUID, []byte("古い検索語"), "", "ja",
"text/plain; charset=utf-8", "guide.txt",
); err != nil {
t.Fatal(err)
}
if _, err := st.SaveRevisionContent(
objectUUID, []byte("新しい検索語と本文"), "", "ja",
"text/plain; charset=utf-8", "guide.txt",
); err != nil {
t.Fatal(err)
}
results, err := st.SearchPathsInDomain(
defaultDomainUUID(t, st), "/docs", "新しい", 10,
)
if err != nil {
t.Fatal(err)
}
if len(results) != 1 || results[0].Path != "/docs/guide" {
t.Fatalf("new body results = %#v", results)
}
results, err = st.SearchPathsInDomain(
defaultDomainUUID(t, st), "/docs", "古い", 10,
)
if err != nil {
t.Fatal(err)
}
if len(results) != 0 {
t.Fatalf("old body unexpectedly matched: %#v", results)
}
if err := st.RenamePath("/docs/guide", "/docs/manual"); err != nil {
t.Fatal(err)
}
results, err = st.SearchPathsInDomain(
defaultDomainUUID(t, st), "/docs", "manual", 10,
)
if err != nil {
t.Fatal(err)
}
if len(results) != 1 || results[0].Path != "/docs/manual" {
t.Fatalf("renamed path results = %#v", results)
}
}
func searchStoreFixture(t *testing.T) *store.Store {
t.Helper()
database, err := db.Open(t.TempDir() + "/search.db")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { database.Close() })
if err := db.Migrate(database); err != nil {
t.Fatal(err)
}
return store.New(database)
}
func TestSearchLiteralScopeAndMatchSources(t *testing.T) {
st := searchStoreFixture(t)
domain := defaultDomainUUID(t, st)
for _, path := range []string{"/docs_%/literal_%", "/docsXY/literal-any", "/docs_%extra/literal_%", "/docs_%/body"} {
object, err := st.CreatePageAtPathInDomain(domain, path)
if err != nil {
t.Fatal(err)
}
filename, body := "report_annual.txt", "Some surrounding context about nebula and stars."
if strings.HasSuffix(path, "body") {
filename = "body.txt"
}
if _, err := st.SaveRevisionContent(object, []byte(body), "", "en", "text/plain", filename); err != nil {
t.Fatal(err)
}
}
results, err := st.SearchPathsInDomain(domain, "/docs_%", "literal_%", 20)
if err != nil || len(results) != 1 || results[0].Path != "/docs_%/literal_%" || !results[0].PathMatch || results[0].BodyMatch {
t.Fatalf("literal search: %#v %v", results, err)
}
results, err = st.SearchPathsInDomain(domain, "/docs_%", "annual report", 20)
if err != nil || len(results) != 1 || !results[0].FilenameMatch || results[0].BodyMatch {
t.Fatalf("filename prefix source: %#v %v", results, err)
}
results, err = st.SearchPathsInDomain(domain, "/docs_%", "nebula", 20)
if err != nil || len(results) != 2 || !results[0].BodyMatch || !strings.Contains(results[0].Excerpt, "nebula") || results[0].FilenameMatch {
t.Fatalf("body context: %#v %v", results, err)
}
for _, query := range []string{"%", "_", `" OR *`, `NEAR(`, `body:nebula`} {
if _, err := st.SearchPathsInDomain(domain, "/docs_%", query, 20); err != nil {
t.Fatalf("literal syntax %q: %v", query, err)
}
}
}
func TestSearchFiltersBeforeLimitAndBoundsCandidates(t *testing.T) {
st := searchStoreFixture(t)
domain := defaultDomainUUID(t, st)
object, err := st.CreatePageAtPathInDomain(domain, "/items/base")
if err != nil {
t.Fatal(err)
}
if _, err := st.SaveRevisionContent(object, []byte("needle context"), "", "en", "text/plain", "document.txt"); err != nil {
t.Fatal(err)
}
tx, err := st.DB.Begin()
if err != nil {
t.Fatal(err)
}
for i := 0; i < store.SearchCandidateLimit+50; i++ {
if _, err := tx.Exec(`INSERT INTO paths(domain_uuid,path,object_uuid,created_at,is_primary) VALUES(?,?,?,1,0)`, domain, fmt.Sprintf("/items/needle-%04d", i), object); err != nil {
tx.Rollback()
t.Fatal(err)
}
}
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
calls := 0
results, err := st.SearchPathsInDomainFiltered(context.Background(), domain, "/items", "needle-", 3, func(path string) bool {
calls++
return strings.HasSuffix(path, "0004") || strings.HasSuffix(path, "0005")
})
if err != nil || len(results) != 2 || calls > 3*store.SearchCandidateLimit {
t.Fatalf("filter/limit: results=%#v calls=%d err=%v", results, calls, err)
}
if _, err := st.SearchPathsInDomain(domain, "/", strings.Repeat("a", 513), 10); err == nil {
t.Fatal("oversized query accepted")
}
ctx, cancel := context.WithCancel(context.Background())
cancel()
if _, err := st.SearchPathsInDomainFiltered(ctx, domain, "/", "needle", 10, func(string) bool { return true }); err == nil {
t.Fatal("canceled query succeeded")
}
if results, err := st.SearchPathsInDomainFiltered(context.Background(), domain, "/", "needle", 10, nil); err != nil || len(results) != 0 {
t.Fatal("missing authorization filter returned results")
}
}
func TestSearchKeepsDomainAliasesSeparate(t *testing.T) {
st := searchStoreFixture(t)
first, err := st.GetDefaultDomain()
if err != nil {
t.Fatal(err)
}
if err := st.CreateDomain(first.CampusUUID, "search-other", "Other", "search-other", "local", "", "", true); err != nil {
t.Fatal(err)
}
domains, err := st.ListDomains()
if err != nil {
t.Fatal(err)
}
for _, domain := range domains {
object, err := st.CreatePageAtPathInDomain(domain.UUID, "/same-path")
if err != nil {
t.Fatal(err)
}
body := "OTHER_DOMAIN_MARKER"
if domain.UUID == first.UUID {
body = "FIRST_DOMAIN_MARKER"
}
if _, err := st.SaveRevisionContent(object, []byte(body), "", "en", "text/plain", "same-name.txt"); err != nil {
t.Fatal(err)
}
}
results, err := st.SearchPathsInDomain(first.UUID, "/", "OTHER_DOMAIN_MARKER", 10)
if err != nil || len(results) != 0 {
t.Fatalf("other Domain body leaked: %#v %v", results, err)
}
results, err = st.SearchPathsInDomain(first.UUID, "/", "FIRST_DOMAIN_MARKER", 10)
if err != nil || len(results) != 1 || !strings.Contains(results[0].Excerpt, "FIRST_DOMAIN_MARKER") {
t.Fatalf("current Domain result: %#v %v", results, err)
}
}
func TestSearchManyPagesPreservesCurrentRowsAndExcerpts(t *testing.T) {
st := searchStoreFixture(t)
domain := defaultDomainUUID(t, st)
tx, err := st.DB.Begin()
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
for i := 0; i < 600; i++ {
object := fmt.Sprintf("search-object-%04d", i)
if _, err := tx.Exec(`INSERT INTO objects(uuid,kind,created_at) VALUES(?,'page',1)`, object); err != nil {
t.Fatal(err)
}
if _, err := tx.Exec(`INSERT INTO paths(domain_uuid,path,object_uuid,created_at,is_primary) VALUES(?,?,?,1,1)`, domain, fmt.Sprintf("/collection/page-%04d", i), object); err != nil {
t.Fatal(err)
}
for revision := 0; revision < 2; revision++ {
body := "outdated needle " + strings.Repeat("obsolete context ", 64)
if revision == 1 {
body = fmt.Sprintf("Current needle marker%04d; ", i) + strings.Repeat("surrounding text ", 64)
}
if _, err := tx.Exec(`INSERT INTO revisions(uuid,object_uuid,body,document_hash,lang,content_type,filename,message,created_at_ms,created_at)
VALUES(?,?,?,'','en','text/plain','needle.txt','',?,?)`, fmt.Sprintf("search-revision-%04d-%d", i, revision), object, body, (revision+1)*1000, revision+1); err != nil {
t.Fatal(err)
}
}
}
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
// Exercise 1,200 FTS rows, current-only filtering, both candidate streams,
// display clipping and the rowid-based batched snippet lookup together.
results, err := st.SearchPathsInDomainFiltered(context.Background(), domain, "/collection", "needle", 100, func(path string) bool {
return !strings.HasSuffix(path, "0000")
})
if err != nil || len(results) != 100 {
t.Fatalf("large search rows=%d err=%v", len(results), err)
}
for i, result := range results {
want := fmt.Sprintf("/collection/page-%04d", i+1)
if result.Path != want || !result.BodyMatch || !result.FilenameMatch || strings.Contains(result.Excerpt, "outdated") {
t.Fatalf("result %d mismatched current excerpt/source: %+v", i, result)
}
// Race instrumentation can spend the optional 400ms snippet budget.
// Hits must still be returned, with either the correct excerpt or an
// explicit omission, never an old/wrong Revision or silent blank text.
if result.ExcerptOmitted {
if result.Excerpt != "" {
t.Fatal("omitted result contains excerpt text")
}
} else if !strings.Contains(result.Excerpt, fmt.Sprintf("marker%04d", i+1)) {
t.Fatalf("result %d has wrong current excerpt: %+v", i, result)
}
}
}
func TestSearchExcerptInputBudgetsKeepHitsAndDeduplicateAliases(t *testing.T) {
st := searchStoreFixture(t)
domain := defaultDomainUUID(t, st)
const size = 48 << 10
for i := 0; i < 30; i++ {
object, err := st.CreatePageAtPathInDomain(domain, fmt.Sprintf("/items/page-%02d", i))
if err != nil {
t.Fatal(err)
}
if _, err := st.SaveRevisionContent(object, []byte("needle "+strings.Repeat(" ", size-7)), "", "en", "text/plain", "entry.txt"); err != nil {
t.Fatal(err)
}
if i == 0 {
if _, err := st.DB.Exec(`INSERT INTO paths(domain_uuid,path,object_uuid,created_at,is_primary) VALUES(?,?,?,1,0)`, domain, "/items/page-xx", object); err != nil {
t.Fatal(err)
}
}
}
object, err := st.CreatePageAtPathInDomain(domain, "/items/byte-limit")
if err != nil {
t.Fatal(err)
}
// Below 64K characters but above 64KiB: budgets count bytes, not runes.
if _, err := st.SaveRevisionContent(object, []byte("needle "+strings.Repeat("界", 23000)), "", "ja", "text/plain", "entry.txt"); err != nil {
t.Fatal(err)
}
results, err := st.SearchPathsInDomain(domain, "/items", "needle", 100)
if err != nil || len(results) != 32 {
t.Fatalf("budgeted search lost hits: rows=%d err=%v", len(results), err)
}
included := 0
for _, result := range results {
if !result.BodyMatch {
t.Fatalf("omitted excerpt lost body-match source: %+v", result)
}
if result.Path == "/items/byte-limit" && !result.ExcerptOmitted {
t.Fatal("multi-byte document bypassed byte budget")
}
if result.ExcerptOmitted {
if result.Excerpt != "" {
t.Fatal("omitted excerpt contains body")
}
} else {
included++
if !strings.Contains(result.Excerpt, "needle") {
t.Fatal("included excerpt lost matching term")
}
}
}
want := store.SearchExcerptTotalBytes/size + 1 // the alias reuses one excerpt
if included != want {
t.Fatalf("included excerpts=%d want=%d; alias must not consume input budget twice", included, want)
}
}
func defaultDomainUUID(t *testing.T, st *store.Store) string {
t.Helper()
domain, err := st.GetDefaultDomain()
if err != nil {
t.Fatal(err)
}
return domain.UUID
}