feat(storage): add native PostgreSQL runtime and verified offline application import
Build and publish container images / images (push) Failing after 12m29s
Build and publish container images / images (push) Failing after 12m29s
This commit is contained in:
1 parent
96065d1e89
commit
0ba1dcfef0
243 files changed
+21441
-3090
No files matched your search
@@ -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)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user