Files
pages/internal/store/city_organize_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

224 lines
8.7 KiB
Go

package store
import (
"database/sql"
"errors"
"path/filepath"
"testing"
)
func cityOrganizeFixture(t *testing.T) (*Store, string, string, string, string) {
t.Helper()
db, err := sql.Open("sqlite", filepath.Join(t.TempDir(), "city.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { db.Close() })
s := &Store{DB: db}
if err = s.EnsureCitySchema(); err != nil {
t.Fatal(err)
}
if _, err = db.Exec(`CREATE TABLE paths(domain_uuid TEXT,path TEXT,object_uuid TEXT,is_primary INTEGER DEFAULT 0); INSERT INTO paths VALUES('d','/life/home/one/page','p1',1),('d','/life/home/two/page','p2',1),('d','/life/home/readme','p3',1),('other','/private','secret',1)`); err != nil {
t.Fatal(err)
}
q, err := s.CreateZoneAtPath("d", "actor", "quartier", "", "life", "Life", "", "/life")
if err != nil {
t.Fatal(err)
}
home, err := s.CreateZoneAtPath("d", "actor", "street", q, "home", "Home", "", "/life/home")
if err != nil {
t.Fatal(err)
}
work, err := s.CreateZoneAtPath("d", "actor", "street", q, "work", "Work", "", "/life/work")
if err != nil {
t.Fatal(err)
}
one, err := s.CreateSpotAtPath("d", "actor", home, "one", "One", "", "/life/home/one")
if err != nil {
t.Fatal(err)
}
two, err := s.CreateSpotAtPath("d", "actor", home, "two", "Two", "", "/life/home/two")
if err != nil {
t.Fatal(err)
}
target, err := s.CreateSpotAtPath("d", "actor", work, "target", "Target", "", "/life/work/target")
if err != nil {
t.Fatal(err)
}
return s, one, two, target, work
}
func cityTestVersion(t *testing.T, s *Store) int64 {
t.Helper()
var version int64
if err := s.DB.QueryRow(`SELECT version FROM domain_topology_versions WHERE domain_uuid='d'`).Scan(&version); err != nil {
t.Fatal(err)
}
return version
}
func TestCityRenameTitlePreservesIdentityAndChecksVersion(t *testing.T) {
s, one, _, _, _ := cityOrganizeFixture(t)
v := cityTestVersion(t, s)
if err := s.RenameCityTitle("d", "actor", "spot", one, "新しい表示名", v); err != nil {
t.Fatal(err)
}
n, err := s.CityNode("d", "spot", "one")
if err != nil || n.Title != "新しい表示名" || n.UUID != one || n.PathPrefix != "/life/home/one" {
t.Fatalf("%+v %v", n, err)
}
if err = s.RenameCityTitle("d", "actor", "spot", one, "stale", v); !errors.Is(err, ErrCityChanged) {
t.Fatalf("stale: %v", err)
}
v = cityTestVersion(t, s)
if err = s.RenameCityTitle("d", "actor", "spot", one, "新しい表示名", v); err != nil || cityTestVersion(t, s) != v {
t.Fatalf("no-op: %v", err)
}
if err = s.RenameCityTitle("other", "actor", "spot", one, "wrong domain", 1); err == nil {
t.Fatal("cross-domain rename")
}
}
func TestCityMergePreservesPagesAndRelationsAtomically(t *testing.T) {
s, one, two, target, work := cityOrganizeFixture(t)
third, err := s.CreateSpotAtPath("d", "actor", work, "third", "Third", "", "/life/work/third")
if err != nil {
t.Fatal(err)
}
for _, edge := range [][2]string{{one, two}, {one, third}, {two, third}, {third, two}} {
if err = s.AddSpotRelation("d", "actor", edge[0], edge[1], "related"); err != nil {
t.Fatal(err)
}
}
v := cityTestVersion(t, s)
out, err := s.OrganizeCity("d", "actor", CityOrganizeRequest{BaseVersion: v, Action: "merge", Spots: []string{one, two}, TargetSpotUUID: target})
if err != nil || out.Pages != 2 || out.TargetSpotUUID != target {
t.Fatalf("%+v %v", out, err)
}
if cityTestVersion(t, s) != v+1 {
t.Fatal("merge must have a single topology commit")
}
pages, err := s.ListSpotPages("d", target)
if err != nil || len(pages) != 2 {
t.Fatalf("pages=%+v %v", pages, err)
}
for _, p := range pages {
if p.Path != "/life/home/one/page" && p.Path != "/life/home/two/page" {
t.Fatalf("URL moved: %+v", p)
}
}
var archived, relations, self, paths int
s.DB.QueryRow(`SELECT COUNT(*) FROM spots WHERE state='archived'`).Scan(&archived)
s.DB.QueryRow(`SELECT COUNT(*) FROM spot_relations`).Scan(&relations)
s.DB.QueryRow(`SELECT COUNT(*) FROM spot_relations WHERE source_spot_uuid=target_spot_uuid`).Scan(&self)
s.DB.QueryRow(`SELECT COUNT(*) FROM paths`).Scan(&paths)
if archived != 2 || relations != 2 || self != 0 || paths != 4 {
t.Fatalf("archived=%d relations=%d self=%d paths=%d", archived, relations, self, paths)
}
if _, err = s.OrganizeCity("d", "actor", CityOrganizeRequest{BaseVersion: v, Action: "merge", Spots: []string{one, two}, TargetSpotUUID: target}); !errors.Is(err, ErrCityChanged) {
t.Fatal("repeat must not reapply", err)
}
}
func TestCityCreateFromUndefinedAndRejectInvalidSelection(t *testing.T) {
s, one, _, _, work := cityOrganizeFixture(t)
var home string
s.DB.QueryRow(`SELECT street_uuid FROM street_spots WHERE spot_uuid=?`, one).Scan(&home)
undefined, err := s.CreateSpotAtPath("d", "actor", home, "home-undefined", "Undefined", "", "/life/home/_undefined")
if err != nil {
t.Fatal(err)
}
if err = s.AddSpotPage("d", "actor", undefined, "p3", "", "primary", "Readme"); err != nil {
t.Fatal(err)
}
v := cityTestVersion(t, s)
req := CityOrganizeRequest{BaseVersion: v, Action: "merge", Pages: []CityPageSelection{{undefined, "p3"}}, NewSpot: &CityNewSpot{StreetUUID: work, Name: "collected", Title: "Collected", PathPrefix: "/life/work/collected"}}
bad := req
bad.Pages = []CityPageSelection{{undefined, "secret"}}
if _, err = s.OrganizeCity("d", "actor", bad); err == nil {
t.Fatal("accepted a Page outside selection/domain")
}
if cityTestVersion(t, s) != v {
t.Fatal("failed mutation changed version")
}
out, err := s.OrganizeCity("d", "actor", req)
if err != nil {
t.Fatal(err)
}
pages, err := s.ListSpotPages("d", out.TargetSpotUUID)
if err != nil || len(pages) != 1 || pages[0].Path != "/life/home/readme" {
t.Fatalf("%+v %v", pages, err)
}
left, err := s.ListSpotPages("d", undefined)
if err != nil || len(left) != 0 {
t.Fatalf("source still has moved Page: %+v %v", left, err)
}
var ov string
s.DB.QueryRow(`SELECT spot_uuid FROM city_page_overrides WHERE domain_uuid='d' AND page_uuid='p3'`).Scan(&ov)
if ov != out.TargetSpotUUID {
t.Fatal("missing manual inference override")
}
}
func TestCityMovePreservesUUIDAndInferredMembers(t *testing.T) {
s, one, two, _, work := cityOrganizeFixture(t)
out, err := s.OrganizeCity("d", "actor", CityOrganizeRequest{BaseVersion: cityTestVersion(t, s), Action: "move", Spots: []string{one, two}, StreetUUID: work})
if err != nil || out.Pages != 2 {
t.Fatalf("%+v %v", out, err)
}
for _, id := range []string{one, two} {
n, err := s.CityNode("d", "spot", "uuid:"+id)
if err != nil || !cityPathContains("/life/work", n.PathPrefix) {
t.Fatalf("%+v %v", n, err)
}
pages, err := s.ListSpotPages("d", id)
if err != nil || len(pages) != 1 || !cityPathContains("/life/home", pages[0].Path) {
t.Fatalf("lost old membership: %+v %v", pages, err)
}
}
}
func TestCityOrganizeRollbackOnBoundaryAndCrossDomainErrors(t *testing.T) {
s, one, two, target, work := cityOrganizeFixture(t)
v := cityTestVersion(t, s)
requests := []CityOrganizeRequest{
{Action: "merge", Spots: []string{one}, TargetSpotUUID: one},
{Action: "merge", Spots: []string{one, "absent"}, TargetSpotUUID: target},
{Action: "merge", Spots: []string{one}, NewSpot: &CityNewSpot{StreetUUID: work, Name: "invalid", Title: "Invalid", PathPrefix: "/life/home/elsewhere"}},
{Action: "move", Spots: []string{one, two}, StreetUUID: target}, // Spot cannot be a parent.
{Action: "move", Spots: []string{one}, StreetUUID: work, PathPrefix: "/life/work/target"},
}
for _, req := range requests {
req.BaseVersion = v
if _, err := s.OrganizeCity("d", "actor", req); err == nil {
t.Fatalf("accepted %+v", req)
}
if cityTestVersion(t, s) != v {
t.Fatal("failed operation left partial writes")
}
}
if _, err := s.OrganizeCity("other", "actor", CityOrganizeRequest{BaseVersion: 1, Action: "merge", Spots: []string{one}, TargetSpotUUID: target}); err == nil {
t.Fatal("cross-domain merge")
}
}
func TestCityMergeRollsBackAfterPartialWrites(t *testing.T) {
s, one, two, target, _ := cityOrganizeFixture(t)
v := cityTestVersion(t, s)
if _, err := s.DB.Exec(`CREATE TRIGGER fail_archive BEFORE UPDATE OF state ON spots WHEN NEW.state='archived' BEGIN SELECT RAISE(ABORT,'test failure'); END`); err != nil {
t.Fatal(err)
}
if _, err := s.OrganizeCity("d", "actor", CityOrganizeRequest{BaseVersion: v, Action: "merge", Spots: []string{one, two}, TargetSpotUUID: target}); err == nil {
t.Fatal("injected failure was ignored")
}
pages, err := s.ListSpotPages("d", target)
if err != nil || len(pages) != 0 {
t.Fatalf("partial transfer: %+v %v", pages, err)
}
var overrides, archived int
s.DB.QueryRow(`SELECT COUNT(*) FROM city_page_overrides`).Scan(&overrides)
s.DB.QueryRow(`SELECT COUNT(*) FROM spots WHERE state='archived'`).Scan(&archived)
if overrides != 0 || archived != 0 || cityTestVersion(t, s) != v {
t.Fatalf("partial state: %d %d", overrides, archived)
}
}