test(library): 真实PG验证超出历史窗口仍能取回写集合
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 侧改为委托。
This commit is contained in:
姚章浩
2026-10-30 02:32:26 +08:00
parent f0bd6fb0d2
commit 67743f2285
6 changed files with 461 additions and 37 deletions
@@ -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)
}
}
}
+14 -3
View File
@@ -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 {
@@ -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)
}
@@ -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)
}
}
}
@@ -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()
}
+5
View File
@@ -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 仍红(超出窗口找不到)、修后绿"
}
]
}