feat(storage): add native PostgreSQL runtime and verified offline application import
Build and publish container images / images (push) Failing after 12m29s

This commit is contained in:
Anya Tokugawa committed 2026-11-15 05:47:14 +09:00
1 parent 96065d1e89
commit 0ba1dcfef0
243 files changed
+21441 -3090

No files matched your search

+321
View File
@@ -0,0 +1,321 @@
package metadata
import (
"context"
"errors"
"net/url"
"os"
"strings"
"testing"
"time"
"pageswiki/internal/db"
"pageswiki/internal/geduldh"
)
func TestPortabilityIsFailClosed(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
for _, change := range []string{"table", "view", "column", "history", "component"} {
t.Run(string(backend)+"/"+change, func(t *testing.T) {
r := testRepository(t, backend)
ctx := context.Background()
report, err := r.InspectPortability(ctx)
if err != nil || !report.CoreCompatible || report.ApplicationReady {
t.Fatal("fresh core readiness", err, report)
}
q := map[string]string{
"table": `CREATE TABLE auth_private_users(secret TEXT)`,
"view": `CREATE VIEW private_view AS SELECT uuid FROM objects`,
"column": `ALTER TABLE objects ADD COLUMN unexpected TEXT`,
"history": `UPDATE schema_migration_steps SET checksum='tampered' WHERE version=1`,
"component": `INSERT INTO schema_migration_steps(component,version,name,checksum,applied_at_ms) VALUES ('future',1,'other','unknown',1)`,
}[change]
if _, err := r.database.ExecContext(ctx, q); err != nil {
t.Fatal(err)
}
report, err = r.InspectPortability(ctx)
if err != nil || report.CoreCompatible || len(report.Blockers) == 0 {
t.Fatal("unsupported state accepted", err, report)
}
if _, err := r.FingerprintCore(ctx); !errors.Is(err, ErrMigrationBlocked) {
t.Fatal("unsupported state fingerprinted as portable", err)
}
})
}
}
}
func TestPortabilityDoesNotHideSameNamedTrigger(t *testing.T) {
r := testRepository(t, SQLite)
ctx := context.Background()
if _, err := r.database.ExecContext(ctx, `CREATE TRIGGER objects AFTER UPDATE ON objects BEGIN SELECT 1; END`); err != nil {
t.Fatal(err)
}
report, err := r.InspectPortability(ctx)
if err != nil || report.CoreCompatible {
t.Fatal("security trigger hidden by table name", err)
}
if !strings.Contains(strings.Join(report.Blockers, " "), "trigger: objects") {
t.Fatal("trigger not identified", report)
}
}
func seedRehearsal(t *testing.T, r *Repository) (geduldh.Store, Revision) {
t.Helper()
ctx := context.Background()
docs, _, v := documentFixture(t, r)
first, err := r.SaveDocument(ctx, docs, "test", v, []byte(`<h1>移行</h1><img src="asset:image:cover">`), "", "actor")
if err != nil {
t.Fatal(err)
}
if err := r.BindPath(ctx, "test", "/alias", v.ObjectUUID); err != nil {
t.Fatal(err)
}
for _, path := range []string{"/日本語%_", "/Case", "/case", "/é", "/e\u0301"} {
if err := r.BindPath(ctx, "test", path, v.ObjectUUID); err != nil {
t.Fatal(err)
}
}
// Values above JavaScript's safe-integer range must never pass through
// float64 on the migration path. Also exercise identity/sequence recovery.
const large = int64(9007199254741011)
if _, err := r.database.ExecContext(ctx, `UPDATE asset_head_history SET id=`+r.p(1), large); err != nil {
t.Fatal(err)
}
if _, err := r.database.ExecContext(ctx, `UPDATE activity_outbox SET sequence=`+r.p(1)+`,status='failed',attempts=3,last_error='synthetic'`, large); err != nil {
t.Fatal(err)
}
if _, err := r.database.ExecContext(ctx, `UPDATE activity_outbox_heads SET last_sequence=`+r.p(1), large); err != nil {
t.Fatal(err)
}
return docs, first.Revision
}
func TestCoreFingerprintIncludesContentAndPurgedIdentity(t *testing.T) {
source := testRepository(t, SQLite)
target := testRepository(t, SQLite)
ctx := context.Background()
docs, v := seedRehearsal(t, source)
before, err := source.FingerprintCore(ctx)
if err != nil {
t.Fatal(err)
}
if _, err := source.database.ExecContext(ctx, `UPDATE objects SET kind='changed' WHERE uuid=?`, v.ObjectUUID); err != nil {
t.Fatal(err)
}
after, err := source.FingerprintCore(ctx)
if err != nil || after.SHA256 == before.SHA256 {
t.Fatal("same row counts hid content change", err)
}
// A retained generator high-water mark must survive even if the highest
// history rows have been purged. Reusing an old history URL is not safe.
if _, err := source.database.ExecContext(ctx, `UPDATE sqlite_sequence SET seq=9007199254741999 WHERE name='asset_head_history'`); err != nil {
t.Fatal(err)
}
result, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true, Documents: docs})
if err != nil || result.IdentityNext != 9007199254742000 {
t.Fatal("purged sequence lost", err, result.IdentityNext)
}
a, err := target.GetAsset(ctx, "test", "asset:image:cover")
if err != nil {
t.Fatal(err)
}
if _, err := target.PutAsset(ctx, a, a.HeadDocumentHash, "actor"); err != nil {
t.Fatal(err)
}
var id int64
if err := target.database.QueryRowContext(ctx, `SELECT max(id) FROM asset_head_history`).Scan(&id); err != nil || id != result.IdentityNext {
t.Fatal("old history ID reused", err, id)
}
if _, err := source.database.ExecContext(ctx, `UPDATE objects SET created_at='not-an-integer'`); err != nil {
t.Fatal(err)
}
if _, err := source.FingerprintCore(ctx); !errors.Is(err, ErrIntegrity) {
t.Fatal("invalid integer type accepted", err)
}
}
func TestCoreRoundTripSQLitePostgreSQLSQLite(t *testing.T) {
source := testRepository(t, SQLite)
target := testRepository(t, PostgreSQL)
restored := testRepository(t, SQLite)
ctx := context.Background()
docs, first := seedRehearsal(t, source)
before, err := source.FingerprintCore(ctx)
if err != nil {
t.Fatal(err)
}
result, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true, Documents: docs})
if err != nil || result.SHA256 != before.SHA256 {
t.Fatal("SQLite to PostgreSQL", err, result)
}
got, err := target.Head(ctx, "test", first.ObjectUUID, first.Language)
if err != nil || got != first {
t.Fatal("revision identity/content changed", err)
}
asset, err := target.GetAsset(ctx, "test", "asset:image:cover")
if err != nil {
t.Fatal(err)
}
asset.Filename = "new.png"
if _, err := target.PutAsset(ctx, asset, asset.HeadDocumentHash, "actor"); err != nil {
t.Fatal("identity sequence not repaired", err)
}
var id int64
if err := target.database.QueryRowContext(ctx, `SELECT max(id) FROM asset_head_history`).Scan(&id); err != nil || id != 9007199254741012 {
t.Fatal("identity precision/restart", id, err)
}
if _, err := target.database.ExecContext(ctx, `ALTER TABLE asset_head_history ALTER COLUMN id RESTART WITH 9007199254743000`); err != nil {
t.Fatal(err)
}
next, err := target.SaveDocument(ctx, docs, "test", first, []byte(`<h1>PostgreSQLで更新</h1>`), first.UUID, "actor")
if err != nil {
t.Fatal(err)
}
targetState, err := target.FingerprintCore(ctx)
if err != nil {
t.Fatal(err)
}
back, err := CloneCoreForRehearsal(ctx, target, restored, RehearsalOptions{Offline: true, Documents: docs})
if err != nil || back.SHA256 != targetState.SHA256 {
t.Fatal("PostgreSQL to SQLite", err)
}
if got, err := restored.Head(ctx, "test", first.ObjectUUID, first.Language); err != nil || got.UUID != next.Revision.UUID {
t.Fatal("post-cutover update lost on rollback", err)
}
if got, err := source.FingerprintCore(ctx); err != nil || got.SHA256 != before.SHA256 {
t.Fatal("source was modified", err)
}
if _, err := restored.PutAsset(ctx, asset, asset.HeadDocumentHash, "actor"); err != nil {
t.Fatal("SQLite sequence not recovered", err)
}
if err := restored.database.QueryRowContext(ctx, `SELECT max(id) FROM asset_head_history`).Scan(&id); err != nil || id != 9007199254743000 {
t.Fatal("PostgreSQL retained generator state lost", id, err)
}
}
func TestCoreCloneRejectsSameDatabaseThroughDifferentPools(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
r := testRepository(t, backend)
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
var alias *Repository
if backend == SQLite {
var file string
if err := r.database.QueryRow(`SELECT file FROM pragma_database_list WHERE name='main'`).Scan(&file); err != nil {
t.Fatal(err)
}
database, err := db.Open(file)
if err != nil {
t.Fatal(err)
}
defer database.Close()
alias, _ = New(database, backend)
} else {
var schema string
if err := r.database.QueryRow(`SELECT current_schema()`).Scan(&schema); err != nil {
t.Fatal(err)
}
u, err := url.Parse(os.Getenv("PAGESWIKI_TEST_POSTGRES_DSN"))
if err != nil {
t.Fatal("invalid test DSN")
}
q := u.Query()
q.Set("search_path", schema)
u.RawQuery = q.Encode()
database, err := db.OpenPostgreSQL(ctx, db.PostgreSQLOptions{DSN: u.String(), AllowInsecure: true})
if err != nil {
t.Fatal(err)
}
defer database.Close()
alias, _ = New(database, backend)
}
documents, _ := geduldh.NewLocal(t.TempDir())
if _, err := CloneCoreForRehearsal(ctx, r, alias, RehearsalOptions{Offline: true, Documents: documents}); !errors.Is(err, ErrMigrationBlocked) {
t.Fatal("self-copy not rejected before locking", err)
}
})
}
}
func TestCoreCloneRejectsUnsafeConditionsAndRollsBack(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
source := testRepository(t, SQLite)
target := testRepository(t, backend)
ctx := context.Background()
docs, _ := seedRehearsal(t, source)
if _, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Documents: docs}); !errors.Is(err, ErrMigrationBlocked) {
t.Fatal("online migration permitted", err)
}
if _, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true}); !errors.Is(err, ErrMigrationBlocked) {
t.Fatal("unverified Documents permitted", err)
}
empty, err := target.FingerprintCore(ctx)
if err != nil {
t.Fatal(err)
}
// Extra uniqueness rules must block the plan before any copying.
if _, err := target.database.ExecContext(ctx, `CREATE UNIQUE INDEX synthetic_rehearsal_failure ON paths(object_uuid)`); err != nil {
t.Fatal(err)
}
if _, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true, Documents: docs}); !errors.Is(err, ErrMigrationBlocked) {
t.Fatal("unexpected unique index accepted", err)
}
if _, err := target.database.ExecContext(ctx, `DROP INDEX synthetic_rehearsal_failure`); err != nil {
t.Fatal(err)
}
if got, err := target.FingerprintCore(ctx); err != nil || got.SHA256 != empty.SHA256 {
t.Fatal("partial destination rows survived", err)
}
// SQLite can contain a BLOB despite a TEXT declaration. Detect it
// while streaming, after earlier tables have been inserted, and roll
// back every destination row instead of coercing or truncating it.
if _, err := source.database.ExecContext(ctx, `UPDATE paths SET path=CAST(path AS BLOB)`); err != nil {
t.Fatal(err)
}
if _, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true, Documents: docs}); !errors.Is(err, ErrIntegrity) {
t.Fatal("nonportable row accepted", err)
}
if got, err := target.FingerprintCore(ctx); err != nil || got.SHA256 != empty.SHA256 {
t.Fatal("mid-copy failure left rows", err)
}
if _, err := source.database.ExecContext(ctx, `UPDATE paths SET path=CAST(path AS TEXT)`); err != nil {
t.Fatal(err)
}
if _, err := target.CreatePage(ctx, "test", "/do-not-overwrite"); err != nil {
t.Fatal(err)
}
occupied, err := target.FingerprintCore(ctx)
if err != nil {
t.Fatal(err)
}
if _, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true, Documents: docs}); !errors.Is(err, ErrDestinationNotEmpty) {
t.Fatal("occupied destination overwritten", err)
}
if got, err := target.FingerprintCore(ctx); err != nil || got.SHA256 != occupied.SHA256 {
t.Fatal("occupied target changed", err)
}
})
}
}
func TestCoreCloneRejectsMissingDocumentsAndBrokenRelations(t *testing.T) {
r := testRepository(t, SQLite)
target := testRepository(t, SQLite)
ctx := context.Background()
docs, _ := seedRehearsal(t, r)
if _, err := r.database.ExecContext(ctx, `UPDATE paths SET object_uuid='missing'`); err != nil {
t.Fatal(err)
}
if _, err := CloneCoreForRehearsal(ctx, r, target, RehearsalOptions{Offline: true, Documents: docs}); !errors.Is(err, ErrIntegrity) {
t.Fatal("broken references copied", err)
}
r = testRepository(t, SQLite)
docs, _ = seedRehearsal(t, r)
missing, _ := geduldh.NewLocal(t.TempDir())
if _, err := CloneCoreForRehearsal(ctx, r, target, RehearsalOptions{Offline: true, Documents: missing}); !errors.Is(err, ErrIntegrity) {
t.Fatal("missing Document accepted", err)
}
}