diff --git a/cmd/worker/library_writeset_integration_test.go b/cmd/worker/library_writeset_integration_test.go new file mode 100644 index 0000000..3add184 --- /dev/null +++ b/cmd/worker/library_writeset_integration_test.go @@ -0,0 +1,239 @@ +package main + +import ( + "context" + "encoding/json" + "fmt" + "os" + "testing" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "knowledge-governance/internal/governance" + "knowledge-governance/internal/libraryrelease" + postgresstore "knowledge-governance/internal/platform/postgres" + "knowledge-governance/internal/platform/postgres/pgtest" + v071 "knowledge-governance/internal/releaseadapter/v071" +) + +// 这一组用例跑在真实 PostgreSQL 上(TEST_DATABASE_URL),因为要证明的正是 +// 治理库的契约:版本台账的身份查询不许依赖"最近 N 条",而且写集合锚点必须与 +// 预备份原有证据共存。假的版本库不实现 1..100 的分页上限,正是它让真实现场 +// 那个"library version limit out of range"一路绿到线上。 + +// ledgerTestTarget 是"只做预检 + 四个内容阶段"的目标:本用例要证明的是治理库侧的 +// 台账契约,不是 v071 的生产写入;但预检的落盘(PersistWriteSet)是真实的, +// 因为接管/恢复就是按这份文件取回写集合。 +type ledgerTestTarget struct { + root string + plan libraryrelease.WriteSetPlan +} + +func (t *ledgerTestTarget) Current(context.Context) (libraryrelease.CurrentState, error) { + return libraryrelease.CurrentState{Counts: map[string]int64{"resources": 1}, Digests: map[string]string{"resources": "universe-digest"}}, nil +} + +func (t *ledgerTestTarget) Apply(context.Context, libraryrelease.Stage, string) error { return nil } +func (t *ledgerTestTarget) Verify(context.Context, libraryrelease.Expectation) error { return nil } +func (t *ledgerTestTarget) Restore(context.Context, libraryrelease.BackupRef) error { return nil } + +func (t *ledgerTestTarget) PlanWriteSet(_ context.Context, plan libraryrelease.WriteSetPlan) (libraryrelease.WriteSet, error) { + t.plan = plan + set := libraryrelease.WriteSet{Version: libraryrelease.WriteSetVersion, JobID: plan.JobID, Target: plan.Target, + TenantID: 10001, KnowledgeBaseID: "kb-ledger", + BackupSnapshotID: plan.BackupSnapshotID, TargetSnapshotID: plan.TargetSnapshotID, CreatedAt: time.Now().UTC(), + Rows: []libraryrelease.WriteSetRow{{Table: "resources", ID: "res-new"}}, + Universe: plan.Universe} + if err := set.Seal(); err != nil { + return libraryrelease.WriteSet{}, err + } + if _, err := v071.PersistWriteSet(t.root, &set); err != nil { + return libraryrelease.WriteSet{}, err + } + return set, nil +} + +// ledgerTestBackups 返回一份已经拍好的预备份(模拟"真实备份已完成"), +// WriteSet 留空:台账必须由真实预检算出来,不能由夹具直接塞进去。 +type ledgerTestBackups struct { + ref libraryrelease.BackupRef +} + +func (b ledgerTestBackups) Prepare(context.Context, string, libraryrelease.CurrentState) (libraryrelease.BackupRef, error) { + return b.ref, nil +} + +func openLedgerStore(t *testing.T) (*postgresstore.Store, *pgxpool.Pool) { + t.Helper() + databaseURL := pgtest.IsolatedDatabaseURL(t, os.Getenv("TEST_DATABASE_URL")) + if databaseURL == "" { + t.Skip("TEST_DATABASE_URL is not set") + } + ctx := context.Background() + pool, err := pgxpool.New(ctx, databaseURL) + if err != nil { + t.Fatalf("connect: %v", err) + } + t.Cleanup(pool.Close) + if err := postgresstore.ApplyMigrations(ctx, pool); err != nil { + t.Fatalf("migrate: %v", err) + } + return postgresstore.NewStore(pool), pool +} + +// seedVersionHistory 往同一 scope 里塞满比目标更新版本的历史记录: +// 目标记录被顶到任何"最近 N 条"窗口之外,只有按身份精确查询才能取回。 +func seedVersionHistory(t *testing.T, ctx context.Context, store *postgresstore.Store, scope string, now time.Time, count int) { + t.Helper() + for i := 0; i < count; i++ { + snapshot := fmt.Sprintf("history-snap-%03d", i) + if err := store.RecordLibraryVersion(ctx, governance.LibraryVersion{ + ID: governance.LibraryVersionID(governance.LibraryVersionProductionPrebackup, scope, snapshot), + Scope: scope, Kind: governance.LibraryVersionProductionPrebackup, SnapshotID: snapshot, + SourceJobID: fmt.Sprintf("history-job-%03d", i), CreatedBy: "worker", + Evidence: map[string]any{"backup_snapshot": snapshot, "backup_bytes": 1024}, + CreatedAt: now.Add(-time.Duration(i) * time.Minute), + }); err != nil { + t.Fatalf("seed history version %d: %v", i, err) + } + } +} + +func containsSnapshot(versions []governance.LibraryVersion, snapshotID string) bool { + for _, version := range versions { + if version.SnapshotID == snapshotID { + return true + } + } + return false +} + +// TestLibraryRunAnchorsWriteSetAndKeepsLookingItUpBeyondHistoryWindow 是本问题的 +// 端到端证据:真实 Run → contentTrackedTarget 包装 → 真实 libraryStageRecorder +// .WriteSetPlanned → 真实 store,并且历史长到把这条记录挤出"最近 N 条"窗口后, +// 登记/接管/恢复共用的精确查询仍然取得到它。 +func TestLibraryRunAnchorsWriteSetAndKeepsLookingItUpBeyondHistoryWindow(t *testing.T) { + store, pool := openLedgerStore(t) + ctx := context.Background() + now := time.Now().UTC() + const ( + scope = "internal" + jobID = "libsync-ledger-200" + snapshot = "backup-snap-ledger-200" + target = "target-snap-ledger-200" + params = "params-digest-ledger-200" + ) + if _, _, err := store.CreateLibraryJob(ctx, governance.LibraryJob{ID: jobID, Scope: scope, Kind: governance.LibraryJobSync, + IdempotencyKey: "library.sync:internal:ledger-200", RequestDigest: params, Actor: "admin"}, + governance.SyncStages(), now); err != nil { + t.Fatalf("create library job: %v", err) + } + + root := t.TempDir() + inner := &ledgerTestTarget{root: root} + // 台账必须在第一笔写入之前就能按身份读回:图省事把登记挪到写之后, + // 崩溃时就没有"这次明确写了什么"可读。 + anchorBeforeFirstWrite, checkedFirstWrite := false, false + wrapped := &contentTrackedTarget{inner: inner, onApply: func() { + if checkedFirstWrite { + return + } + checkedFirstWrite = true + if _, err := writeSetDigestOf(ctx, store, scope, jobID, snapshot); err == nil { + anchorBeforeFirstWrite = true + } + }} + recorder := libraryStageRecorder{store: store, jobID: jobID, scope: scope, mappingDigest: "mapping-live"} + outcome := libraryrelease.Run(ctx, libraryrelease.Request{JobID: jobID, Target: scope, SnapshotID: target, + ParamsDigest: params, Now: now, Grant: libraryrelease.Grant{Target: scope, SnapshotID: target, + ParamsDigest: params, ExpiresAt: now.Add(time.Hour), AuthorizedBy: "tester"}}, + wrapped, ledgerTestBackups{ref: libraryrelease.BackupRef{ID: "backup-" + snapshot, SnapshotID: snapshot, + Bytes: 4096, Universe: map[string]libraryrelease.TableFingerprint{"resources": {Count: 1, Digest: "universe-digest"}}}}, + recorder) + if outcome.State != "succeeded" { + t.Fatalf("台账登记不应让作业失败:state=%s error=%s", outcome.State, outcome.Error) + } + if inner.plan.JobID != jobID || inner.plan.BackupSnapshotID != snapshot { + t.Fatalf("包装层没有把预检落到内层目标:%+v", inner.plan) + } + + // 登记必须发生在写第一笔之前。 + if !anchorBeforeFirstWrite { + t.Fatal("第一笔写入时台账还读不回来:写集合登记没有发生在其之前") + } + + digest, err := writeSetDigestOf(ctx, store, scope, jobID, snapshot) + if err != nil { + t.Fatalf("按作业+预备份取写集合摘要:%v", err) + } + if digest == "" { + t.Fatal("写集合摘要为空:登记没有落到版本证据里") + } + + // 原证据字段必须与锚点共存(原子保留):整份替换会丢掉备份字节与索引映射, + // 而页面与恢复都在用它们。 + set, err := loadWriteSetForJob(ctx, store, root, scope, jobID, snapshot) + if err != nil { + t.Fatalf("按作业+目标+预备份取回写集合:%v", err) + } + if set.Digest != digest { + t.Fatalf("取回的写集合摘要 = %s, want %s", set.Digest, digest) + } + + var evidence []byte + if err := pool.QueryRow(ctx, `SELECT evidence FROM library_versions WHERE scope=$1 AND kind='production_prebackup' +AND source_job_id=$2 AND snapshot_id=$3`, scope, jobID, snapshot).Scan(&evidence); err != nil { + t.Fatalf("read evidence: %v", err) + } + assertEvidenceKeepsBackupFields(t, evidence, map[string]any{ + "backup_bytes": float64(4096), "job": jobID, "index_mapping_sha256": "mapping-live", "writeset_digest": digest, + }) + + // 历史继续增长:把这条预备份记录推到 250 条更新记录之后,任何"最近 N 条" + // (真实 Store 上限 100)的窗口都看不到它——这正是现场"读不到现有版本证据"。 + if _, err := pool.Exec(ctx, `UPDATE library_versions SET created_at=$2 +WHERE scope=$1 AND kind='production_prebackup' AND source_job_id=$3 AND snapshot_id=$4`, + scope, now.Add(-48*time.Hour), jobID, snapshot); err != nil { + t.Fatalf("age prebackup version: %v", err) + } + seedVersionHistory(t, ctx, store, scope, now.Add(-time.Hour), 250) + + window, err := store.LibraryVersions(ctx, scope, 100) + if err != nil { + t.Fatalf("list versions: %v", err) + } + if len(window) != 100 { + t.Fatalf("窗口条数 = %d, want 100", len(window)) + } + if containsSnapshot(window, snapshot) { + t.Fatal("窗口里仍能看到目标记录:本用例无法证明精确查找(夹具失效)") + } + again, err := writeSetDigestOf(ctx, store, scope, jobID, snapshot) + if err != nil { + t.Fatalf("历史超过窗口后仍必须按身份取回摘要:%v", err) + } + if again != digest { + t.Fatalf("超出窗口后取回的摘要 = %s, want %s", again, digest) + } + if _, err := loadWriteSetForJob(ctx, store, root, scope, jobID, snapshot); err != nil { + t.Fatalf("历史超过窗口后接管/恢复仍必须取回写集合:%v", err) + } +} + +func assertEvidenceKeepsBackupFields(t *testing.T, raw []byte, want map[string]any) { + t.Helper() + var evidence map[string]any + if err := json.Unmarshal(raw, &evidence); err != nil { + t.Fatalf("decode evidence: %v", err) + } + for key, value := range want { + got, ok := evidence[key] + if !ok { + t.Fatalf("证据字段 %s 丢失:%v", key, evidence) + } + if fmt.Sprint(got) != fmt.Sprint(value) { + t.Fatalf("证据字段 %s = %v, want %v", key, got, value) + } + } +} diff --git a/cmd/worker/library_writeset_test.go b/cmd/worker/library_writeset_test.go index dac7bff..4136f6e 100644 --- a/cmd/worker/library_writeset_test.go +++ b/cmd/worker/library_writeset_test.go @@ -24,11 +24,22 @@ type fakeVersionStore struct { err error } -func (f *fakeVersionStore) LibraryVersions(context.Context, string, int) ([]governance.LibraryVersion, 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 nil, f.err + return governance.LibraryVersion{}, false, f.err } - return f.versions, nil + 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 { diff --git a/internal/platform/postgres/integration_isolation_test.go b/internal/platform/postgres/integration_isolation_test.go index 8886991..170af79 100644 --- a/internal/platform/postgres/integration_isolation_test.go +++ b/internal/platform/postgres/integration_isolation_test.go @@ -1,44 +1,14 @@ package postgres import ( - "context" - "crypto/sha256" - "encoding/hex" - "net/url" "testing" - "github.com/jackc/pgx/v5/pgxpool" + "knowledge-governance/internal/platform/postgres/pgtest" ) +// 隔离 schema 的实现只留一份(pgtest):postgres 与 cmd/worker 的集成用例 +// 都要连真库,复制一份到两边,迟早只改一边。 func isolatedIntegrationDatabaseURL(t *testing.T, databaseURL string) string { t.Helper() - if databaseURL == "" { - return "" - } - parsed, err := url.Parse(databaseURL) - if err != nil || parsed.Scheme == "" || parsed.Host == "" { - t.Fatalf("TEST_DATABASE_URL must be a PostgreSQL URL: %v", err) - } - digest := sha256.Sum256([]byte(t.Name())) - schema := "kgtest_" + hex.EncodeToString(digest[:8]) - ctx := context.Background() - admin, err := pgxpool.New(ctx, databaseURL) - if err != nil { - t.Fatalf("connect integration database: %v", err) - } - defer admin.Close() - if _, err := admin.Exec(ctx, "CREATE SCHEMA "+schema); err != nil { - t.Fatalf("create isolated integration schema: %v", err) - } - t.Cleanup(func() { - cleanup, err := pgxpool.New(context.Background(), databaseURL) - if err == nil { - _, _ = cleanup.Exec(context.Background(), "DROP SCHEMA IF EXISTS "+schema+" CASCADE") - cleanup.Close() - } - }) - query := parsed.Query() - query.Set("search_path", schema) - parsed.RawQuery = query.Encode() - return parsed.String() + return pgtest.IsolatedDatabaseURL(t, databaseURL) } diff --git a/internal/platform/postgres/library_version_lookup_integration_test.go b/internal/platform/postgres/library_version_lookup_integration_test.go new file mode 100644 index 0000000..c3cdb1e --- /dev/null +++ b/internal/platform/postgres/library_version_lookup_integration_test.go @@ -0,0 +1,149 @@ +package postgres + +import ( + "context" + "fmt" + "os" + "strings" + "testing" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "knowledge-governance/internal/governance" + "knowledge-governance/internal/platform/postgres/pgtest" +) + +// 版本台账的身份查询必须按 (scope, kind, 作业, 快照) 精确命中: +// 缺 → found=false(调用方失败),冲突 → 错误(调用方拒绝), +// 而不是"读最近 N 条再筛"——历史超过窗口就会把存在读成不存在。 +// 这里跑真实 PostgreSQL,因为契约的一半是 Store 的分页上限与 SQL 条件本身。 + +func openVersionStore(t *testing.T) (*Store, *pgxpool.Pool) { + t.Helper() + databaseURL := pgtest.IsolatedDatabaseURL(t, os.Getenv("TEST_DATABASE_URL")) + if databaseURL == "" { + t.Skip("TEST_DATABASE_URL is not set") + } + ctx := context.Background() + pool, err := pgxpool.New(ctx, databaseURL) + if err != nil { + t.Fatalf("connect: %v", err) + } + t.Cleanup(pool.Close) + if err := ApplyMigrations(ctx, pool); err != nil { + t.Fatalf("migrate: %v", err) + } + return NewStore(pool), pool +} + +func recordPrebackup(t *testing.T, ctx context.Context, store *Store, scope, jobID, snapshot string, created time.Time) { + t.Helper() + if err := store.RecordLibraryVersion(ctx, governance.LibraryVersion{ + ID: governance.LibraryVersionID(governance.LibraryVersionProductionPrebackup, scope, snapshot), + Scope: scope, Kind: governance.LibraryVersionProductionPrebackup, SnapshotID: snapshot, + SourceJobID: jobID, CreatedBy: "worker", + Evidence: map[string]any{"backup_snapshot": snapshot, "backup_bytes": 4096, "job": jobID}, + CreatedAt: created, + }); err != nil { + t.Fatalf("record prebackup %s: %v", snapshot, err) + } +} + +func TestLibraryVersionByRefSeparatesMissingFromConflict(t *testing.T) { + store, _ := openVersionStore(t) + ctx := context.Background() + now := time.Now().UTC() + recordPrebackup(t, ctx, store, "internal", "job-a", "snap-1", now) + + version, found, err := store.LibraryVersionByRef(ctx, "internal", governance.LibraryVersionProductionPrebackup, "job-a", "snap-1") + if err != nil || !found { + t.Fatalf("本作业的记录必须命中:found=%v err=%v", found, err) + } + if version.Evidence["backup_bytes"] != float64(4096) { + t.Fatalf("命中的记录必须带着原有证据:%v", version.Evidence) + } + + // 同一个快照的台账归别的作业所有:这是冲突,必须报错,不能当成"没有记录"。 + if _, found, err := store.LibraryVersionByRef(ctx, "internal", governance.LibraryVersionProductionPrebackup, "job-b", "snap-1"); err == nil || found { + t.Fatalf("作业不一致时必须报冲突:found=%v err=%v", found, err) + } else if !strings.Contains(err.Error(), "属于作业 job-a") { + t.Fatalf("冲突错误要指明归属,实际:%v", err) + } + + // 真的没有这条记录:found=false 且无错误(调用方据此失败,可重试造记录)。 + if _, found, err := store.LibraryVersionByRef(ctx, "internal", governance.LibraryVersionProductionPrebackup, "job-a", "snap-missing"); err != nil || found { + t.Fatalf("缺失必须是 found=false 且无错误:found=%v err=%v", found, err) + } + // 目标范围隔离:另一个 scope 的同名快照不算命中。 + if _, found, err := store.LibraryVersionByRef(ctx, "external", governance.LibraryVersionProductionPrebackup, "job-a", "snap-1"); err != nil || found { + t.Fatalf("跨 scope 不许命中:found=%v err=%v", found, err) + } + // 同快照但别的类型(例如生效版本)也不算命中。 + if _, found, err := store.LibraryVersionByRef(ctx, "internal", governance.LibraryVersionProductionEffective, "job-a", "snap-1"); err != nil || found { + t.Fatalf("跨 kind 不许命中:found=%v err=%v", found, err) + } +} + +func TestLibraryVersionByRefRejectsAmbiguousIdentity(t *testing.T) { + store, pool := openVersionStore(t) + ctx := context.Background() + now := time.Now().UTC() + recordPrebackup(t, ctx, store, "internal", "job-a", "snap-dup", now) + // 台账被写坏(同 scope+kind+snapshot 两行、不同 id):身份不再唯一。 + if _, err := pool.Exec(ctx, ` +INSERT INTO library_versions (id, scope, kind, snapshot_id, source_job_id, evidence, created_by, created_at) +VALUES ('libver-dup-fixture','internal','production_prebackup','snap-dup','job-a','{}'::jsonb,'worker',$1)`, now); err != nil { + t.Fatalf("insert duplicate row: %v", err) + } + if _, found, err := store.LibraryVersionByRef(ctx, "internal", governance.LibraryVersionProductionPrebackup, "job-a", "snap-dup"); err == nil || found { + t.Fatalf("身份不唯一时必须拒绝:found=%v err=%v", found, err) + } else if !strings.Contains(err.Error(), "拒绝挑选") { + t.Fatalf("错误要说清是重复身份,实际:%v", err) + } +} + +func TestLibraryVersionByRefFindsRowOutsideHistoryWindow(t *testing.T) { + store, _ := openVersionStore(t) + ctx := context.Background() + now := time.Now().UTC() + // 目标记录最老:任何"最近 N 条"(真实上限 100)都看不到它。 + recordPrebackup(t, ctx, store, "internal", "job-old", "snap-old", now.Add(-48*time.Hour)) + for i := 0; i < 150; i++ { + recordPrebackup(t, ctx, store, "internal", fmt.Sprintf("job-new-%03d", i), fmt.Sprintf("snap-new-%03d", i), + now.Add(-time.Duration(i)*time.Minute)) + } + window, err := store.LibraryVersions(ctx, "internal", 100) + if err != nil { + t.Fatalf("list versions: %v", err) + } + for _, item := range window { + if item.SnapshotID == "snap-old" { + t.Fatal("窗口里仍能看到目标记录:本用例证明不了窗口之外仍可精确取回(夹具失效)") + } + } + version, found, err := store.LibraryVersionByRef(ctx, "internal", governance.LibraryVersionProductionPrebackup, "job-old", "snap-old") + if err != nil || !found { + t.Fatalf("窗口之外也必须精确命中:found=%v err=%v", found, err) + } + if version.SourceJobID != "job-old" || version.SnapshotID != "snap-old" { + t.Fatalf("命中的不是目标记录:%+v", version) + } +} + +// 空身份不许被当成"查所有":少一个字段就等于换了一种查询,必须直接拒绝。 +func TestLibraryVersionByRefRejectsIncompleteRef(t *testing.T) { + store, _ := openVersionStore(t) + ctx := context.Background() + cases := []struct{ scope, job, snapshot string }{ + {"", "job-a", "snap-1"}, + {"internal", "", "snap-1"}, + {"internal", "job-a", ""}, + } + for _, item := range cases { + if _, found, err := store.LibraryVersionByRef(ctx, item.scope, + governance.LibraryVersionProductionPrebackup, item.job, item.snapshot); err == nil || found { + t.Fatalf("不完整身份必须拒绝:%+v found=%v err=%v", item, found, err) + } + } +} diff --git a/internal/platform/postgres/pgtest/isolated.go b/internal/platform/postgres/pgtest/isolated.go new file mode 100644 index 0000000..dcd9a37 --- /dev/null +++ b/internal/platform/postgres/pgtest/isolated.go @@ -0,0 +1,50 @@ +// Package pgtest 给真实 PostgreSQL 集成用例提供"一个用例一个 schema"的隔离入口。 +// +// 为什么要单独成包:postgres 与 cmd/worker 的集成用例都要连真库,隔离逻辑只该有一份; +// 复制一份到另一个包里,迟早只改一边(AGENTS.md 硬约束 1:同一含义的代码只准有一份)。 +package pgtest + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "net/url" + "testing" + + "github.com/jackc/pgx/v5/pgxpool" +) + +// IsolatedDatabaseURL 为当前用例建一个独立 schema 并返回指向它的连接串; +// 用例结束自动 DROP。基地址为空时返回空串(调用方据此 Skip)。 +func IsolatedDatabaseURL(t *testing.T, databaseURL string) string { + t.Helper() + if databaseURL == "" { + return "" + } + parsed, err := url.Parse(databaseURL) + if err != nil || parsed.Scheme == "" || parsed.Host == "" { + t.Fatalf("TEST_DATABASE_URL must be a PostgreSQL URL: %v", err) + } + digest := sha256.Sum256([]byte(t.Name())) + schema := "kgtest_" + hex.EncodeToString(digest[:8]) + ctx := context.Background() + admin, err := pgxpool.New(ctx, databaseURL) + if err != nil { + t.Fatalf("connect integration database: %v", err) + } + defer admin.Close() + if _, err := admin.Exec(ctx, "CREATE SCHEMA "+schema); err != nil { + t.Fatalf("create isolated integration schema: %v", err) + } + t.Cleanup(func() { + cleanup, err := pgxpool.New(context.Background(), databaseURL) + if err == nil { + _, _ = cleanup.Exec(context.Background(), "DROP SCHEMA IF EXISTS "+schema+" CASCADE") + cleanup.Close() + } + }) + query := parsed.Query() + query.Set("search_path", schema) + parsed.RawQuery = query.Encode() + return parsed.String() +} diff --git a/scripts/test-scope.json b/scripts/test-scope.json index bb386fc..465ff92 100644 --- a/scripts/test-scope.json +++ b/scripts/test-scope.json @@ -222,6 +222,11 @@ "package": "knowledge-governance/internal/releaseadapter/v071", "test": "TestWriteSetKillHelper", "reason": "上面 SIGKILL 用例的子进程 fixture,单独运行没有意义;默认 CI 跳过" + }, + { + "package": "knowledge-governance/cmd/worker", + "test": "TestLibraryRunAnchorsWriteSetAndKeepsLookingItUpBeyondHistoryWindow", + "reason": "必须在真实 PostgreSQL(TEST_DATABASE_URL 指向可销毁测试库)上跑:要证明的正是 Store 的『版本列表 1..100 上限』与按身份精确查询的差别,假版本库不实现该上限(本轮缺陷就是这样一路绿的);默认 CI 无库 ⇒ 跳过,本机一次性 PG 已实跑:原码红(library version limit out of range)、只改 200→100 仍红(超出窗口找不到)、修后绿" } ] }