67743f2285
build / build (push) Successful in 1m27s
fake 版本库不实现 Store 的 1..100 上限,正是它让"限 out of range"一路绿到线上。 这组用例跑真实 PostgreSQL:真实 Run → contentTrackedTarget → 真实 libraryStageRecorder.WriteSetPlanned → 真实 store,断言台账在第一笔写入之前可读、 原备份证据字段与 writeset_digest 原子共存,并把记录推到 250 条更新版本之后 (窗口里已看不到它)仍能按身份取回。 store 级契约用例覆盖:命中、真缺失 found=false、别的作业=冲突、同身份两行=拒绝挑选、 跨 scope/跨 kind 不命中、不完整身份拒绝。变异成"列最近 N 条再筛"时四条全红。 隔离 schema 逻辑收敛到 pgtest 一份,postgres 侧改为委托。
276 lines
12 KiB
Go
276 lines
12 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
|
|
}
|
|
|
|
// LibraryVersionByRef 按 scope+kind+作业+快照四个条件精确命中:
|
|
// 真实 store 已不再提供"列最近 N 条再筛"这条路,夹具也不能假装还能那样查。
|
|
func (f *fakeVersionStore) LibraryVersionByRef(_ context.Context, scope string, kind governance.LibraryVersionKind,
|
|
sourceJobID, snapshotID string) (governance.LibraryVersion, bool, error) {
|
|
if f.err != nil {
|
|
return governance.LibraryVersion{}, false, f.err
|
|
}
|
|
for _, version := range f.versions {
|
|
if version.Scope != "" && version.Scope != scope {
|
|
continue
|
|
}
|
|
if version.Kind == kind && version.SnapshotID == snapshotID && version.SourceJobID == sourceJobID {
|
|
return version, true, nil
|
|
}
|
|
}
|
|
return governance.LibraryVersion{}, false, 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)
|
|
}
|
|
}
|
|
|
|
// 编排路径上的同一个断言:Run 是按 target.(WriteSetPlanner) 决定要不要预检的,
|
|
// 所以包装体必须在**真实调用链里**也把预检带上(只测直接调用内层会漏掉这一层)。
|
|
type orchestratorTarget struct {
|
|
planned int
|
|
applied []libraryrelease.Stage
|
|
}
|
|
|
|
func (t *orchestratorTarget) Current(context.Context) (libraryrelease.CurrentState, error) {
|
|
return libraryrelease.CurrentState{}, nil
|
|
}
|
|
func (t *orchestratorTarget) Apply(_ context.Context, stage libraryrelease.Stage, _ string) error {
|
|
t.applied = append(t.applied, stage)
|
|
return nil
|
|
}
|
|
func (t *orchestratorTarget) Verify(context.Context, libraryrelease.Expectation) error { return nil }
|
|
func (t *orchestratorTarget) Restore(context.Context, libraryrelease.BackupRef) error { return nil }
|
|
func (t *orchestratorTarget) PlanWriteSet(_ context.Context, plan libraryrelease.WriteSetPlan) (libraryrelease.WriteSet, error) {
|
|
t.planned++
|
|
set := libraryrelease.WriteSet{Version: libraryrelease.WriteSetVersion, JobID: plan.JobID, Target: plan.Target,
|
|
TenantID: 10001, KnowledgeBaseID: "kb", BackupSnapshotID: plan.BackupSnapshotID,
|
|
TargetSnapshotID: plan.TargetSnapshotID, CreatedAt: time.Now().UTC(),
|
|
Universe: plan.Universe,
|
|
Rows: []libraryrelease.WriteSetRow{{Table: "resources", ID: "res-1"}}}
|
|
if err := set.Seal(); err != nil {
|
|
return libraryrelease.WriteSet{}, err
|
|
}
|
|
return set, nil
|
|
}
|
|
|
|
type stubBackupStore struct{}
|
|
|
|
func (stubBackupStore) Prepare(context.Context, string, libraryrelease.CurrentState) (libraryrelease.BackupRef, error) {
|
|
return libraryrelease.BackupRef{ID: "backup-1", SnapshotID: "backup-snap",
|
|
Universe: map[string]libraryrelease.TableFingerprint{"resources": {Count: 1, Digest: "abc"}}}, nil
|
|
}
|
|
|
|
func TestRunPlansWriteSetThroughContentTrackedWrapper(t *testing.T) {
|
|
inner := &orchestratorTarget{}
|
|
tracked := &contentTrackedTarget{inner: inner, onApply: func() {}}
|
|
now := time.Now().UTC()
|
|
request := libraryrelease.Request{JobID: "job-1", Target: "internal", SnapshotID: "snap-1",
|
|
ParamsDigest: "digest-1", Now: now,
|
|
Grant: libraryrelease.Grant{Target: "internal", SnapshotID: "snap-1", ParamsDigest: "digest-1",
|
|
ExpiresAt: now.Add(time.Hour), AuthorizedBy: "acceptance"}}
|
|
outcome := libraryrelease.Run(context.Background(), request, tracked, stubBackupStore{}, nil)
|
|
if outcome.State != "succeeded" {
|
|
t.Fatalf("outcome = %+v", outcome)
|
|
}
|
|
if inner.planned != 1 {
|
|
t.Fatalf("编排路径没有经过包装层触发写集合预检,planned=%d", inner.planned)
|
|
}
|
|
if outcome.Backup.WriteSet == nil || outcome.Backup.WriteSet.Digest == "" {
|
|
t.Fatalf("预检结果必须带回给编排层(恢复要按它清理):%+v", outcome.Backup)
|
|
}
|
|
if len(inner.applied) != len(libraryrelease.Stages()) {
|
|
t.Fatalf("四类写入必须都执行,applied=%v", inner.applied)
|
|
}
|
|
}
|