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 }