Files
knowledge-governance/internal/libraryrelease/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

167 lines
5.3 KiB
Go

package libraryrelease
import (
"encoding/json"
"strings"
"testing"
"time"
)
func sampleWriteSet() WriteSet {
return WriteSet{Version: WriteSetVersion, JobID: "job-1", Target: "internal", TenantID: 10001,
KnowledgeBaseID: "kb", BackupSnapshotID: "backup-1", TargetSnapshotID: "snap-1",
CreatedAt: time.Date(2026, 10, 29, 12, 0, 0, 0, time.UTC),
Rows: []WriteSetRow{
{Table: "resources", ID: "res-new"},
{Table: "knowledges", ID: "doc-existing", Existing: true, Owner: "10001/kb"},
{Table: "resources", ID: "res-old", Existing: true, Owner: "10001/"},
},
Universe: map[string]TableFingerprint{"resources": {Count: 2, Digest: "abc"}}}
}
func TestWriteSetSealVerifyRoundTrip(t *testing.T) {
set := sampleWriteSet()
if err := set.Seal(); err != nil {
t.Fatal(err)
}
if set.Digest == "" {
t.Fatal("seal must produce a digest")
}
if err := set.Verify(); err != nil {
t.Fatalf("sealed record must verify: %v", err)
}
// 行序不影响摘要:换序后重新 Sealed 必须得到同一个值(落盘/读回才可比)。
shuffled := sampleWriteSet()
shuffled.Rows[0], shuffled.Rows[2] = shuffled.Rows[2], shuffled.Rows[0]
if err := shuffled.Seal(); err != nil {
t.Fatal(err)
}
if shuffled.Digest != set.Digest {
t.Fatalf("digest must not depend on row order: %s vs %s", shuffled.Digest, set.Digest)
}
// 序列化往返(落盘再读回)必须仍然通过校验。
raw, err := json.Marshal(shuffled)
if err != nil {
t.Fatal(err)
}
var reloaded WriteSet
if err := json.Unmarshal(raw, &reloaded); err != nil {
t.Fatal(err)
}
if err := reloaded.Verify(); err != nil {
t.Fatalf("record read back from disk must verify: %v", err)
}
}
func TestWriteSetVerifyRejectsTamperingAndMissingEvidence(t *testing.T) {
cases := map[string]func(*WriteSet){
"内容被改": func(set *WriteSet) {
set.Rows[0].ID = "res-other"
},
"换租户": func(set *WriteSet) {
set.TenantID = 20000
},
"整实例证据被清空": func(set *WriteSet) {
set.Universe = nil
},
"缺预备份绑定": func(set *WriteSet) {
set.BackupSnapshotID = ""
},
"缺摘要": func(set *WriteSet) {
set.Digest = ""
},
"版本不认识": func(set *WriteSet) {
set.Version = 99
},
}
for name, mutate := range cases {
set := sampleWriteSet()
if err := set.Seal(); err != nil {
t.Fatal(err)
}
mutate(&set)
if err := set.Verify(); err == nil {
t.Fatalf("%s:必须校验失败", name)
}
}
}
func TestWriteSetCreatedIDsOnlyCoversRowsCreatedByThisRelease(t *testing.T) {
set := sampleWriteSet()
if err := set.Seal(); err != nil {
t.Fatal(err)
}
created := set.CreatedIDs("resources")
if len(created) != 1 || created[0] != "res-new" {
t.Fatalf("created resources = %v, want [res-new](写前已存在的资源绝不能被当成残渣)", created)
}
if strings.Join(set.ExistingIDs("resources"), ",") != "res-old" {
t.Fatalf("existing resources = %v", set.ExistingIDs("resources"))
}
if set.UniverseDigest() == "" {
t.Fatal("universe digest must be derived from the whole-instance evidence")
}
}
// 复用行是"写前已存在 + 有证据摘要"的一种:既不算本次新建(恢复不许删),
// 也不能没有证据摘要,更不能被标成新建。
func TestWriteSetReusedRowsStayOutOfCleanupAndRequireEvidence(t *testing.T) {
set := WriteSet{Version: WriteSetVersion, JobID: "job-2", Target: "internal", TenantID: 10001,
KnowledgeBaseID: "kb", BackupSnapshotID: "backup-2", TargetSnapshotID: "snap-2",
CreatedAt: time.Date(2026, 10, 30, 1, 0, 0, 0, time.UTC),
Rows: []WriteSetRow{
{Table: "resources", ID: "res-reused", Existing: true, Owner: "10001/", Reused: true, ReuseEvidence: "digest-1"},
{Table: "resources", ID: "res-new"},
},
Universe: map[string]TableFingerprint{"resources": {Count: 3, Digest: "abc"}}}
if err := set.Seal(); err != nil {
t.Fatal(err)
}
if err := set.Verify(); err != nil {
t.Fatalf("复用行必须能通过校验: %v", err)
}
if created := set.CreatedIDs("resources"); len(created) != 1 || created[0] != "res-new" {
t.Fatalf("复用行被当成本次新建(恢复会删掉它):%v", created)
}
if reused := set.ReusedIDs("resources"); len(reused) != 1 || reused[0] != "res-reused" {
t.Fatalf("reused resources = %v", reused)
}
noEvidence := set
noEvidence.Rows = append([]WriteSetRow{}, set.Rows...)
for index := range noEvidence.Rows {
if noEvidence.Rows[index].ID == "res-reused" {
noEvidence.Rows[index].ReuseEvidence = ""
}
}
if err := noEvidence.Seal(); err != nil {
t.Fatal(err)
}
if err := noEvidence.Verify(); err == nil {
t.Fatal("复用行没有证据摘要时必须校验失败")
}
notExisting := set
notExisting.Rows = append([]WriteSetRow{}, set.Rows...)
for index := range notExisting.Rows {
if notExisting.Rows[index].ID == "res-reused" {
notExisting.Rows[index].Existing = false
}
}
if err := notExisting.Seal(); err != nil {
t.Fatal(err)
}
if err := notExisting.Verify(); err == nil {
t.Fatal("复用行必须同时是写前已存在行(否则会被恢复当残渣)")
}
// 旧记录(没有复用字段)仍然必须能读回:格式演进不能把历史台账判成损坏。
legacy := sampleWriteSet()
if err := legacy.Seal(); err != nil {
t.Fatal(err)
}
if err := legacy.Verify(); err != nil {
t.Fatalf("历史写集合记录必须继续有效: %v", err)
}
}