Files
pages/internal/store/city_test.go
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

356 lines
13 KiB
Go

package store
import (
"database/sql"
"strings"
"testing"
_ "modernc.org/sqlite"
)
func TestCityMapTopologyAndVersion(t *testing.T) {
database, err := sql.Open("sqlite", "file:city-map-test?mode=memory&cache=shared")
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); INSERT INTO paths(domain_uuid,path,object_uuid,is_primary) VALUES('d','/guide','page-1',1)`); err != nil {
t.Fatal(err)
}
quartier, err := st.CreateZone("d", "actor", "quartier", "ignored", "technology", "Technology", "")
if err != nil {
t.Fatal(err)
}
if _, err := st.CreateZone("d", "actor", "street", "missing", "invalid", "Invalid", ""); err == nil {
t.Fatal("Street without a Quartier was accepted")
}
street, err := st.CreateZone("d", "actor", "street", quartier, "platform", "Platform", "")
if err != nil {
t.Fatal(err)
}
spot, err := st.CreateSpot("d", "actor", street, "pageswiki", "Pages Wiki", "Semantic knowledge system")
if err != nil {
t.Fatal(err)
}
secondSpot, err := st.CreateSpot("d", "actor", street, "architecture", "Architecture", "")
if err != nil {
t.Fatal(err)
}
if err := st.AddSpotPage("d", "actor", spot, "page-1", "", "primary", "Guide"); err != nil {
t.Fatal(err)
}
if err := st.AddSpotPage("d", "actor", secondSpot, "page-1", "", "reference", ""); err != nil {
t.Fatal(err)
}
if err := st.AddSpotRelation("d", "actor", spot, secondSpot, "depends_on"); err != nil {
t.Fatal(err)
}
byName, err := st.CityNode("d", "spot", "pageswiki")
if err != nil || byName.UUID != spot {
t.Fatalf("spot name address = %#v, %v", byName, err)
}
byUUID, err := st.CityNode("d", "spot", "uuid:"+spot)
if err != nil || byUUID.UUID != spot {
t.Fatalf("spot UUID address = %#v, %v", byUUID, err)
}
city, err := st.GetCityMap("d")
if err != nil {
t.Fatal(err)
}
if city.Version != 8 || len(city.Quartiers) != 1 || len(city.Quartiers[0].Streets) != 1 || len(city.Quartiers[0].Streets[0].Spots) != 2 || city.Quartiers[0].Streets[0].Spots[0].UUID != secondSpot && city.Quartiers[0].Streets[0].Spots[1].UUID != spot || len(city.Relations) != 1 {
t.Fatalf("city map = %#v", city)
}
var portalSpot CitySpot
for _, item := range city.Quartiers[0].Streets[0].Spots {
if item.UUID == spot {
portalSpot = item
break
}
}
if portalSpot.PortalPath != "/guide" || portalSpot.PortalPageUUID != "page-1" {
t.Fatalf("spot portal = %#v", portalSpot)
}
appearances, err := st.ListPageSpotAppearances("d", "page-1")
if err != nil || len(appearances) != 2 {
t.Fatalf("MagicPage appearances = %#v, %v", appearances, err)
}
var events int
if err := database.QueryRow(`SELECT COUNT(*) FROM topology_events WHERE domain_uuid='d'`).Scan(&events); err != nil || events != 7 {
t.Fatalf("events = %d, %v", events, err)
}
secondQuartier, err := st.CreateZone("d", "actor", "quartier", "", "operations", "Operations", "")
if err != nil {
t.Fatal(err)
}
secondStreet, err := st.CreateZone("d", "actor", "street", secondQuartier, "service", "Service", "")
if err != nil {
t.Fatal(err)
}
if err := st.MoveStreet("d", "actor", street, secondQuartier, 10); err == nil {
t.Fatal("Street moved outside its Quartier Path boundary")
}
if err := st.MoveStreet("d", "actor", street, quartier, 10); err != nil {
t.Fatal(err)
}
if err := st.MoveSpot("d", "actor", spot, secondStreet, 20); err == nil {
t.Fatal("Spot moved outside its Street Path boundary")
}
if err := st.MoveSpot("d", "actor", spot, street, 20); err != nil {
t.Fatal(err)
}
if err := st.RemoveSpotRelation("d", "actor", spot, secondSpot, "depends_on"); err != nil {
t.Fatal(err)
}
if err := st.RemoveSpotPage("d", "actor", secondSpot, "page-1", "reference"); err != nil {
t.Fatal(err)
}
final, err := st.GetCityMap("d")
if err != nil || final.Version != 14 || len(final.Relations) != 0 {
t.Fatalf("final city = %#v, %v", final, err)
}
}
func TestDeleteCityNodeRecursivelyArchivesTopology(t *testing.T) {
database, err := sql.Open("sqlite", "file:city-delete-test?mode=memory&cache=shared")
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); INSERT INTO paths(domain_uuid,path,object_uuid,is_primary) VALUES('d','/kept','page-kept',1)`); err != nil {
t.Fatal(err)
}
quartier, err := st.CreateZone("d", "actor", "quartier", "", "delete-me", "Delete me", "")
if err != nil {
t.Fatal(err)
}
street, err := st.CreateZone("d", "actor", "street", quartier, "nested-street", "Nested", "")
if err != nil {
t.Fatal(err)
}
spot, err := st.CreateSpot("d", "actor", street, "nested-spot", "Nested", "")
if err != nil {
t.Fatal(err)
}
if err := st.AddSpotPage("d", "actor", spot, "page-kept", "", "primary", "Kept page"); err != nil {
t.Fatal(err)
}
city, err := st.GetCityMap("d")
if err != nil || len(city.Quartiers[0].Streets[0].Spots[0].Pages) != 1 {
t.Fatalf("page graph = %#v, %v", city, err)
}
if err := st.DeleteCityNode("d", "actor", "quartier", quartier); err != nil {
t.Fatal(err)
}
city, err = st.GetCityMap("d")
if err != nil || len(city.Quartiers) != 0 {
t.Fatalf("deleted map = %#v, %v", city, err)
}
var paths, edges int
if err := database.QueryRow(`SELECT COUNT(*) FROM paths WHERE object_uuid='page-kept'`).Scan(&paths); err != nil {
t.Fatal(err)
}
if err := database.QueryRow(`SELECT COUNT(*) FROM spot_pages WHERE spot_uuid=?`, spot).Scan(&edges); err != nil {
t.Fatal(err)
}
if paths != 1 || edges != 0 {
t.Fatalf("document paths=%d graph edges=%d", paths, edges)
}
}
func TestArchivedCityNamesCanBeReused(t *testing.T) {
database, err := sql.Open("sqlite", "file:city-name-reuse-test?mode=memory&cache=shared")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = database.Close() })
st := &Store{DB: database}
if err := st.EnsureCitySchema(); err != nil {
t.Fatal(err)
}
quartier, err := st.CreateZoneAtPath("d", "actor", "quartier", "", "life", "Life", "", "/life")
if err != nil {
t.Fatal(err)
}
street, err := st.CreateZoneAtPath("d", "actor", "street", quartier, "home", "Home", "", "/life/home")
if err != nil {
t.Fatal(err)
}
spot, err := st.CreateSpotAtPath("d", "actor", street, "portal", "Portal", "", "/life/home/portal")
if err != nil {
t.Fatal(err)
}
if err := st.DeleteCityNode("d", "actor", "spot", spot); err != nil {
t.Fatal(err)
}
if _, err := st.CreateSpotAtPath("d", "actor", street, "portal", "New portal", "", "/life/home/new-portal"); err != nil {
t.Fatalf("reusing archived Spot name: %v", err)
}
if err := st.DeleteCityNode("d", "actor", "street", street); err != nil {
t.Fatal(err)
}
if _, err := st.CreateZoneAtPath("d", "actor", "street", quartier, "home", "New home", "", "/life/new-home"); err != nil {
t.Fatalf("reusing archived Street name: %v", err)
}
}
func TestCityPathBoundariesInferPrimarySpot(t *testing.T) {
database, err := sql.Open("sqlite", "file:city-path-test?mode=memory&cache=shared")
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); INSERT INTO paths VALUES('d','/life/home/kitchen/recipe','recipe-page',1)`); err != nil {
t.Fatal(err)
}
quartier, err := st.CreateZoneAtPath("d", "actor", "quartier", "", "life", "Life", "", "/life")
if err != nil {
t.Fatal(err)
}
if _, err := st.CreateZoneAtPath("d", "actor", "street", quartier, "outside", "Outside", "", "/work/outside"); err == nil {
t.Fatal("accepted Street outside Quartier boundary")
}
street, err := st.CreateZoneAtPath("d", "actor", "street", quartier, "home", "Home", "", "/life/home")
if err != nil {
t.Fatal(err)
}
spot, err := st.CreateSpotAtPath("d", "actor", street, "kitchen", "Kitchen", "", "/life/home/kitchen")
if err != nil {
t.Fatal(err)
}
if _, err := st.CreateSpotAtPath("d", "actor", street, "overlap", "Overlap", "", "/life/home/kitchen/sub"); err == nil {
t.Fatal("accepted overlapping Spot boundary")
}
pages, err := st.ListSpotPages("d", spot)
if err != nil || len(pages) != 1 || pages[0].PageUUID != "recipe-page" || pages[0].Source != "path" {
t.Fatalf("inferred pages=%#v, %v", pages, err)
}
appearances, err := st.ListPageSpotAppearances("d", "recipe-page")
if err != nil || len(appearances) != 1 || appearances[0].SpotUUID != spot || appearances[0].Source != "path" {
t.Fatalf("inferred appearances=%#v, %v", appearances, err)
}
city, err := st.GetCityMap("d")
if err != nil {
t.Fatal(err)
}
portal := city.Quartiers[0].Streets[0].Spots[0]
if portal.PortalPath != "/life/home/kitchen/recipe" || portal.PortalPageUUID != "recipe-page" {
t.Fatalf("inferred spot portal = %#v", portal)
}
}
func TestCityDetailsPathAndRecursiveRenameStayInSync(t *testing.T) {
database, err := sql.Open("sqlite", "file:city-path-rename-test?mode=memory&cache=shared")
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 domains(uuid TEXT PRIMARY KEY,placement TEXT,enabled INTEGER); INSERT INTO domains VALUES('d','local',1); CREATE TABLE paths(domain_uuid TEXT,path TEXT,object_uuid TEXT,created_at INTEGER DEFAULT 0,is_primary INTEGER DEFAULT 0,PRIMARY KEY(domain_uuid,path)); CREATE TABLE revisions(uuid TEXT,object_uuid TEXT,body TEXT,document_hash TEXT,lang TEXT,content_type TEXT,filename TEXT,message TEXT,created_at_ms INTEGER,created_at INTEGER); INSERT INTO paths(domain_uuid,path,object_uuid) VALUES('d','/life/home/page','page-1')`); err != nil {
t.Fatal(err)
}
quartier, err := st.CreateZoneAtPath("d", "actor", "quartier", "", "life", "Life", "", "/life")
if err != nil {
t.Fatal(err)
}
street, err := st.CreateZoneAtPath("d", "actor", "street", quartier, "home", "Home", "", "/life/home")
if err != nil {
t.Fatal(err)
}
spot, err := st.CreateSpotAtPath("d", "actor", street, "page", "Page", "", "/life/home/page")
if err != nil {
t.Fatal(err)
}
if err := st.UpdateCityNodePath("d", "actor", "spot", spot, "/life/home/portal"); err != nil {
t.Fatal(err)
}
if _, err := st.RenamePathsInDomain("d", "/life", "/living", true); err != nil {
t.Fatal(err)
}
for kind, id := range map[string]string{"quartier": quartier, "street": street, "spot": spot} {
detail, err := st.CityNode("d", kind, "uuid:"+id)
if err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(detail.PathPrefix, "/living") {
t.Fatalf("%s path did not follow rename: %q", kind, detail.PathPrefix)
}
}
}
func TestSpotPathCanBeRepairedWithUnrelatedUnsetBoundaries(t *testing.T) {
database, err := sql.Open("sqlite", "file:city-legacy-boundary-test?mode=memory&cache=shared")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = database.Close() })
st := &Store{DB: database}
if err := st.EnsureCitySchema(); err != nil {
t.Fatal(err)
}
quartier, err := st.CreateZoneAtPath("d", "actor", "quartier", "", "life", "Life", "", "/life")
if err != nil {
t.Fatal(err)
}
street, err := st.CreateZoneAtPath("d", "actor", "street", quartier, "home", "Home", "", "/life/home")
if err != nil {
t.Fatal(err)
}
spot, err := st.CreateSpotAtPath("d", "actor", street, "portal", "Portal", "", "/life/home/portal")
if err != nil {
t.Fatal(err)
}
if _, err := database.Exec(`UPDATE zones SET path_prefix=''`); err != nil {
t.Fatal(err)
}
if err := st.UpdateCityNodePath("d", "actor", "spot", spot, "/moved-portal"); err != nil {
t.Fatalf("unrelated unset boundaries blocked Spot move: %v", err)
}
detail, err := st.CityNode("d", "spot", "uuid:"+spot)
if err != nil || detail.PathPrefix != "/moved-portal" {
t.Fatalf("moved Spot = %#v, %v", detail, err)
}
}
func TestCityNodeOverlappingPathFindsExistingMergeTarget(t *testing.T) {
database, err := sql.Open("sqlite", "file:city-overlap-merge-test?mode=memory&cache=shared")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { database.Close() })
st := &Store{DB: database}
if err := st.EnsureCitySchema(); err != nil {
t.Fatal(err)
}
q, err := st.CreateZoneAtPath("d", "actor", "quartier", "", "tech", "Tech", "", "/tech")
if err != nil {
t.Fatal(err)
}
street, err := st.CreateZoneAtPath("d", "actor", "street", q, "dev", "Dev", "", "/tech/dev")
if err != nil {
t.Fatal(err)
}
spot, err := st.CreateSpotAtPath("d", "actor", street, "lang", "Lang", "", "/tech/dev/lang")
if err != nil {
t.Fatal(err)
}
got, err := st.CityNodeOverlappingPath("d", "spot", street, "/tech/dev/lang/python")
if err != nil || got.UUID != spot {
t.Fatalf("merge target = %#v, %v", got, err)
}
}