349 lines
13 KiB
Go
349 lines
13 KiB
Go
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("<h1>Imported page</h1>"), "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)
|
|
}
|
|
}
|
|
}
|