package store
import (
"bytes"
"context"
"crypto/sha256"
"database/sql"
"encoding/json"
"net/url"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"github.com/google/uuid"
"pageswiki/internal/db"
)
func TestApplicationImportRoundTrip(t *testing.T) {
ctx := context.Background()
source := testNamespaceStore(t, storeSQLite)
if _, err := source.NewCalendarRepository(ctx); err != nil {
t.Fatal(err)
}
domain, err := source.GetDefaultDomain()
if err != nil {
t.Fatal(err)
}
owner, err := source.BootstrapOwner(domain.UUID, "owner", "synthetic import password", "日本語 owner", "")
if err != nil {
t.Fatal(err)
}
if err = source.SetConfigInDomain(domain.UUID, "authorization_mode", "enforcing"); err != nil {
t.Fatal(err)
}
obj, err := source.CreatePageAtPathInDomain(domain.UUID, "/日本語/roundtrip")
if err != nil {
t.Fatal(err)
}
rev, err := source.SaveRevisionContent(obj, []byte("
Imported page
"), "commit message", "en", "text/html", "")
if err != nil {
t.Fatal(err)
}
if err = source.AddTag(obj, "日本語 tag"); err != nil {
t.Fatal(err)
}
token, err := source.CreateAuthSession(domain.UUID, owner.UUID)
if err != nil {
t.Fatal(err)
}
if _, err = source.DB.Exec(`UPDATE principals SET avatar=? WHERE uuid=?`, []byte{0, 1, 2, 255}, owner.UUID); err != nil {
t.Fatal(err)
}
task, err := source.SaveTaskDAV(ctx, domain.UUID, owner.UUID, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "移行タスク", Status: "todo", Bucket: "inbox"}, 0, &TaskDAVData{Name: "import.ics", UID: "import-task", Data: "synthetic VTODO"}, "", "")
if err != nil {
t.Fatal(err)
}
contact, err := source.SaveContact(ctx, domain.UUID, owner.UUID, Contact{UUID: uuid.NewString(), VCard: syntheticContact("import-contact")}, true)
if err != nil {
t.Fatal(err)
}
project, err := source.SaveTask(ctx, domain.UUID, owner.UUID, TaskRecord{UUID: uuid.NewString(), Kind: "project", Title: "移行 Project", Status: "todo", Bucket: "inbox"}, 0)
if err != nil {
t.Fatal(err)
}
projectTask, err := source.SaveTaskDAV(ctx, domain.UUID, owner.UUID, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "Project task", Status: "todo", Bucket: "inbox", ProjectUUID: project.UUID}, 0, &TaskDAVData{Name: "import.ics", UID: "import-task", Data: "synthetic VTODO"}, "", project.UUID)
if err != nil {
t.Fatal(err)
}
deleted, err := source.SaveTask(ctx, domain.UUID, owner.UUID, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "Deleted task", Status: "todo", Bucket: "inbox", ProjectUUID: project.UUID}, 0)
if err != nil {
t.Fatal(err)
}
if err = source.DeleteTask(ctx, domain.UUID, owner.UUID, deleted.UUID, deleted.Version); err != nil {
t.Fatal(err)
}
snapshot, err := source.ContactDAVSnapshot(ctx, domain.UUID, owner.UUID, "", 200)
if err != nil {
t.Fatal(err)
}
// Deleted highest sequence must not be reused after transfer.
if _, err = source.DB.Exec(`UPDATE sqlite_sequence SET seq=100000 WHERE name='organizer_contact_changes'`); err != nil {
t.Fatal(err)
}
target := testNamespaceStore(t, storePostgreSQL)
// Only synthetic bootstrap rows in this test's private schema are removed.
if _, err = target.DB.Exec(`DELETE FROM domains;DELETE FROM campuses;DELETE FROM config`); err != nil {
t.Fatal(err)
}
if err = PreparePostgreSQLImport(ctx, target.DB, source.DocumentRoot); err != nil {
t.Fatal(err)
}
if err = VerifyPostgreSQLImport(ctx, target.DB, source.DocumentRoot); err == nil {
t.Fatal("unimported target accepted")
}
// Force a late failure after row copying, without altering canonical files.
if _, err = source.DB.Exec(`INSERT INTO tags(object_uuid,tag,created_at) VALUES(?,?,?)`, obj, "rollback", "invalid bigint"); err != nil {
t.Fatal(err)
}
if _, err = ImportSQLiteApplication(ctx, source.DB, target.DB, source.DocumentRoot); err == nil {
t.Fatal("invalid row accepted")
}
var count int
if err = target.DB.QueryRow(`SELECT count(*) FROM domains`).Scan(&count); err != nil || count != 0 {
t.Fatal("partial import", count, err)
}
if err = target.DB.QueryRow(`SELECT count(*) FROM pg_trigger t JOIN pg_class c ON c.oid=t.tgrelid JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND NOT t.tgisinternal AND t.tgenabled='D'`).Scan(&count); err != nil || count != 0 {
t.Fatal("disabled triggers retained", count, err)
}
if _, err = source.DB.Exec(`DELETE FROM tags WHERE tag='rollback'`); err != nil {
t.Fatal(err)
}
if err = PreparePostgreSQLImport(ctx, target.DB, source.DocumentRoot); err != nil {
t.Fatal("retry preparation", err)
}
report, err := ImportSQLiteApplication(ctx, source.DB, target.DB, source.DocumentRoot)
if err != nil {
t.Fatal(err)
}
if report.Documents != 1 || len(report.Tables) < 130 || report.Fingerprint == "" {
t.Fatal(report)
}
if err = VerifyPostgreSQLImport(ctx, target.DB, source.DocumentRoot); err != nil {
t.Fatal(err)
}
st, err := NewPostgreSQLWithDocumentRoot(ctx, target.DB, source.DocumentRoot)
if err != nil {
t.Fatal(err)
}
got, err := st.GetRevision(rev.UUID)
if err != nil || got.Body != rev.Body {
t.Fatal(got, err)
}
p, err := st.PrincipalForSession(domain.UUID, token)
if err != nil || p.UUID != owner.UUID {
t.Fatal(p, err)
}
var avatar []byte
if err = target.DB.QueryRow(`SELECT avatar FROM principals WHERE uuid=$1`, owner.UUID).Scan(&avatar); err != nil || !bytes.Equal(avatar, []byte{0, 1, 2, 255}) {
t.Fatal(avatar, err)
}
tags, err := st.ListTags(obj)
if err != nil || len(tags) != 1 || tags[0] != "日本語 tag" {
t.Fatal(tags, err)
}
if got, err := st.TaskDAVByName(ctx, domain.UUID, owner.UUID, "import.ics"); err != nil || got.UUID != task.UUID || got.Title != task.Title {
t.Fatal(got, err)
}
if got, err := st.TaskDAVByName(ctx, domain.UUID, owner.UUID, "import.ics", project.UUID); err != nil || got.UUID != projectTask.UUID {
t.Fatal("project DAV identity", got, err)
}
if err = st.DeleteTask(ctx, domain.UUID, owner.UUID, deleted.UUID, deleted.Version); err != nil {
t.Fatal("delete idempotency", err)
}
if got, err := st.Contact(ctx, domain.UUID, owner.UUID, contact.UUID); err != nil || got.VCard != contact.VCard {
t.Fatal(got, err)
}
if got, err := st.ContactDAVSnapshot(ctx, domain.UUID, owner.UUID, snapshot.Token, 200); err != nil || len(got.Items) != 0 {
t.Fatal("sync continuity", got, err)
}
contact.Name = "After import"
if _, err = st.SaveContact(ctx, domain.UUID, owner.UUID, contact, false); err != nil {
t.Fatal(err)
}
var sequence int64
if err = target.DB.QueryRow(`SELECT max(sequence) FROM organizer_contact_changes`).Scan(&sequence); err != nil || sequence <= 100000 {
t.Fatal("sequence reused", sequence, err)
}
if err = PreparePostgreSQLImport(ctx, target.DB, source.DocumentRoot); err == nil {
t.Fatal("populated target preparation accepted")
}
if os.Getenv("PAGESWIKI_TEST_POSTGRES_CONTAINER") != "" {
restored := restoreImportTestSchema(t, target)
if err = VerifyPostgreSQLImport(ctx, restored, source.DocumentRoot); err != nil {
t.Fatal(err)
}
r, err := NewPostgreSQLWithDocumentRoot(ctx, restored, source.DocumentRoot)
if err != nil {
t.Fatal(err)
}
if got, err := r.GetRevision(rev.UUID); err != nil || got.Body != rev.Body {
t.Fatal("restored revision", err)
}
if got, err := r.PrincipalForSession(domain.UUID, token); err != nil || got.UUID != owner.UUID {
t.Fatal("restored session", err)
}
if got, err := r.TaskDAVByName(ctx, domain.UUID, owner.UUID, "import.ics", project.UUID); err != nil || got.UUID != projectTask.UUID {
t.Fatal("restored task DAV", err)
}
if _, err = r.ContactDAVSnapshot(ctx, domain.UUID, owner.UUID, snapshot.Token, 200); err != nil {
t.Fatal("restored contact sync", err)
}
t.Log("schema-scoped pg_dump/pg_restore and canonical-file reuse verified")
}
if _, err = ImportSQLiteApplication(ctx, source.DB, target.DB, source.DocumentRoot); err == nil {
t.Fatal("overwrite accepted")
}
}
// Opt-in restore rehearsal: only the random schema created by this test is
// dumped and restored, inside the explicitly selected disposable container.
func restoreImportTestSchema(t *testing.T, source *Store) *sql.DB {
t.Helper()
container := os.Getenv("PAGESWIKI_TEST_POSTGRES_CONTAINER")
u, err := url.Parse(os.Getenv("PAGESWIKI_TEST_POSTGRES_DSN"))
if err != nil {
t.Fatal(err)
}
var schema string
if err = source.DB.QueryRow(`SELECT current_schema()`).Scan(&schema); err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(schema, "pageswiki_namespace_test_") {
t.Fatal("restore requires a private test schema")
}
database := strings.TrimPrefix(u.Path, "/")
dump, err := exec.Command("docker", "exec", container, "pg_dump", "-U", u.User.Username(), "-d", database, "-n", schema, "--no-owner", "--no-acl", "-Fc").Output()
if err != nil {
t.Fatal("synthetic schema pg_dump failed")
}
old := schema + "_old"
if _, err = source.DB.Exec(`ALTER SCHEMA ` + importIdent(schema) + ` RENAME TO ` + importIdent(old)); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _, _ = source.DB.Exec(`DROP SCHEMA IF EXISTS ` + importIdent(old) + ` CASCADE`) })
cmd := exec.Command("docker", "exec", "-i", container, "pg_restore", "-U", u.User.Username(), "-d", database, "--exit-on-error", "--no-owner", "--no-acl")
cmd.Stdin = bytes.NewReader(dump)
if err = cmd.Run(); err != nil {
t.Fatal("synthetic schema pg_restore failed")
}
q := u.Query()
q.Set("search_path", schema)
u.RawQuery = q.Encode()
restored, err := db.OpenPostgreSQL(context.Background(), db.PostgreSQLOptions{DSN: u.String(), AllowInsecure: true})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { restored.Close() })
return restored
}
func TestApplicationImportScalarFingerprint(t *testing.T) {
seen := map[string]bool{}
for _, v := range []any{nil, "", []byte{}, "YQ==", []byte("a"), int64(1), float64(1), true} {
b, err := importRowBytes([]any{v})
if err != nil || seen[string(b)] {
t.Fatal("scalar collision", err)
}
seen[string(b)] = true
}
}
func TestApplicationImportRejectsSourceDrift(t *testing.T) {
for _, ddl := range []string{`CREATE TABLE unexpected(secret TEXT)`, `ALTER TABLE tags ADD COLUMN unexpected TEXT`, `CREATE TRIGGER unexpected AFTER INSERT ON tags BEGIN SELECT 1; END`} {
t.Run(strings.Fields(ddl)[1], func(t *testing.T) {
s := testNamespaceStore(t, storeSQLite)
if _, err := InspectSQLiteApplicationImport(context.Background(), s.DB); err != nil {
t.Fatal(err)
}
if _, err := s.DB.Exec(ddl); err != nil {
t.Fatal(err)
}
if _, err := InspectSQLiteApplicationImport(context.Background(), s.DB); err == nil {
t.Fatal("schema drift accepted")
}
})
}
}
// Opt-in schema inventory contains table/column metadata only, never user rows.
func TestApplicationImportCatalogInventory(t *testing.T) {
if os.Getenv("PAGESWIKI_IMPORT_CATALOG") != "1" {
t.Skip("schema inventory")
}
ctx := context.Background()
for _, backend := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
s := testNamespaceStore(t, backend)
if backend == storePostgreSQL {
root := filepath.Join(t.TempDir(), "documents")
if err := os.Mkdir(root, 0700); err != nil {
t.Fatal(err)
}
t.Setenv("PAGESWIKI_AUTH_KEY", "synthetic catalog key")
var err error
s, err = NewPostgreSQLWithDocumentRoot(ctx, s.DB, root)
if err != nil {
t.Fatal(err)
}
}
if _, err := s.NewCalendarRepository(ctx); err != nil {
t.Fatal(err)
}
query := `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`
if backend == storePostgreSQL {
query = `SELECT table_name FROM information_schema.tables WHERE table_schema=current_schema() AND table_type='BASE TABLE' ORDER BY table_name`
}
rows, err := s.DB.Query(query)
if err != nil {
t.Fatal(err)
}
var tables []string
for rows.Next() {
var n string
if err = rows.Scan(&n); err != nil {
t.Fatal(err)
}
tables = append(tables, n)
}
rows.Close()
if backend == storeSQLite {
objects, err := s.DB.Query(`SELECT type,name,sql FROM sqlite_master WHERE type IN ('trigger','view') ORDER BY name`)
if err != nil {
t.Fatal(err)
}
for objects.Next() {
var kind, name, ddl string
if err = objects.Scan(&kind, &name, &ddl); err != nil {
t.Fatal(err)
}
t.Logf("SOURCEOBJECT %s %s %x", kind, name, sha256.Sum256([]byte(ddl)))
}
objects.Close()
}
for _, table := range tables {
var cols *sql.Rows
if backend == storeSQLite {
cols, err = s.DB.Query(`SELECT name,type FROM pragma_table_info(?) ORDER BY name`, table)
} else {
cols, err = s.DB.Query(`SELECT column_name,data_type FROM information_schema.columns WHERE table_schema=current_schema() AND table_name=$1 ORDER BY column_name`, table)
}
if err != nil {
t.Fatal(err)
}
columns := map[string]string{}
for cols.Next() {
var name, kind string
if err = cols.Scan(&name, &kind); err != nil {
t.Fatal(err)
}
columns[name] = kind
}
cols.Close()
b, _ := json.Marshal(columns)
t.Logf("CATALOG %d %s %s", backend, table, b)
}
}
}