Files
pages/internal/store/city_search_test.go
T
Anya Tokugawa d5d21b7841
Build and publish container images / images (push) Successful in 9m34s
Release container images / release (push) Successful in 36s
Refactor architecture into eight components and consolidate reliability work
Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts.

Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation.

Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
2026-11-01 15:23:31 +09:00

248 lines
13 KiB
Go

package store
import (
"context"
"errors"
"fmt"
"reflect"
"strings"
"testing"
"time"
)
func citySearchAllowAll(string) bool { return true }
func citySearchInsertZone(t *testing.T, st *Store, id, domain, kind, parent, name, title, description, path string) {
t.Helper()
cityTestExec(t, st, `INSERT INTO zones(uuid,domain_uuid,kind,parent_uuid,name,title,description,path_prefix,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?,?,'active',1000,2000)`, id, domain, kind, parent, name, title, description, path)
}
func citySearchInsertSpot(t *testing.T, st *Store, id, domain, street, name, title, description, path string) {
t.Helper()
cityTestExec(t, st, `INSERT INTO spots(uuid,domain_uuid,name,title,summary,path_prefix,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,'active',1000,2000)`, id, domain, name, title, description, path)
cityTestExec(t, st, `INSERT INTO street_spots(street_uuid,spot_uuid,created_at_ms) VALUES(?,?,1000)`, street, id)
}
func citySearchIDs(results []CitySearchResult) []string {
ids := make([]string, len(results))
for i, result := range results {
ids[i] = result.UUID
}
return ids
}
func TestCitySearchMetadataRankingAndMatchSources(t *testing.T) {
st := cityReadFixture(t)
// The fixture has only Path metadata, no document/revision bodies. Search
// may test boundary existence but must not expand a CityMap or read bodies.
citySearchInsertZone(t, st, "q-description", "d", "quartier", "", "description", "Description", "needle in charter", "/a-description")
citySearchInsertZone(t, st, "q-path", "d", "quartier", "", "path", "Path", "", "/b-needle")
citySearchInsertZone(t, st, "q-title", "d", "quartier", "", "title", "NeEdLe quartier", "", "/c-title")
citySearchInsertZone(t, st, "street", "d", "street", "q-title", "needle-street", "Street", "", "/c-title/street")
citySearchInsertSpot(t, st, "spot", "d", "street", "spot", "Spot", strings.Repeat("前", 500)+"needle 日本語", "/c-title/street/spot")
results, err := st.SearchCityInDomain(context.Background(), "d", "/", "NEEDLE", 30, citySearchAllowAll, SearchOptions{})
if err != nil {
t.Fatal(err)
}
if got, want := citySearchIDs(results), []string{"q-title", "q-path", "q-description", "street", "spot"}; !reflect.DeepEqual(got, want) {
t.Fatalf("ranked hits = %v, want %v", got, want)
}
if !results[0].NameMatch || results[0].PathMatch || results[0].DescriptionMatch || !results[1].PathMatch || !results[2].DescriptionMatch {
t.Fatalf("match sources = %#v", results)
}
spot := results[4]
if spot.Kind != "spot" || spot.QuartierTitle != "NeEdLe quartier" || spot.StreetTitle != "Street" || !strings.Contains(spot.Description, "needle 日本語") || len([]rune(spot.Description)) > 512 {
t.Fatalf("spot metadata/excerpt = %#v", spot)
}
if spot.CreatedAtMS != 1000 || spot.UpdatedAtMS != 2000 {
t.Fatalf("timestamps = %#v", spot)
}
}
func TestCitySearchScopeUsesLiteralBoundaries(t *testing.T) {
st := cityReadFixture(t)
citySearchInsertZone(t, st, "literal", "d", "quartier", "", "literal", "日本語 %_", "a'b\\c", "/Life_%/日本語")
citySearchInsertZone(t, st, "child", "d", "street", "literal", "child", "日本語 %_", "", "/Life_%/日本語/child")
citySearchInsertZone(t, st, "sibling", "d", "quartier", "", "sibling", "日本語", "", "/Life_%/日本語-other")
citySearchInsertZone(t, st, "lower", "d", "quartier", "", "lower", "日本語 %_", "", "/life_%/日本語")
citySearchInsertZone(t, st, "wildcard", "d", "quartier", "", "wildcard", "日本語", "", "/Life-xyz/日本語")
for _, tt := range []struct {
scope, query string
ids []string
}{
{"/Life_%/日本語", "日本語", []string{"literal", "child"}},
{"/Life_%/日本語/child", "日本語", []string{"child"}},
{"/Life_%/日本語/child/deeper", "日本語", []string{}},
{"/Life_%/日本語", "%_", []string{"literal", "child"}},
{"/Life_%/日本語", "a'b\\c", []string{"literal"}},
{"/", "' OR 1=1 --", []string{}},
} {
t.Run(tt.scope+"_"+tt.query, func(t *testing.T) {
results, err := st.SearchCityInDomain(context.Background(), "d", tt.scope, tt.query, 30, citySearchAllowAll, SearchOptions{})
if err != nil || !reflect.DeepEqual(citySearchIDs(results), tt.ids) {
t.Fatalf("hits = %v, %v; want %v", citySearchIDs(results), err, tt.ids)
}
})
}
}
func TestCitySearchRequiresReadableActiveSameDomainAncestors(t *testing.T) {
st := cityReadFixture(t)
citySearchInsertZone(t, st, "q-one", "d", "quartier", "", "one", "needle One", "", "/one")
citySearchInsertZone(t, st, "q-two", "d", "quartier", "", "two", "needle Two", "", "/two")
// Street names are only unique within their Quartier. Keep both hits and
// their distinct UUID/context instead of deduplicating by name.
citySearchInsertZone(t, st, "st-one", "d", "street", "q-one", "same-name", "needle Street", "", "/one/street")
citySearchInsertZone(t, st, "st-two", "d", "street", "q-two", "same-name", "needle Street", "", "/two/street")
citySearchInsertSpot(t, st, "spot-one", "d", "st-one", "one-spot", "needle Spot", "", "/one/street/spot")
citySearchInsertSpot(t, st, "spot-two", "d", "st-two", "two-spot", "needle Spot", "", "/two/street/spot")
citySearchInsertZone(t, st, "foreign-q", "foreign", "quartier", "", "foreign", "needle Foreign", "", "/foreign")
citySearchInsertZone(t, st, "cross-street", "d", "street", "foreign-q", "cross", "needle Cross", "", "/foreign/street")
citySearchInsertSpot(t, st, "cross-spot", "d", "cross-street", "cross-spot", "needle Cross", "", "/foreign/street/spot")
citySearchInsertSpot(t, st, "foreign-spot", "foreign", "st-one", "foreign-spot", "needle Foreign", "", "/one/street/foreign")
citySearchInsertZone(t, st, "archived-q", "d", "quartier", "", "archived", "needle Archived", "", "/archived")
citySearchInsertZone(t, st, "archived-child", "d", "street", "archived-q", "archived-child", "needle Child", "", "/archived/child")
citySearchInsertSpot(t, st, "archived-spot", "d", "archived-child", "archived-spot", "needle Child", "", "/archived/child/spot")
cityTestExec(t, st, `UPDATE zones SET state='archived' WHERE uuid='archived-q'`)
for i, path := range []string{"", "relative", strings.Repeat("/", 4097)} {
id := fmt.Sprintf("invalid-%d", i)
citySearchInsertZone(t, st, id, "d", "quartier", "", id, "needle Invalid", "", path)
citySearchInsertZone(t, st, id+"-child", "d", "street", id, id+"-child", "needle Invalid", "", "/invalid-child/"+id)
}
search := func(allowed func(string) bool, limit int) []CitySearchResult {
t.Helper()
results, err := st.SearchCityInDomain(context.Background(), "d", "/", "needle", limit, allowed, SearchOptions{})
if err != nil {
t.Fatal(err)
}
return results
}
all := search(citySearchAllowAll, 30)
if got, want := citySearchIDs(all), []string{"q-one", "q-two", "st-one", "st-two", "spot-one", "spot-two"}; !reflect.DeepEqual(got, want) {
t.Fatalf("active same-domain metadata = %v, want %v", got, want)
}
if all[2].QuartierTitle != "needle One" || all[3].QuartierTitle != "needle Two" {
t.Fatalf("same-name context lost: %#v", all)
}
// The child alone being readable must not disclose an unreadable ancestor.
visible := search(func(path string) bool { return path != "/one" && path != "/two/street" }, 30)
if got, want := citySearchIDs(visible), []string{"q-two"}; !reflect.DeepEqual(got, want) {
t.Fatalf("parent ACL filter = %v, want %v", got, want)
}
visible = search(func(path string) bool { return strings.HasPrefix(path, "/two") }, 1)
if got, want := citySearchIDs(visible), []string{"q-two"}; !reflect.DeepEqual(got, want) {
t.Fatalf("ACL must precede visible limit: %v, want %v", got, want)
}
cityTestExec(t, st, `UPDATE zones SET title='' WHERE uuid IN ('q-one','st-one'); UPDATE zones SET state='archived' WHERE uuid='st-two'; UPDATE spots SET state='archived' WHERE uuid='spot-one'`)
results, err := st.SearchCityInDomain(context.Background(), "d", "/", "", 30, citySearchAllowAll, SearchOptions{FromMS: new(int64)})
if err != nil || !reflect.DeepEqual(citySearchIDs(results), []string{"q-one", "q-two", "st-one"}) || results[2].QuartierTitle != "one" {
t.Fatalf("own/parent archived and title fallback: %#v, %v", results, err)
}
}
func TestCitySearchDateFiltersAndFileExclusion(t *testing.T) {
st := cityReadFixture(t)
citySearchInsertZone(t, st, "quarter", "d", "quartier", "", "quarter", "Quarter", "", "/quarter")
from, before := int64(1000), int64(2000)
for _, tt := range []struct {
name string
query string
options SearchOptions
want int
}{
{"no query or filters", "", SearchOptions{}, 0},
{"date field alone", "", SearchOptions{DateField: "created"}, 0},
{"created inclusive from", "", SearchOptions{DateField: "created", FromMS: &from, BeforeMS: &before}, 1},
{"updated exclusive before", "", SearchOptions{FromMS: &from, BeforeMS: &before}, 0},
{"updated inclusive from", "", SearchOptions{FromMS: &before}, 1},
{"keyword and date", "quarter", SearchOptions{BeforeMS: &before}, 0},
{"file type", "quarter", SearchOptions{FileType: "pdf"}, 0},
{"extension", "quarter", SearchOptions{Extension: "py"}, 0},
} {
t.Run(tt.name, func(t *testing.T) {
results, err := st.SearchCityInDomain(context.Background(), "d", "/", tt.query, 30, citySearchAllowAll, tt.options)
if err != nil || len(results) != tt.want {
t.Fatalf("hits = %v, %v; want %d", citySearchIDs(results), err, tt.want)
}
})
}
for _, options := range []SearchOptions{
{DateField: "updated_at_ms); DROP TABLE zones;--"},
{FromMS: &before, BeforeMS: &from},
{FromMS: &from, BeforeMS: &from},
} {
if _, err := st.SearchCityInDomain(context.Background(), "d", "/", "quarter", 30, citySearchAllowAll, options); !errors.Is(err, ErrInvalidSearchOptions) {
t.Fatalf("invalid options = %#v: %v", options, err)
}
}
}
func TestCitySearchBoundedCandidatesAndFiltersBeforeCap(t *testing.T) {
st := cityReadFixture(t)
cityTestExec(t, st, `WITH RECURSIVE n(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM n WHERE i<=?)
INSERT INTO zones(uuid,domain_uuid,kind,parent_uuid,name,title,path_prefix,state,created_at_ms,updated_at_ms)
SELECT printf('q-%04d',i),'d','quartier','',printf('q-%04d',i),'needle',printf('/q-%04d',i),'active',1000,1000 FROM n`, CitySearchCandidateLimit)
allowedCalls := 0
results, err := st.SearchCityInDomain(context.Background(), "d", "/", "needle", 30, func(path string) bool {
allowedCalls++
return path == fmt.Sprintf("/q-%04d", CitySearchCandidateLimit+1)
}, SearchOptions{})
if err != nil || len(results) != 0 || allowedCalls != CitySearchCandidateLimit {
t.Fatalf("candidate budget: got %v, calls=%d, err=%v", citySearchIDs(results), allowedCalls, err)
}
cityTestExec(t, st, `UPDATE zones SET updated_at_ms=3000 WHERE uuid=?`, fmt.Sprintf("q-%04d", CitySearchCandidateLimit+1))
from := int64(2000)
results, err = st.SearchCityInDomain(context.Background(), "d", "/", "", 30, citySearchAllowAll, SearchOptions{FromMS: &from})
if err != nil || len(results) != 1 {
t.Fatalf("date filter must run before cap: %v, %v", citySearchIDs(results), err)
}
results, err = st.SearchCityInDomain(context.Background(), "d", "/", "needle", 10000, citySearchAllowAll, SearchOptions{})
if err != nil || len(results) != CitySearchResultLimit {
t.Fatalf("visible budget: got %d, %v", len(results), err)
}
}
func TestCitySearchCancellationFailureAndConnectionRelease(t *testing.T) {
st := cityReadFixture(t)
citySearchInsertZone(t, st, "quarter", "d", "quartier", "", "quarter", "needle", "", "/quarter")
st.DB.SetMaxOpenConns(1)
ctx, cancel := context.WithCancel(context.Background())
cancel()
if _, err := st.SearchCityInDomain(ctx, "d", "/", "needle", 30, citySearchAllowAll, SearchOptions{}); !errors.Is(err, context.Canceled) {
t.Fatalf("canceled search = %v", err)
}
ctx, cancel = context.WithTimeout(context.Background(), time.Second)
defer cancel()
results, err := st.SearchCityInDomain(ctx, "d", "/", "needle", 30, func(string) bool {
// Authorization is outside the search transaction, even with pool=1.
var value int
if err := st.DB.QueryRowContext(ctx, `SELECT 1`).Scan(&value); err != nil {
t.Errorf("authorization cannot use released read connection: %v", err)
return false
}
return value == 1
}, SearchOptions{})
if err != nil || len(results) != 1 {
t.Fatalf("single-connection search = %v, %v", results, err)
}
assertCityReadConnectionReturned(t, st)
cancelContext, stop := context.WithCancel(context.Background())
defer stop()
results, err = st.SearchCityInDomain(cancelContext, "d", "/", "needle", 1, func(string) bool { stop(); return true }, SearchOptions{})
if !errors.Is(err, context.Canceled) || len(results) != 0 {
t.Fatalf("cancellation during authorization returned partial success: %#v, %v", results, err)
}
cityTestExec(t, st, `DROP TABLE spots`)
results, err = st.SearchCityInDomain(context.Background(), "d", "/", "needle", 30, citySearchAllowAll, SearchOptions{})
if err == nil || len(results) != 0 {
t.Fatalf("failed query must not return partial success: %v, %v", results, err)
}
assertCityReadConnectionReturned(t, st)
if _, err := st.SearchCityInDomain(context.Background(), "d", "/", strings.Repeat("a", 513), 30, citySearchAllowAll, SearchOptions{}); err == nil {
t.Fatal("oversized query accepted")
}
if _, err := st.SearchCityInDomain(context.Background(), "d", "/", strings.Repeat("word ", 17), 30, citySearchAllowAll, SearchOptions{}); err == nil {
t.Fatal("too many query terms accepted")
}
}