Files
knowledge-governance/cmd/worker/library_writeset_test.go
T
姚章浩 0252492e53 fix(library): 恢复保留下来的资源凭可审计证据复用
同步 A 成功后手工恢复 B,resources 表既不删行也不删对象;再同步 A 时,
resources 里那 21 行以“同租户但不在预备份范围”被判成别人的知识库,整次
同步在写第一笔之前被拒。

“目标里没人引用”不是归属证据:历史孤儿、其它知识库暂未绑定的资源都满足
它。改成唯一放行路径——可审计复用(v071/library_reuse.go):
1. 持久来源:这个目标成功同步过且登记过生效版本的快照,或它自己的预备份,
   且同一资源行在来源里内容一致;
2. 整行内容(除易变时间戳)与本次写入将要落地的行完全一致;
3. 该资源的对象字节与本次快照归档摘要一致。

三条同时成立才允许复用:写入阶段跳过它(不重写行、不重传对象),写集合里
记 existing+reused,恢复不清理;证据单独落盘 reuse/<digest>.json,摘要写进
写集合行,不冒充历史台账。内容不同、来源范围不同、或没有持久来源一律继续
拒绝,且拒绝发生在写入之前。

为什么把预备份也算来源:恢复作业的写集合同样会把“本目标历史状态里已有的
资源”判成跨范围冲突,而它们本来就出自这个目标自己的快照。

验证:隔离 PG+ES+MinIO 真服务下新增 5 个场景用例(复用成功且 xmin 不变、
无来源拒绝、内容不同拒绝、同内容不同来源拒绝、wiki 半写回滚只清本次新建);
v071 整包与全仓 go test 通过;make verify 15 项全绿。
2026-10-30 01:59:32 +08:00

206 lines
8.8 KiB
Go

