Files
pages/internal/store/city_backend_test.go
2026-11-15 05:47:14 +09:00

134 lines
4.8 KiB
Go

package store
import (
"errors"
"fmt"
"testing"
)
func TestCityBackendReadAndOrganize(t *testing.T) {
for _, backend := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(backend), func(t *testing.T) {
f := newPublicationBackend(t, backend)
s := f.s
f.page("page", "/news_%/st/sp/entry", "rev", 1)
f.exec(`INSERT INTO spots(uuid,domain_uuid,name,path_prefix,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(6)+`)`, "dest", f.domain, "destination", "/news_%/st/destination", 1, 1)
f.exec(`INSERT INTO street_spots(street_uuid,spot_uuid,created_at_ms) VALUES('st','dest',1)`)
model, err := s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
if len(model.Quartiers) != 1 || len(model.Quartiers[0].Streets) != 1 || len(model.Quartiers[0].Streets[0].Spots) != 2 {
t.Fatal(model)
}
pages, err := s.ListSpotPages(f.domain, "sp")
if err != nil || len(pages) != 1 || pages[0].PageUUID != "page" {
t.Fatal(pages, err)
}
context, err := s.ResolveCityPathContext(f.domain, "/news_%/st/sp/entry")
if err != nil || context.Spot == nil || context.Spot.UUID != "sp" {
t.Fatal(context, err)
}
node, err := s.CityNode(f.domain, "street", "q/st")
if err != nil || node.UUID != "st" {
t.Fatal(node, err)
}
if err = s.RenameCityTitle(f.domain, f.actor, "spot", "sp", "New title", model.Version); err != nil {
t.Fatal(err)
}
if err = s.RenameCityTitle(f.domain, f.actor, "spot", "sp", "stale", model.Version); !errors.Is(err, ErrCityChanged) {
t.Fatal(err)
}
model, err = s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
// Transfer a single implicit Page; the old boundary must stop claiming it.
result, err := s.OrganizeCity(f.domain, f.actor, CityOrganizeRequest{BaseVersion: model.Version, Action: "merge", TargetSpotUUID: "dest", Pages: []CityPageSelection{{SpotUUID: "sp", PageUUID: "page"}}})
if err != nil || result.Pages != 1 {
t.Fatal(result, err)
}
pages, err = s.ListSpotPages(f.domain, "sp")
if err != nil || len(pages) != 0 {
t.Fatal(pages, err)
}
pages, err = s.ListSpotPages(f.domain, "dest")
if err != nil || len(pages) != 1 {
t.Fatal(pages, err)
}
model, err = s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
f.exec(`INSERT INTO spot_relations(source_spot_uuid,target_spot_uuid,relation_type,weight,created_at_ms) VALUES('sp','dest','related',2,1)`)
// Merge whole Spots into a new one, retaining Page placements and URLs.
result, err = s.OrganizeCity(f.domain, f.actor, CityOrganizeRequest{BaseVersion: model.Version, Action: "merge", Spots: []string{"sp", "dest"}, NewSpot: &CityNewSpot{StreetUUID: "st", Name: "merged", Title: "Merged", PathPrefix: "/news_%/st/merged"}})
if err != nil || result.Pages != 1 {
t.Fatal(result, err)
}
if id, err := s.ResolvePathInDomain(f.domain, "/news_%/st/sp/entry"); err != nil || id != "page" {
t.Fatal(id, err)
}
health, err := s.GetCityHealth(f.domain)
if err != nil || health.Spots != 1 || health.BrokenRelations != 0 {
t.Fatal(health, err)
}
if err = s.UpdateCityNodePath(f.domain, f.actor, "spot", result.TargetSpotUUID, "/news_%/st/changed"); err != nil {
t.Fatal(err)
}
model, err = s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
if _, err = s.OrganizeCity(f.domain, f.actor, CityOrganizeRequest{BaseVersion: model.Version, Action: "move", Spots: []string{result.TargetSpotUUID}, StreetUUID: "st", PathPrefix: "/news_%/st/moved"}); err != nil {
t.Fatal(err)
}
events, err := s.ListTopologyEvents(f.domain, 0, 100)
if err != nil || len(events) < 4 {
t.Fatal(events, err)
}
// Failure to persist the audit event must not commit the title change.
model, err = s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
f.exec(`ALTER TABLE topology_events RENAME COLUMN operation TO unavailable_operation`)
if err = s.RenameCityTitle(f.domain, f.actor, "spot", result.TargetSpotUUID, "must roll back", model.Version); err == nil {
t.Fatal("missing audit accepted")
}
node, err = s.CityNode(f.domain, "spot", "uuid:"+result.TargetSpotUUID)
if err != nil || node.Title != "Merged" {
t.Fatal(node, err)
}
})
}
}
func TestPostgreSQLCityConcurrentVersion(t *testing.T) {
f := newPublicationBackend(t, storePostgreSQL)
s := f.s
model, err := s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
peer := &Store{DB: s.DB, sqlBackend: storePostgreSQL}
results := make(chan error, 2)
for _, writer := range []*Store{s, peer} {
go func(w *Store) {
results <- w.RenameCityTitle(f.domain, f.actor, "spot", "sp", "changed", model.Version)
}(writer)
}
wins := 0
for i := 0; i < 2; i++ {
err := <-results
if err == nil {
wins++
} else if !errors.Is(err, ErrCityChanged) {
t.Fatal(err)
}
}
if wins != 1 {
t.Fatal("multiple version winners", wins)
}
}