Files
knowledge-governance/cmd/worker/library_finalize_r11_integration_test.go
T
姚章浩 8febe12d7d test(library): 隔离数据契约与 r11 身份自然键矩阵
真实本机 PG/ES/MinIO:v071 目录镜像 10 模式、结构引用/游标 15 模式、
8 表×2 外部范围身份矩阵、13 模式自然键(含软删除与合法同 parent 正例)、
备份期间三注入、收尾故障与授权撤销两个真实治理 PG 用例。

需隔离服务的用例在 test-scope.json 显式声明:普通 CI 跳过不算通过。
2026-11-01 11:35:09 +08:00

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