Files
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

631 lines
12 KiB
Go

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