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(`

移行

`), "", "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(`

PostgreSQLで更新

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