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) } }