Files
pages/internal/store/search_backend_test.go
T
2026-11-15 05:47:14 +09:00

197 lines
8.1 KiB
Go

package store
import (
"context"
"errors"
"fmt"
"strings"
"testing"
"time"
)
func TestPostgreSQLMetadataSearch(t *testing.T) {
f := newPublicationBackend(t, storePostgreSQL)
s := f.s
for range 2 {
if err := s.EnsureSearchIndexSchema(); err != nil {
t.Fatal(err)
}
}
for i, entry := range []struct{ path, mime, filename, category string }{
{"/files/literal_%", "application/octet-stream", "code.py", "code"},
{"/files/pdf", "application/pdf; x=y", "report.txt", "pdf"},
{"/files/json", "application/ld+json", "", "json"},
{"/files/office", "application/vnd.ms-word.document.macroenabled.12", "", "office"},
{"/files/image", "image/png", "", "image"},
{"/files/archive", "application/octet-stream", "bundle.tar.gz", "archive"},
{"/files/audio", "audio/flac", "", "audio"},
{"/files/video", "video/mp4", "", "video"},
{"/files/text", "text/markdown", "", "text"},
{"/files/csv", "text/csv", "", "csv"},
{"/files/other", "application/unrecognized", "pretend.pdf", "other"},
{"/files/html", "text/html", "", "html"},
} {
id := fmt.Sprint(i)
f.page(id, entry.path, "r"+id, 2000)
f.exec(`UPDATE revisions SET content_type=$1,filename=$2,body='body-only-needle' WHERE uuid=$3`, entry.mime, entry.filename, "r"+id)
results, err := s.SearchPathsInDomainWithOptions(context.Background(), f.domain, "/files", "", 100, func(string) bool { return true }, SearchOptions{FileType: entry.category})
if err != nil || len(results) != 1 || results[0].Path != entry.path {
t.Fatalf("category %s: %+v %v", entry.category, results, err)
}
}
f.page("sibling", "/files-sibling/literal_%", "rs", 2000)
s.DB.SetMaxOpenConns(1)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
allowed := func(p string) bool {
var n int
if err := s.DB.QueryRowContext(ctx, `SELECT 1`).Scan(&n); err != nil {
t.Fatal(err)
}
return p != "/files/pdf"
}
for _, tc := range []struct {
scope, q string
n int
}{
{"/files", "_%", 1}, {"/files", "code.py", 1}, {"/files", "body-only-needle", 0}, {"/files", "report", 0}, {"/files", "' OR true --", 0},
} {
results, err := s.SearchPathsInDomainFiltered(ctx, f.domain, tc.scope, tc.q, 100, allowed)
if err != nil || len(results) != tc.n {
t.Fatalf("%+v: %+v %v", tc, results, err)
}
for _, r := range results {
if r.BodyMatch || r.Excerpt != "" {
t.Fatal("unexpected body hydration", r)
}
}
}
if results, err := s.SearchPathsInDomainFiltered(ctx, "outside", "/", "literal", 100, allowed); err != nil || len(results) != 0 {
t.Fatal(results, err)
}
from, before := int64(2000), int64(2001)
results, err := s.SearchPathsInDomainWithOptions(ctx, f.domain, "/files", "", 100, allowed, SearchOptions{Extension: "tar.gz", FromMS: &from, BeforeMS: &before})
if err != nil || len(results) != 1 || results[0].Filename != "bundle.tar.gz" {
t.Fatal(results, err)
}
before = 2000
if _, err = s.SearchPathsInDomainWithOptions(ctx, f.domain, "/files", "", 100, allowed, SearchOptions{FromMS: &from, BeforeMS: &before}); !errors.Is(err, ErrInvalidSearchOptions) {
t.Fatal(err)
}
if _, err = s.SearchPathsInDomainFiltered(ctx, f.domain, "/", strings.Repeat("x", 513), 100, allowed); err == nil {
t.Fatal("unbounded query")
}
suggestions, err := s.SearchPathSuggestionsInDomain(ctx, f.domain, "/files", "_%", 8, allowed)
if err != nil || len(suggestions) != 1 {
t.Fatal(suggestions, err)
}
canceled, stop := context.WithCancel(ctx)
stop()
if _, err = s.SearchPathsInDomainFiltered(canceled, f.domain, "/", "files", 100, allowed); !errors.Is(err, context.Canceled) {
t.Fatal(err)
}
}
func TestCitySearchBackend(t *testing.T) {
for _, backend := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(backend), func(t *testing.T) {
f := newPublicationBackend(t, backend)
s := f.s
f.page("page", "/news_%/st/sp", "rev", 1000)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
s.DB.SetMaxOpenConns(1)
blocked := ""
allowed := func(p string) bool {
var n int
if err := s.DB.QueryRowContext(ctx, `SELECT 1`).Scan(&n); err != nil {
t.Fatal(err)
}
return p != blocked
}
results, err := s.SearchCityInDomain(ctx, f.domain, "/", "_%", 30, allowed, SearchOptions{})
if err != nil || len(results) != 3 || results[0].Kind != "quartier" || results[2].Kind != "spot" || !results[2].HasPage {
t.Fatal(results, err)
}
blocked = "/news_%"
results, err = s.SearchCityInDomain(ctx, f.domain, "/", "sp", 30, allowed, SearchOptions{})
if err != nil || len(results) != 0 {
t.Fatal("parent ACL", results, err)
}
blocked = ""
from, before := int64(1), int64(2)
results, err = s.SearchCityInDomain(ctx, f.domain, "/news_%/st", "", 30, allowed, SearchOptions{FromMS: &from, BeforeMS: &before, DateField: "created"})
if err != nil || len(results) != 2 {
t.Fatal("dates/scope", results, err)
}
results, err = s.SearchCityInDomain(ctx, "outside", "/", "_%", 30, allowed, SearchOptions{})
if err != nil || len(results) != 0 {
t.Fatal("domain", results, err)
}
f.exec(`UPDATE spots SET path_prefix='/news_%/st/_undefined' WHERE uuid='sp'`)
results, err = s.SearchCityInDomain(ctx, f.domain, "/", "_undefined", 30, allowed, SearchOptions{})
if err != nil || len(results) != 1 || results[0].NavigationPath != "/news_%/st" {
t.Fatal(results, err)
}
})
}
}
func TestPostgreSQLHostedEditorGate(t *testing.T) {
s := testNamespaceStore(t, storePostgreSQL)
for range 2 {
if err := s.EnsureAdapterSessionsSchema(); err != nil {
t.Fatal(err)
}
}
if _, err := s.DB.Exec(`INSERT INTO adapter_sessions(ticket_hash,domain_uuid,plugin_id,object_uuid,base_revision_uuid,ticket_expires_at_ms,created_at_ms) VALUES('retained','d','code','o','r',1,1)`); err != nil {
t.Fatal(err)
}
_, e1 := s.IssueAdapterTicket("d", "code", "o", "r", "/")
_, _, e2 := s.ExchangeAdapterTicket("retained")
_, e3 := s.GetAdapterSession("retained")
_, e4 := s.SaveHostedRevision(nil, nil, "")
_, e5 := s.SaveHostedRevisionAt(nil, "", "", nil, "")
for _, err := range []error{e1, e2, e3, e4, e5} {
if !errors.Is(err, ErrBackendFeatureUnavailable) {
t.Fatal(err)
}
}
var count int
if err := s.DB.QueryRow(`SELECT count(*) FROM adapter_sessions WHERE ticket_hash='retained' AND exchanged_at_ms=0`).Scan(&count); err != nil || count != 1 {
t.Fatal(count, err)
}
}
func TestPostgreSQLSearchFiltersBeforeCandidateLimit(t *testing.T) {
f := newPublicationBackend(t, storePostgreSQL)
s := f.s
if err := s.EnsureSearchIndexSchema(); err != nil {
t.Fatal(err)
}
f.exec(`INSERT INTO objects(uuid,kind,created_at) SELECT 'bulk-'||i,'page',1 FROM generate_series(1,1100) i`)
f.exec(`INSERT INTO paths(domain_uuid,path,object_uuid,created_at) SELECT $1,'/bulk/'||lpad(i::text,4,'0'),'bulk-'||i,1 FROM generate_series(1,1100) i`, f.domain)
f.exec(`INSERT INTO revisions(uuid,object_uuid,document_hash,lang,content_type,filename,created_at_ms,created_at) SELECT 'bulk-rev-'||i,'bulk-'||i,repeat('a',64),'ja','text/plain','',1000,1 FROM generate_series(1,1100) i`)
f.exec(`UPDATE revisions SET content_type='application/pdf',created_at_ms=2000,filename='target.pdf' WHERE uuid='bulk-rev-1100'`)
ctx := context.Background()
allow := func(string) bool { return true }
from := int64(2000)
for _, options := range []SearchOptions{{FileType: "pdf"}, {Extension: "pdf"}, {FromMS: &from}} {
results, err := s.SearchPathsInDomainWithOptions(ctx, f.domain, "/bulk", "", 100, allow, options)
if err != nil || len(results) != 1 || results[0].Path != "/bulk/1100" {
t.Fatal(options, results, err)
}
}
// Only the latest revision contributes file/date predicates.
f.revision("bulk-1100", "newer", 3000)
results, err := s.SearchPathsInDomainWithOptions(ctx, f.domain, "/bulk", "", 100, allow, SearchOptions{FileType: "pdf"})
if err != nil || len(results) != 0 {
t.Fatal("historical metadata leaked", results, err)
}
checked := 0
results, err = s.SearchPathsInDomainFiltered(ctx, f.domain, "/bulk", "bulk", 100, func(string) bool { checked++; return false })
if err != nil || len(results) != 0 || checked != SearchCandidateLimit {
t.Fatal("candidate cap", checked, err)
}
}