8febe12d7d
真实本机 PG/ES/MinIO:v071 目录镜像 10 模式、结构引用/游标 15 模式、 8 表×2 外部范围身份矩阵、13 模式自然键(含软删除与合法同 parent 正例)、 备份期间三注入、收尾故障与授权撤销两个真实治理 PG 用例。 需隔离服务的用例在 test-scope.json 显式声明:普通 CI 跳过不算通过。
198 lines
9.4 KiB
Go
198 lines
9.4 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"knowledge-governance/internal/governance"
|
|
postgresstore "knowledge-governance/internal/platform/postgres"
|
|
)
|
|
|
|
// B28:内容已通过校验之后的两类收尾故障必须只补收尾、不重写目标,且绝不伪报成功。
|
|
//
|
|
// 这里用真实治理 PG(维护行、作业行、版本事件行都是真表),故障只注入在
|
|
// “释放 scope 维护占用”这一个步骤上;其余调用照旧打到真库。
|
|
type r11FinishFaultStore struct {
|
|
*postgresstore.Store
|
|
applies *int
|
|
failOnRelease bool
|
|
releaseFailure error
|
|
}
|
|
|
|
func (s *r11FinishFaultStore) ReleaseLibraryMaintenance(ctx context.Context, scope, ownerJobID string, now time.Time) error {
|
|
if s.failOnRelease {
|
|
return s.releaseFailure
|
|
}
|
|
return s.Store.ReleaseLibraryMaintenance(ctx, scope, ownerJobID, now)
|
|
}
|
|
|
|
type r11HealthyTarget struct{ err error }
|
|
|
|
func (h r11HealthyTarget) VerifyRunning(context.Context) error { return h.err }
|
|
|
|
func TestR11FinalizeFailureAfterTerminalHoldsThenRepairsWithoutRewrite(t *testing.T) {
|
|
store, _ := openLedgerStore(t)
|
|
ctx := context.Background()
|
|
now := time.Now().UTC()
|
|
const (
|
|
scope = "internal"
|
|
instance = "kgseal-r11-finalize"
|
|
jobID = "libsync-r11-finalize"
|
|
target = "target-snap-r11-finalize"
|
|
backup = "backup-snap-r11-finalize"
|
|
operation = "libop-r11-finalize"
|
|
)
|
|
if _, _, err := store.CreateLibraryJob(ctx, governance.LibraryJob{ID: jobID, Scope: scope,
|
|
Kind: governance.LibraryJobSync, IdempotencyKey: "library.sync:internal:r11-finalize",
|
|
RequestDigest: "digest-r11-finalize", Actor: "admin", TargetSnapshotID: target},
|
|
governance.SyncStages(), now); err != nil {
|
|
t.Fatalf("create library job: %v", err)
|
|
}
|
|
// 生效事件必须引用真实 operation:登记前先落这条执行意图(真表,不是夹具)。
|
|
if _, _, err := store.EnsureLibraryOperation(ctx, governance.LibraryOperation{ID: operation, Scope: scope,
|
|
Kind: governance.LibraryJobSync, TargetSnapshotID: target, RequestDigest: "digest-r11-finalize",
|
|
OperationKey: "r11-finalize", Actor: "admin", CreatedAt: now}); err != nil {
|
|
t.Fatalf("ensure library operation: %v", err)
|
|
}
|
|
// 这次作业确实持有两把维护锁:收尾失败后必须仍然持有(页面显示维护中)。
|
|
if _, err := store.AcquireLibraryMaintenance(ctx, postgresstore.LibraryMaintenance{Scope: scope,
|
|
OwnerJobID: jobID, TargetIdentity: "scope=" + scope, Level: "library", State: "acquired",
|
|
IngressState: "closed", Services: []string{"app"}}, now); err != nil {
|
|
t.Fatalf("acquire library maintenance: %v", err)
|
|
}
|
|
if _, err := store.AcquireInstanceMaintenance(ctx, postgresstore.LibraryInstanceMaintenance{Instance: instance,
|
|
OwnerJobID: jobID, OwnerScope: scope, TargetFingerprint: "fingerprint-r11",
|
|
Level: "instance", Services: []string{"app"}, IngressState: "closed", State: "acquired"}, now); err != nil {
|
|
t.Fatalf("acquire instance maintenance: %v", err)
|
|
}
|
|
// 完整锚点:真实字节数与写集合摘要。缺任何一项,收尾都该拒绝登记而不是补一份空台账。
|
|
if err := store.RecordLibraryVersion(ctx, governance.LibraryVersion{
|
|
ID: governance.LibraryVersionID(governance.LibraryVersionProductionPrebackup, scope, backup),
|
|
Scope: scope, Kind: governance.LibraryVersionProductionPrebackup, SnapshotID: backup,
|
|
SourceJobID: jobID, CreatedBy: "tester",
|
|
Evidence: map[string]any{"backup_snapshot": backup, "backup_bytes": float64(4096),
|
|
"writeset_digest": "writeset-digest-r11", "writeset_rows": float64(7)},
|
|
CreatedAt: now,
|
|
}); err != nil {
|
|
t.Fatalf("record prebackup version: %v", err)
|
|
}
|
|
|
|
// 目标内容落盘且计数:任何“再来一次”的重写都会让计数增长。
|
|
root := t.TempDir()
|
|
published := filepath.Join(root, "target-content.txt")
|
|
if err := os.WriteFile(published, []byte("published-v1"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
applies := 1 // 内容写入(含校验)已经发生过一次
|
|
writer := &libraryAttemptWriter{Store: store, attempt: governance.LibraryAttempt{
|
|
OperationID: operation, JobID: jobID, Owner: "queue-r11-finalize"}}
|
|
recorder := libraryStageRecorder{store: store, jobID: jobID, scope: scope, operationID: operation}
|
|
payload := libraryReleasePayload{LibraryJobID: jobID, Scope: scope, TargetSnapshotID: target, FinalizeOnly: true}
|
|
previous := governance.LibraryJob{ID: jobID, Scope: scope, Kind: governance.LibraryJobSync,
|
|
SnapshotID: backup, TargetSnapshotID: target}
|
|
grant := governance.LibraryReleaseAuthorization{AuthorizedBy: "admin", Scope: scope, SnapshotID: target}
|
|
|
|
// 1) 事件登记失败(这里用真实数据缺口:锚点里没有写集合摘要)必须拒绝登记,
|
|
// 不写生效版本、不进入终态、不重写目标。
|
|
if err := store.RecordLibraryVersion(ctx, governance.LibraryVersion{
|
|
ID: governance.LibraryVersionID(governance.LibraryVersionProductionPrebackup, scope, backup+"-noanchor"),
|
|
Scope: scope, Kind: governance.LibraryVersionProductionPrebackup, SnapshotID: backup + "-noanchor",
|
|
SourceJobID: jobID + "-noanchor", CreatedBy: "tester",
|
|
Evidence: map[string]any{"backup_snapshot": backup + "-noanchor"},
|
|
CreatedAt: now,
|
|
}); err != nil {
|
|
t.Fatalf("record anchorless prebackup: %v", err)
|
|
}
|
|
badBoundary := payload
|
|
badBoundary.TargetSnapshotID = target + "-noanchor"
|
|
badPrevious := previous
|
|
badPrevious.SnapshotID = backup + "-noanchor"
|
|
if _, err := rebuildSuccessBoundary(ctx, writer, recorder, badBoundary, badPrevious,
|
|
governance.LibraryJobSync, grant); err == nil {
|
|
t.Fatal("anchorless prebackup was accepted as a success boundary")
|
|
}
|
|
if _, found, err := store.LibraryVersionByRef(ctx, scope, governance.LibraryVersionProductionEffective,
|
|
jobID, target+"-noanchor"); err != nil || found {
|
|
t.Fatalf("refused registration still wrote an effective version: found=%v err=%v", found, err)
|
|
}
|
|
if job, err := store.LibraryJob(ctx, jobID); err != nil || job.State == governance.LibraryJobSucceeded {
|
|
t.Fatalf("refused registration reported success: state=%v err=%v", job.State, err)
|
|
}
|
|
|
|
// 2) journal 终态之后、释放维护占用这一步失败:不许报成功,锁必须继续持有。
|
|
failing := &r11FinishFaultStore{Store: store, applies: &applies, failOnRelease: true,
|
|
releaseFailure: errors.New("injected: scope maintenance release failed after terminal journal")}
|
|
boundary := successBoundary{Ready: true, Backup: backup, Target: target, FinishedAt: now}
|
|
if err := finishLibrarySuccess(ctx, failing, r11HealthyTarget{}, instance, scope, jobID, boundary); err == nil {
|
|
t.Fatal("finish reported success even though the maintenance release failed")
|
|
}
|
|
if job, err := store.LibraryJob(ctx, jobID); err != nil || job.State != governance.LibraryJobFailed {
|
|
t.Fatalf("job must be failed after finalize failure: state=%v err=%v", job.State, err)
|
|
}
|
|
held, err := store.LibraryMaintenanceOf(ctx, scope)
|
|
if err != nil || held == nil || held.OwnerJobID != jobID || held.ReleasedAt != nil {
|
|
t.Fatalf("scope maintenance must stay held by this job: %+v err=%v", held, err)
|
|
}
|
|
if held.State != "needs_restore" {
|
|
t.Fatalf("held maintenance state = %q, want needs_restore", held.State)
|
|
}
|
|
if applies != 1 {
|
|
t.Fatalf("finalize failure rewrote target content: applies=%d", applies)
|
|
}
|
|
content, err := os.ReadFile(published)
|
|
if err != nil || string(content) != "published-v1" {
|
|
t.Fatalf("target bytes changed during finalize failure: %q err=%v", content, err)
|
|
}
|
|
|
|
// 3) 修复只补收尾:同一个持久凭据再收尾一次即可成功,且仍然不重写。
|
|
repaired := &r11FinishFaultStore{Store: store, applies: &applies}
|
|
if err := finishLibrarySuccess(ctx, repaired, r11HealthyTarget{}, instance, scope, jobID, boundary); err != nil {
|
|
t.Fatalf("finalize-only repair failed: %v", err)
|
|
}
|
|
if job, err := store.LibraryJob(ctx, jobID); err != nil || job.State != governance.LibraryJobSucceeded {
|
|
t.Fatalf("job not succeeded after repair: state=%v err=%v", job.State, err)
|
|
}
|
|
released, err := store.LibraryMaintenanceOf(ctx, scope)
|
|
if err != nil || released == nil || released.ReleasedAt == nil {
|
|
t.Fatalf("scope maintenance not released after repair: %+v err=%v", released, err)
|
|
}
|
|
if applies != 1 {
|
|
t.Fatalf("finalize-only repair rewrote target content: applies=%d", applies)
|
|
}
|
|
content, err = os.ReadFile(published)
|
|
if err != nil || string(content) != "published-v1" {
|
|
t.Fatalf("target bytes changed during repair: %q err=%v", content, err)
|
|
}
|
|
|
|
// 4) current/event 与实际内容一致:补登记的生效版本恰好一条,重复收尾不再新增。
|
|
if _, err := rebuildSuccessBoundary(ctx, writer, recorder, payload, previous,
|
|
governance.LibraryJobSync, grant); err != nil {
|
|
t.Fatalf("rebuild boundary after repair: %v", err)
|
|
}
|
|
if _, err := rebuildSuccessBoundary(ctx, writer, recorder, payload, previous,
|
|
governance.LibraryJobSync, grant); err != nil {
|
|
t.Fatalf("idempotent rebuild: %v", err)
|
|
}
|
|
current, found, err := store.LibraryCurrentVersion(ctx, scope)
|
|
if err != nil || !found || current.SnapshotID != target || current.SourceJobID != jobID {
|
|
t.Fatalf("current does not point at the repaired snapshot: %+v found=%v err=%v", current, found, err)
|
|
}
|
|
versions, err := store.LibraryVersionsBySnapshot(ctx, scope, target)
|
|
if err != nil {
|
|
t.Fatalf("read effective versions: %v", err)
|
|
}
|
|
same := 0
|
|
for _, version := range versions {
|
|
if version.Kind == governance.LibraryVersionProductionEffective {
|
|
same++
|
|
}
|
|
}
|
|
if same != 1 {
|
|
t.Fatalf("effective version rows for %s = %d, want exactly 1", target, same)
|
|
}
|
|
}
|