package main
import (
"context"
"errors"
"os"
"path/filepath"
"strings"
"testing"
"time"
"knowledge-governance/internal/governance"
"knowledge-governance/internal/libraryrelease"
v071 "knowledge-governance/internal/releaseadapter/v071"
)
// 这里验证的是"治理侧的锚点":摘要真的写进版本证据、能按作业+目标+预备份取回,
// 并且任何一步对不上都返回错误(调用方据此不写目标 / 保持维护)。
// 归档文件的读写在 v071 的写集合用例里用真实文件验证。
type fakeVersionStore struct {
versions []governance.LibraryVersion
recorded *governance.LibraryVersion
err error
}
func (f *fakeVersionStore) LibraryVersions(context.Context, string, int) ([]governance.LibraryVersion, error) {
if f.err != nil {
return nil, f.err
}
return f.versions, nil
}
func (f *fakeVersionStore) RecordLibraryVersion(_ context.Context, version governance.LibraryVersion) error {
f.recorded = &version
return nil
}
func sealedLedger(t *testing.T, digest string) libraryrelease.WriteSet {
t.Helper()
set := libraryrelease.WriteSet{Version: libraryrelease.WriteSetVersion, JobID: "job-1", Target: "internal",
TenantID: 10001, KnowledgeBaseID: "kb", BackupSnapshotID: "backup-snap",
TargetSnapshotID: "target-snap", CreatedAt: time.Now().UTC(),
Rows: []libraryrelease.WriteSetRow{{Table: "resources", ID: "res-new"}},
Universe: map[string]libraryrelease.TableFingerprint{"resources": {Count: 2, Digest: "d"}}}
if err := set.Seal(); err != nil {
t.Fatal(err)
}
return set
}
func TestWriteSetEvidenceKeepsBackupEvidenceAndAddsAnchor(t *testing.T) {
set := sealedLedger(t, "")
evidence := writeSetEvidence(map[string]any{"backup_bytes": int64(4096), "index_mapping_sha256": "old"}, set, "mapping-1")
if evidence["backup_bytes"] != int64(4096) {
t.Fatalf("原预备份证据必须保留:%v", evidence)
}
if evidence["writeset_digest"] != set.Digest {
t.Fatalf("writeset_digest = %v, want %s", evidence["writeset_digest"], set.Digest)
}
if evidence["writeset_universe_digest"] != set.UniverseDigest() || evidence["writeset_universe_digest"] == "" {
t.Fatalf("整实例证据摘要必须登记:%v", evidence)
}
if evidence["index_mapping_sha256"] != "mapping-1" {
t.Fatalf("当前索引映射必须覆盖旧值:%v", evidence)
}
if evidence["writeset_job"] != nil && evidence["job"] != "job-1" {
t.Fatalf("写集合必须绑定作业:%v", evidence)
}
}
func TestWriteSetDigestLookupRequiresJobTargetAndSnapshotMatch(t *testing.T) {
store := &fakeVersionStore{versions: []governance.LibraryVersion{
{ID: "v1", Scope: "internal", Kind: governance.LibraryVersionProductionPrebackup, SnapshotID: "backup-snap",
SourceJobID: "job-1", Evidence: map[string]any{"writeset_digest": "digest-1"}},
{ID: "v2", Scope: "internal", Kind: governance.LibraryVersionProductionPrebackup, SnapshotID: "backup-snap",
SourceJobID: "job-2", Evidence: map[string]any{"writeset_digest": "digest-2"}},
}}
digest, err := writeSetDigestOf(context.Background(), store, "internal", "job-1", "backup-snap")
if err != nil || digest != "digest-1" {
t.Fatalf("digest = %q, err = %v", digest, err)
}
// 别的作业的版本不能被拿来用。
if _, err := writeSetDigestOf(context.Background(), store, "internal", "job-3", "backup-snap"); err == nil {
t.Fatal("找不到本作业的版本时必须失败")
}
// 有版本但没登记摘要 → 失败(不许当成"没有写集合"降级)。
missing := &fakeVersionStore{versions: []governance.LibraryVersion{{Kind: governance.LibraryVersionProductionPrebackup,
SnapshotID: "backup-snap", SourceJobID: "job-1", Evidence: map[string]any{}}}}
if _, err := writeSetDigestOf(context.Background(), missing, "internal", "job-1", "backup-snap"); err == nil {
t.Fatal("没有写集合摘要时必须失败")
}
// 读不到版本 → 失败。
if _, err := writeSetDigestOf(context.Background(), &fakeVersionStore{err: errors.New("db down")},
"internal", "job-1", "backup-snap"); err == nil {
t.Fatal("版本查询失败必须向上传递")
}
}
func TestLoadWriteSetForJobChecksBinding(t *testing.T) {
root := t.TempDir()
set := sealedLedger(t, "")
if _, err := v071.PersistWriteSet(root, &set); err != nil {
t.Fatal(err)
}
store := &fakeVersionStore{versions: []governance.LibraryVersion{{Kind: governance.LibraryVersionProductionPrebackup,
SnapshotID: "backup-snap", SourceJobID: "job-1", Evidence: map[string]any{"writeset_digest": set.Digest}}}}
loaded, err := loadWriteSetForJob(context.Background(), store, root, "internal", "job-1", "backup-snap")
if err != nil {
t.Fatalf("load: %v", err)
}
if loaded.Digest != set.Digest {
t.Fatalf("digest = %s", loaded.Digest)
}
// 目标不一致 → 拒绝(同一份记录不能被拿去恢复另一个目标)。
if _, err := loadWriteSetForJob(context.Background(), store, root, "external", "job-1", "backup-snap"); err == nil {
t.Fatal("目标不一致时必须失败")
}
// 作业不一致 → 拒绝。
if _, err := loadWriteSetForJob(context.Background(), store, root, "internal", "job-2", "backup-snap"); err == nil {
t.Fatal("作业不一致时必须失败")
}
// 记录文件被删 → 拒绝。
if err := os.Chmod(filepath.Join(root, "writesets", set.Digest+".json"), 0600); err != nil {
t.Fatal(err)
}
if err := os.Remove(filepath.Join(root, "writesets", set.Digest+".json")); err != nil {
t.Fatal(err)
}
if _, err := loadWriteSetForJob(context.Background(), store, root, "internal", "job-1", "backup-snap"); err == nil {
t.Fatal("写集合文件缺失时必须失败")
}
}
// 接管用的预备份来源:没有写集合就不许继续(返回错误,而不是给一个空引用)。
func TestLedgerBackupStoreRefusesWithoutWriteSet(t *testing.T) {
store := ledgerBackupStore{ref: libraryrelease.BackupRef{ID: "backup-1", SnapshotID: "backup-snap"}}
if _, err := store.Prepare(context.Background(), "target-snap", libraryrelease.CurrentState{}); err == nil {
t.Fatal("没有写集合时接管必须失败")
}
set := sealedLedger(t, "")
store.write = &set
ref, err := store.Prepare(context.Background(), "target-snap", libraryrelease.CurrentState{})
if err != nil {
t.Fatalf("prepare: %v", err)
}
if ref.WriteSet == nil || ref.WriteSet.Digest != set.Digest {
t.Fatalf("接管必须带上持久化的写集合:%+v", ref)
}
}
// 包装层必须把"写集合预检"这件事透出去:orchestrator 用的是类型断言,
// 少一个方法就等于静默跳过台账(真实后果:真作业没有 writeset_digest、也没有
// writesets/ 文件,崩溃接管无台账可读)。
type plainTarget struct{ applied int }
func (t *plainTarget) Current(context.Context) (libraryrelease.CurrentState, error) {
return libraryrelease.CurrentState{}, nil
}
func (t *plainTarget) Apply(context.Context, libraryrelease.Stage, string) error {
t.applied++
return nil
}
func (t *plainTarget) Verify(context.Context, libraryrelease.Expectation) error { return nil }
func (t *plainTarget) Restore(context.Context, libraryrelease.BackupRef) error { return nil }
type planningTarget struct {
plainTarget
planned int
last libraryrelease.WriteSetPlan
}
func (t *planningTarget) PlanWriteSet(_ context.Context, plan libraryrelease.WriteSetPlan) (libraryrelease.WriteSet, error) {
t.planned++
t.last = plan
return libraryrelease.WriteSet{Version: libraryrelease.WriteSetVersion, JobID: "job-1", Target: "internal"}, nil
}
func TestContentTrackedTargetForwardsWriteSetPlanning(t *testing.T) {
inner := &planningTarget{}
wrapped := &contentTrackedTarget{inner: inner, onApply: func() {}}
planner, ok := libraryrelease.Target(wrapped).(libraryrelease.WriteSetPlanner)
if !ok {
t.Fatal("包装后的目标必须仍然实现 WriteSetPlanner,否则写集合会被静默跳过")
}
if _, err := planner.PlanWriteSet(context.Background(), libraryrelease.WriteSetPlan{JobID: "job-1", Target: "internal",
PriorSnapshots: []libraryrelease.PriorSnapshot{{JobID: "job-0", SnapshotID: "snap-0", Kind: libraryrelease.PriorSnapshotSync}}}); err != nil {
t.Fatalf("plan: %v", err)
}
if inner.planned != 1 {
t.Fatalf("预检必须落到内层目标,planned=%d", inner.planned)
}
// 来源证据也必须透传:丢掉它就会让"恢复保留下来的资源"永远无法证明可复用。
if len(inner.last.PriorSnapshots) != 1 || inner.last.PriorSnapshots[0].SnapshotID != "snap-0" {
t.Fatalf("PriorSyncs 没有透传到内层:%+v", inner.last)
}
// 内层不支持预检 ⇒ 硬错误,不许"没有台账也照写"。
strict := &contentTrackedTarget{inner: &plainTarget{}, onApply: func() {}}
if _, err := strict.PlanWriteSet(context.Background(), libraryrelease.WriteSetPlan{}); err == nil {
t.Fatal("内层不支持写集合预检时必须报错")
} else if !strings.Contains(err.Error(), "写集合") {
t.Fatalf("错误必须点名写集合:%v", err)
}
}