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.
342 lines
14 KiB
Go
342 lines
14 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"pageswiki/internal/db"
|
|
)
|
|
|
|
func cityReadFixture(t *testing.T) *Store {
|
|
t.Helper()
|
|
database, err := db.Open(t.TempDir() + "/city.db")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = database.Close() })
|
|
st := &Store{DB: database}
|
|
if err := st.EnsureCitySchema(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := database.Exec(`CREATE TABLE paths(domain_uuid TEXT,path TEXT,object_uuid TEXT,is_primary INTEGER DEFAULT 0,PRIMARY KEY(domain_uuid,path)); CREATE INDEX city_test_path_object ON paths(domain_uuid,object_uuid)`); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return st
|
|
}
|
|
|
|
func cityReadTopology(t *testing.T, st *Store, domain, path string) (string, string, string) {
|
|
t.Helper()
|
|
q, err := st.CreateZoneAtPath(domain, "actor", "quartier", "", "quarter", "Quarter", "", path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
base := strings.TrimRight(normalizePath(path), "/")
|
|
street, err := st.CreateZoneAtPath(domain, "actor", "street", q, "street", "Street", "", base+"/home")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
spot, err := st.CreateSpotAtPath(domain, "actor", street, "spot", "Spot", "", base+"/home/kitchen")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return q, street, spot
|
|
}
|
|
|
|
func cityTestExec(t *testing.T, st *Store, query string, args ...any) {
|
|
t.Helper()
|
|
if _, err := st.DB.Exec(query, args...); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func assertCityReadConnectionReturned(t *testing.T, st *Store) {
|
|
t.Helper()
|
|
// database/sql may finish its cancellation-triggered rollback on another
|
|
// goroutine after a caller observes the deadline. Reacquiring the only
|
|
// connection tests the actual leak contract without a racy Stats snapshot.
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
|
|
defer cancel()
|
|
conn, err := st.DB.Conn(ctx)
|
|
if err != nil {
|
|
t.Fatalf("City read leaked its sole connection: %v", err)
|
|
}
|
|
_ = conn.Close()
|
|
}
|
|
|
|
func TestCityReadSingleConnectionAndSnapshot(t *testing.T) {
|
|
st := cityReadFixture(t)
|
|
q, street, spot := cityReadTopology(t, st, "d", "/life")
|
|
cityTestExec(t, st, `INSERT INTO paths VALUES('d','/life/home/kitchen','portal',1),('d','/life/home/kitchen/page','page',1)`)
|
|
if err := st.AddSpotPage("d", "actor", spot, "portal", "", "primary", "Portal"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := st.AddSpotPage("d", "actor", spot, "portal", "", "reference", "Reference"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st.DB.SetMaxOpenConns(1)
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
|
|
defer cancel()
|
|
city, err := st.GetCityMapContext(ctx, "d")
|
|
if err != nil {
|
|
t.Fatalf("single connection read failed: %v", err)
|
|
}
|
|
got := city.Quartiers[0].Streets[0].Spots[0]
|
|
if got.UUID != spot || got.PageCount != 2 || len(got.Pages) != 3 || got.PortalPath != "/life/home/kitchen" {
|
|
t.Fatalf("deduplicated snapshot = %#v", got)
|
|
}
|
|
assertCityReadConnectionReturned(t, st)
|
|
st.DB.SetMaxOpenConns(2)
|
|
tx, err := st.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer tx.Rollback()
|
|
var before int64
|
|
if err := tx.QueryRow(`SELECT version FROM domain_topology_versions WHERE domain_uuid='d'`).Scan(&before); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Commit after the reader pins the snapshot, before topology/Page loading.
|
|
writer, err := st.DB.Begin()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = writer.Exec(`UPDATE zones SET title='New title' WHERE uuid IN (?,?); UPDATE paths SET path='/changed' WHERE object_uuid='page'; UPDATE domain_topology_versions SET version=version+1 WHERE domain_uuid='d'`, q, street); err != nil {
|
|
_ = writer.Rollback()
|
|
t.Fatal(err)
|
|
}
|
|
if err := writer.Commit(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
old, err := readCityMapTx(cityReadQuery{ctx: ctx, tx: tx}, "d")
|
|
if err != nil || old.Version != before || old.Quartiers[0].Title != "Quarter" || old.Quartiers[0].Streets[0].Spots[0].PageCount != 2 {
|
|
t.Fatalf("mixed concurrent snapshot: %#v, %v", old, err)
|
|
}
|
|
_ = tx.Rollback()
|
|
current, err := st.GetCityMap("d")
|
|
if err != nil || current.Version != before+1 || current.Quartiers[0].Title != "New title" || current.Quartiers[0].Streets[0].Spots[0].PageCount != 1 {
|
|
t.Fatalf("new snapshot missing commit: %#v, %v", current, err)
|
|
}
|
|
}
|
|
|
|
func TestCityReadRejectsBudgetAndReleasesConnection(t *testing.T) {
|
|
for _, budget := range []string{"nodes", "pages", "relations"} {
|
|
t.Run(budget, func(t *testing.T) {
|
|
st := cityReadFixture(t)
|
|
_, street, spot := cityReadTopology(t, st, "d", "/life")
|
|
switch budget {
|
|
case "nodes":
|
|
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,name,path_prefix,created_at_ms,updated_at_ms) SELECT 'q'||i,'d','quartier','q'||i,'/q'||i,1,1 FROM n`, MaxCityMapNodes)
|
|
case "pages":
|
|
cityTestExec(t, st, `WITH RECURSIVE n(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM n WHERE i<?) INSERT INTO paths SELECT 'd','/life/home/kitchen/'||i,'page'||i,1 FROM n`, MaxCityMapPagePlacements+1)
|
|
case "relations":
|
|
second, err := st.CreateSpotAtPath("d", "actor", street, "second", "Second", "", "/life/home/second")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cityTestExec(t, st, `WITH RECURSIVE n(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM n WHERE i<?) INSERT INTO spot_relations(source_spot_uuid,target_spot_uuid,relation_type,created_at_ms) SELECT ?,?,'kind'||i,1 FROM n`, MaxCityMapRelations+1, spot, second)
|
|
}
|
|
st.DB.SetMaxOpenConns(1)
|
|
city, err := st.GetCityMap("d")
|
|
if errors.Is(err, context.DeadlineExceeded) {
|
|
// Race instrumentation may exhaust the two-second time budget
|
|
// before SQLite produces 20,001 rows. Check the independent row
|
|
// ceiling on the same reader without the production time budget.
|
|
tx, beginErr := st.DB.Begin()
|
|
if beginErr != nil {
|
|
t.Fatal(beginErr)
|
|
}
|
|
_, err = readCityMapTx(cityReadQuery{ctx: context.Background(), tx: tx}, "d")
|
|
_ = tx.Rollback()
|
|
}
|
|
if !errors.Is(err, ErrCityMapBudget) || len(city.Quartiers) != 0 || len(city.Relations) != 0 {
|
|
t.Fatalf("budget returned a partial/successful model: %#v, %v", city, err)
|
|
}
|
|
assertCityReadConnectionReturned(t, st)
|
|
if budget == "pages" {
|
|
pages, err := st.ListSpotPagesContext(context.Background(), "d", spot)
|
|
if (!errors.Is(err, ErrCityMapBudget) && !errors.Is(err, context.DeadlineExceeded)) || len(pages) != 0 {
|
|
t.Fatalf("Spot API returned partial/unbounded pages: %d, %v", len(pages), err)
|
|
}
|
|
assertCityReadConnectionReturned(t, st)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCityReadCancellationAndQueryErrors(t *testing.T) {
|
|
st := cityReadFixture(t)
|
|
_, street, _ := cityReadTopology(t, st, "d", "/life")
|
|
st.DB.SetMaxOpenConns(1)
|
|
conn, err := st.DB.Conn(context.Background())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
|
|
defer cancel()
|
|
_, err = st.GetCityMapContext(ctx, "d")
|
|
if !errors.Is(err, context.DeadlineExceeded) {
|
|
t.Fatalf("pool wait was not canceled: %v", err)
|
|
}
|
|
_ = conn.Close()
|
|
cityTestExec(t, st, `UPDATE zones SET sort_key='invalid' WHERE uuid=?`, street)
|
|
city, err := st.GetCityMap("d")
|
|
if err == nil || len(city.Quartiers) != 0 {
|
|
t.Fatalf("nested scan error was ignored: %#v, %v", city, err)
|
|
}
|
|
assertCityReadConnectionReturned(t, st)
|
|
cityTestExec(t, st, `UPDATE zones SET sort_key=0 WHERE uuid=?`, street)
|
|
cityTestExec(t, st, `DROP TABLE domain_topology_versions`)
|
|
if _, err := st.GetCityMap("d"); err == nil {
|
|
t.Fatal("version query error was ignored")
|
|
}
|
|
if _, err := st.GetCityHealth("d"); err == nil {
|
|
t.Fatal("health version query error was ignored")
|
|
}
|
|
}
|
|
|
|
func TestCityReadRejectsForeignAndArchivedTopologyEdges(t *testing.T) {
|
|
st := cityReadFixture(t)
|
|
q, street, spot := cityReadTopology(t, st, "d", "/life")
|
|
_, foreignStreet, foreignSpot := cityReadTopology(t, st, "foreign", "/life")
|
|
cityTestExec(t, st, `INSERT INTO paths VALUES('d','/life/home/kitchen/page','local-page',1),('foreign','/life/home/kitchen/secret','foreign-page',1)`)
|
|
cityTestExec(t, st, `UPDATE street_spots SET street_uuid=? WHERE spot_uuid=?`, street, foreignSpot)
|
|
cityTestExec(t, st, `UPDATE zones SET parent_uuid=? WHERE uuid=?`, q, foreignStreet)
|
|
cityTestExec(t, st, `INSERT INTO spot_pages(spot_uuid,page_uuid,edge_type,created_at_ms) VALUES(?,'foreign-page','reference',1)`, spot)
|
|
cityTestExec(t, st, `INSERT INTO spot_relations(source_spot_uuid,target_spot_uuid,relation_type,created_at_ms) VALUES(?,?,'related',1)`, spot, foreignSpot)
|
|
city, err := st.GetCityMap("d")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(city.Quartiers) != 1 || len(city.Quartiers[0].Streets) != 1 || len(city.Quartiers[0].Streets[0].Spots) != 1 || len(city.Relations) != 0 {
|
|
t.Fatalf("foreign parent/Spot/relation leaked: %#v", city)
|
|
}
|
|
pages := city.Quartiers[0].Streets[0].Spots[0].Pages
|
|
if len(pages) != 1 || pages[0].PageUUID != "local-page" {
|
|
t.Fatalf("foreign explicit Page leaked: %#v", pages)
|
|
}
|
|
cityTestExec(t, st, `UPDATE zones SET state='archived' WHERE uuid=?`, street)
|
|
city, err = st.GetCityMap("d")
|
|
if err != nil || len(city.Quartiers[0].Streets) != 0 {
|
|
t.Fatalf("archived subtree leaked: %#v, %v", city, err)
|
|
}
|
|
}
|
|
|
|
func TestCityLiteralBoundariesOverlapAndContext(t *testing.T) {
|
|
for _, path := range []string{"/a%", "/a_", "/A", "/学区%_", "/a\\b"} {
|
|
t.Run(path, func(t *testing.T) {
|
|
st := cityReadFixture(t)
|
|
q, street, spot := cityReadTopology(t, st, "d", path)
|
|
near := map[string]string{"/a%": "/abc", "/a_": "/ab", "/A": "/a", "/学区%_": "/学区AB", "/a\\b": "/ab"}[path]
|
|
if _, err := st.CreateZoneAtPath("d", "actor", "quartier", "", "other", "Other", "", near); err != nil {
|
|
t.Fatalf("literal disjoint boundary conflicted: %v", err)
|
|
}
|
|
for _, item := range []struct{ kind, parent, id, prefix string }{
|
|
{"quartier", "", q, path}, {"street", q, street, path + "/home"}, {"spot", street, spot, path + "/home/kitchen"},
|
|
} {
|
|
for _, candidate := range []string{item.prefix, item.prefix + "/descendant"} {
|
|
got, err := st.CityNodeOverlappingPath("d", item.kind, item.parent, candidate)
|
|
if err != nil || got.UUID != item.id {
|
|
t.Fatalf("overlap %s %q = %#v, %v", item.kind, candidate, got, err)
|
|
}
|
|
}
|
|
if _, err := st.CityNodeOverlappingPath("d", item.kind, item.parent, item.prefix+"extra"); !errors.Is(err, sql.ErrNoRows) {
|
|
t.Fatalf("segment sibling unexpectedly overlaps: %v", err)
|
|
}
|
|
}
|
|
locality, err := st.ResolveCityPathContext("d", path+"/home/kitchen/page")
|
|
if err != nil || locality.Quartier == nil || locality.Quartier.UUID != q || locality.Street == nil || locality.Street.UUID != street || locality.Spot == nil || locality.Spot.UUID != spot {
|
|
t.Fatalf("literal context=%#v, %v", locality, err)
|
|
}
|
|
other, err := st.ResolveCityPathContext("d", near+"/home/kitchen/page")
|
|
if err != nil || other.Quartier == nil || other.Quartier.UUID == q || other.Street != nil || other.Spot != nil {
|
|
t.Fatalf("wildcard/case crossed locality: %#v, %v", other, err)
|
|
}
|
|
if _, err := st.CreateZoneAtPath("d", "actor", "quartier", "", "nested", "Nested", "", path+"/nested"); err == nil {
|
|
t.Fatal("real descendant overlap accepted")
|
|
}
|
|
cityTestExec(t, st, `INSERT INTO paths VALUES('d',?,'matching',1),('d',?,'unrelated',1)`, path+"/home/kitchen/page", near+"/home/kitchen/page")
|
|
health, err := st.GetCityHealth("d")
|
|
if err != nil || health.EmptySpots != 0 || health.UnconsolidatedPages != 0 || health.OrphanPages != 1 {
|
|
t.Fatalf("literal health: %#v, %v", health, err)
|
|
}
|
|
cityTestExec(t, st, `DELETE FROM paths WHERE object_uuid='matching'`)
|
|
health, err = st.GetCityHealth("d")
|
|
if err != nil || health.EmptySpots != 1 {
|
|
t.Fatalf("unrelated wildcard/case Path made Spot non-empty: %#v, %v", health, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCityRootBoundaryAndHealthUserNamespace(t *testing.T) {
|
|
for _, rootFirst := range []bool{true, false} {
|
|
t.Run(fmt.Sprint(rootFirst), func(t *testing.T) {
|
|
st := cityReadFixture(t)
|
|
first, second := "/", "/life"
|
|
if !rootFirst {
|
|
first, second = second, first
|
|
}
|
|
q, err := st.CreateZoneAtPath("d", "actor", "quartier", "", "first", "First", "", first)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := st.CreateZoneAtPath("d", "actor", "quartier", "", "second", "Second", "", second); err == nil {
|
|
t.Fatal("root/non-root overlap accepted")
|
|
}
|
|
got, err := st.CityNodeOverlappingPath("d", "quartier", "", second)
|
|
if err != nil || got.UUID != q {
|
|
t.Fatalf("root overlap=%#v,%v", got, err)
|
|
}
|
|
if rootFirst {
|
|
for _, path := range []string{"/", "/life", "/学区/page"} {
|
|
got, err := st.ResolveCityPathContext("d", path)
|
|
if err != nil || got.Quartier == nil || got.Quartier.UUID != q {
|
|
t.Fatalf("root context %q=%#v,%v", path, got, err)
|
|
}
|
|
}
|
|
}
|
|
cityTestExec(t, st, `INSERT INTO paths VALUES('d','/u','user-root',1),('d','/u/alice','user',1),('d','/U/alice','upper',1),('d','/unrelated','normal',1)`)
|
|
health, err := st.GetCityHealth("d")
|
|
if err != nil || health.OrphanPages != 2 {
|
|
t.Fatalf("user exclusion must be exact/case-sensitive: %#v,%v", health, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCityLiteralSiblingStreetAndSpotBoundaries(t *testing.T) {
|
|
for _, kind := range []string{"street", "spot"} {
|
|
for _, names := range [][2]string{{"a%", "abc"}, {"a_", "ab"}, {"A", "a"}, {"学区%_", "学区AB"}} {
|
|
t.Run(kind+names[0], func(t *testing.T) {
|
|
st := cityReadFixture(t)
|
|
q, street, _ := cityReadTopology(t, st, "d", "/life")
|
|
parent, prefix := q, "/life/"
|
|
if kind == "spot" {
|
|
parent, prefix = street, "/life/home/"
|
|
}
|
|
for i, segment := range names {
|
|
var id string
|
|
var err error
|
|
if kind == "street" {
|
|
id, err = st.CreateZoneAtPath("d", "actor", kind, parent, fmt.Sprintf("sibling%d", i), segment, "", prefix+segment)
|
|
} else {
|
|
id, err = st.CreateSpotAtPath("d", "actor", parent, fmt.Sprintf("sibling%d", i), segment, "", prefix+segment)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("disjoint %s boundary rejected: %v", kind, err)
|
|
}
|
|
got, err := st.CityNodeOverlappingPath("d", kind, parent, prefix+segment+"/page")
|
|
if err != nil || got.UUID != id {
|
|
t.Fatalf("wrong literal %s overlap: %#v, %v", kind, got, err)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|