package store_test import ( "database/sql" "errors" "testing" "pageswiki/internal/db" "pageswiki/internal/store" ) func newTopologyStore(t *testing.T) *store.Store { t.Helper() database, err := db.Open(t.TempDir() + "/pages.db") if err != nil { t.Fatal(err) } t.Cleanup(func() { _ = database.Close() }) if err := db.Migrate(database); err != nil { t.Fatal(err) } return store.New(database) } func TestDefaultDomainBelongsToDefaultCampus(t *testing.T) { st := newTopologyStore(t) campus, err := st.GetDefaultCampus() if err != nil { t.Fatal(err) } domain, err := st.GetDefaultDomain() if err != nil { t.Fatal(err) } if campus.Name != "default" { t.Fatalf("default campus name = %q", campus.Name) } if domain.CampusUUID != campus.UUID { t.Fatalf( "default domain campus UUID = %q, want %q", domain.CampusUUID, campus.UUID, ) } } func TestCampusDomainOwnershipAndDeletion(t *testing.T) { st := newTopologyStore(t) if err := st.CreateCampus( "Engineering", "Engineering Campus", "ja", "standalone", "example.test", true, ); err != nil { t.Fatal(err) } campuses, err := st.ListCampuses() if err != nil { t.Fatal(err) } var engineering store.Campus for _, campus := range campuses { if campus.Name == "engineering" { engineering = campus break } } if engineering.UUID == "" { t.Fatal("engineering campus was not created") } if engineering.DefaultLang != "ja" { t.Fatalf("default language = %q", engineering.DefaultLang) } if err := st.CreateDomain( engineering.UUID, "docs", "Documentation", "docs", "local", "", "", true, ); err != nil { t.Fatal(err) } domain, err := st.GetDomainByHost("docs.example.test") if err != nil { t.Fatal(err) } if domain.CampusUUID != engineering.UUID { t.Fatalf( "domain campus UUID = %q, want %q", domain.CampusUUID, engineering.UUID, ) } if err := st.DeleteCampus(engineering.ID); err == nil { t.Fatal("referenced campus deletion succeeded") } } func TestCannotDisableLastEnabledCampus(t *testing.T) { st := newTopologyStore(t) campus, err := st.GetDefaultCampus() if err != nil { t.Fatal(err) } err = st.UpdateCampus( campus.ID, campus.Name, campus.Title, campus.DefaultLang, campus.AuthorityMode, campus.FQDN, false, ) if err == nil { t.Fatal("last enabled campus was disabled") } } func TestPathsAreIsolatedByDomain(t *testing.T) { st := newTopologyStore(t) campus, err := st.GetDefaultCampus() if err != nil { t.Fatal(err) } defaultDomain, err := st.GetDefaultDomain() if err != nil { t.Fatal(err) } if err := st.CreateDomain( campus.UUID, "engineering", "Engineering", "engineering.example.test", "local", "", "", true, ); err != nil { t.Fatal(err) } engineering, err := st.GetDomainByHost("engineering.example.test") if err != nil { t.Fatal(err) } defaultObject, err := st.CreatePageAtPathInDomain( defaultDomain.UUID, "/handbook", ) if err != nil { t.Fatal(err) } engineeringObject, err := st.CreatePageAtPathInDomain( engineering.UUID, "/handbook", ) if err != nil { t.Fatal(err) } if defaultObject == engineeringObject { t.Fatal("separate Page creation reused an Object UUID") } resolvedDefault, err := st.ResolvePathInDomain( defaultDomain.UUID, "/handbook", ) if err != nil { t.Fatal(err) } resolvedEngineering, err := st.ResolvePathInDomain( engineering.UUID, "/handbook", ) if err != nil { t.Fatal(err) } if resolvedDefault != defaultObject { t.Fatalf("default Domain resolved %q", resolvedDefault) } if resolvedEngineering != engineeringObject { t.Fatalf("engineering Domain resolved %q", resolvedEngineering) } if err := st.BindPathInDomain( engineering.UUID, "/shared", defaultObject, ); err != nil { t.Fatal(err) } shared, err := st.ResolvePathInDomain(engineering.UUID, "/shared") if err != nil { t.Fatal(err) } if shared != defaultObject { t.Fatalf("cross-Domain MagicPage resolved %q", shared) } defaultRecent, err := st.ListRecentObjectsInDomain( defaultDomain.UUID, 20, ) if err != nil { t.Fatal(err) } if len(defaultRecent) != 1 || defaultRecent[0].UUID != defaultObject { t.Fatalf("default Domain recent Objects = %#v", defaultRecent) } engineeringRecent, err := st.ListRecentObjectsInDomain( engineering.UUID, 20, ) if err != nil { t.Fatal(err) } if len(engineeringRecent) != 2 { t.Fatalf( "engineering Domain recent Object count = %d", len(engineeringRecent), ) } } func TestChildPathsIncludeSyntheticImmediateDirectoriesAndInvalidateCache( t *testing.T, ) { st := newTopologyStore(t) domain, err := st.GetDefaultDomain() if err != nil { t.Fatal(err) } objectUUID, err := st.CreatePageAtPathInDomain( domain.UUID, "/guides/go/install", ) if err != nil { t.Fatal(err) } children, err := st.ListChildPathsInDomain(domain.UUID, "/guides") if err != nil { t.Fatal(err) } if len(children) != 1 || children[0] != "/guides/go" { t.Fatalf("synthetic children = %#v", children) } if err := st.BindPathInDomain( domain.UUID, "/guides/rust/install", objectUUID, ); err != nil { t.Fatal(err) } children, err = st.ListChildPathsInDomain(domain.UUID, "/guides") if err != nil { t.Fatal(err) } if len(children) != 2 || children[0] != "/guides/go" || children[1] != "/guides/rust" { t.Fatalf("children after cache invalidation = %#v", children) } } func TestLegacyPathsMigrateToDefaultDomain(t *testing.T) { database, err := db.Open(t.TempDir() + "/pages.db") if err != nil { t.Fatal(err) } defer database.Close() if err := db.Migrate(database); err != nil { t.Fatal(err) } if _, err := database.Exec(` INSERT INTO objects (uuid, kind, created_at) VALUES ('legacy-page', 'page', 1); INSERT INTO paths (path, object_uuid, created_at) VALUES ('/legacy', 'legacy-page', 1); `); err != nil { t.Fatal(err) } st := store.New(database) domain, err := st.GetDefaultDomain() if err != nil { t.Fatal(err) } var domainUUID, objectUUID string if err := database.QueryRow(` SELECT domain_uuid, object_uuid FROM paths WHERE path = '/legacy' `).Scan(&domainUUID, &objectUUID); err != nil { t.Fatal(err) } if domainUUID != domain.UUID { t.Fatalf("migrated Domain UUID = %q, want %q", domainUUID, domain.UUID) } if objectUUID != "legacy-page" { t.Fatalf("migrated Object UUID = %q", objectUUID) } } func TestRemoteDomainHasNoLocalPathNamespace(t *testing.T) { st := newTopologyStore(t) campus, err := st.GetDefaultCampus() if err != nil { t.Fatal(err) } if err := st.CreateDomain( campus.UUID, "remote-docs", "Remote Docs", "remote.example.test", "remote", "", "", true, ); err != nil { t.Fatal(err) } remote, err := st.GetDomainByHost("remote.example.test") if err != nil { t.Fatal(err) } if remote.Placement != "remote" { t.Fatalf("placement = %q", remote.Placement) } if _, err := st.CreatePageAtPathInDomain( remote.UUID, "/must-not-exist", ); err == nil { t.Fatal("created a Page path in a remote Domain") } } func TestManagedCampusRequiresFQDN(t *testing.T) { st := newTopologyStore(t) if err := st.CreateCampus( "managed", "Managed Campus", "ja", "managed", "", true, ); err == nil { t.Fatal("managed Campus without an FQDN was created") } } func TestControllerCampusRequiresDomainInstanceFQDN(t *testing.T) { st := newTopologyStore(t) if err := st.CreateCampus( "controller", "Controller Campus", "en", "controller", "campus.example.test", true, ); err != nil { t.Fatal(err) } var controller store.Campus campuses, err := st.ListCampuses() if err != nil { t.Fatal(err) } for _, campus := range campuses { if campus.Name == "controller" { controller = campus break } } if err := st.CreateDomain( controller.UUID, "controlled", "Controlled", "controlled", "remote", "", "", true, ); err == nil { t.Fatal("controller Domain without instance FQDN was created") } token, err := st.IssueCampusToken(controller.UUID, "test") if err != nil { t.Fatal(err) } fingerprint, publicKey, signature := registrationProof(t, "node.example.test", token) _, instance, err := st.RegisterFederationInstance( token, "node.example.test", fingerprint, publicKey, signature, ) if err != nil { t.Fatal(err) } if err := st.SetFederationInstanceStatus( instance.ID, "approved", ); err != nil { t.Fatal(err) } if err := st.CreateDomain( controller.UUID, "controlled", "Controlled", "controlled", "remote", "node.example.test", fingerprint, true, ); err != nil { t.Fatal(err) } domain, err := st.GetDomainByHost( "controlled.campus.example.test", ) if err != nil { t.Fatal(err) } if domain.InstanceFQDN != "node.example.test" { t.Fatalf("instance FQDN = %q", domain.InstanceFQDN) } if domain.InstanceFingerprint != fingerprint { t.Fatalf("instance fingerprint = %q", domain.InstanceFingerprint) } if err := st.SetFederationInstanceStatus( instance.ID, "revoked", ); err != nil { t.Fatal(err) } disabled, err := st.GetDomainByUUID(domain.UUID) if err != nil { t.Fatal(err) } if disabled.Enabled { t.Fatal("Domain remained enabled after its instance was revoked") } } func TestDomainHostResolutionUsesCampusFQDNWithoutFallback(t *testing.T) { st := newTopologyStore(t) defaultDomain, err := st.GetDefaultDomain() if err != nil { t.Fatal(err) } resolved, err := st.GetDomainByHost("localhost") if err != nil { t.Fatal(err) } if resolved.UUID != defaultDomain.UUID { t.Fatalf("localhost resolved Domain %q", resolved.UUID) } if _, err := st.GetDomainByHost("unknown.example.test"); !errors.Is( err, sql.ErrNoRows, ) { t.Fatalf("unknown Host error = %v, want sql.ErrNoRows", err) } } func TestConfigIsIsolatedByDomain(t *testing.T) { st := newTopologyStore(t) if err := st.EnsureConfigTable(); err != nil { t.Fatal(err) } campus, err := st.GetDefaultCampus() if err != nil { t.Fatal(err) } defaultDomain, err := st.GetDefaultDomain() if err != nil { t.Fatal(err) } if err := st.CreateDomain( campus.UUID, "second", "Second", "second.localhost", "local", "", "", true, ); err != nil { t.Fatal(err) } second, err := st.GetDomainByHost("second.localhost") if err != nil { t.Fatal(err) } if err := st.SetConfigInDomain( defaultDomain.UUID, "wiki_name", "Default Wiki", ); err != nil { t.Fatal(err) } if err := st.SetConfigInDomain( second.UUID, "wiki_name", "Second Wiki", ); err != nil { t.Fatal(err) } defaultName, err := st.GetConfigInDomain(defaultDomain.UUID, "wiki_name") if err != nil { t.Fatal(err) } secondName, err := st.GetConfigInDomain(second.UUID, "wiki_name") if err != nil { t.Fatal(err) } if defaultName != "Default Wiki" || secondName != "Second Wiki" { t.Fatalf("config values = %q, %q", defaultName, secondName) } } func TestNewDomainInheritsCampusDefaultLanguage(t *testing.T) { st := newTopologyStore(t) if err := st.EnsureConfigTable(); err != nil { t.Fatal(err) } if err := st.CreateCampus( "japanese", "Japanese Campus", "ja-JP", "standalone", "ja.example.test", true, ); err != nil { t.Fatal(err) } var campus store.Campus campuses, err := st.ListCampuses() if err != nil { t.Fatal(err) } for _, candidate := range campuses { if candidate.Name == "japanese" { campus = candidate break } } if err := st.CreateDomain( campus.UUID, "docs-ja", "Japanese Documentation", "docs.ja.example.test", "local", "", "", true, ); err != nil { t.Fatal(err) } domain, err := st.GetDomainByHost("docs.ja.example.test") if err != nil { t.Fatal(err) } locale, err := st.GetConfigInDomain(domain.UUID, "locale") if err != nil { t.Fatal(err) } if locale != "ja" { t.Fatalf("Domain locale = %q, want ja", locale) } } func TestLegacyConfigMigratesToDefaultDomain(t *testing.T) { st := newTopologyStore(t) if _, err := st.DB.Exec(` CREATE TABLE config ( key TEXT PRIMARY KEY, value TEXT NOT NULL, updated_at INTEGER NOT NULL ); INSERT INTO config (key, value, updated_at) VALUES ('wiki_name', 'Legacy Wiki', 1); `); err != nil { t.Fatal(err) } if err := st.EnsureConfigTable(); err != nil { t.Fatal(err) } domain, err := st.GetDefaultDomain() if err != nil { t.Fatal(err) } value, err := st.GetConfigInDomain(domain.UUID, "wiki_name") if err != nil { t.Fatal(err) } if value != "Legacy Wiki" { t.Fatalf("migrated config = %q", value) } }