Files
knowledge-governance/cmd/worker/library_takeover_integration_test.go
T
姚章浩 ba852f3dc2 fix(worker): 接管判据绑作业身份,同快照别作业登记不算完成
2026-10-29T19:16Z 真实现场:作业只写完 database 阶段(resources/index/wiki/verify
仍 pending),worker 被杀、人工拉起后被判 succeeded,阶段写"已登记生效版本(仅收尾,
未重写生产)",并把生效版本归属改写成这个作业。

根因:classifyTakeover 只看"当前生效版本的目标快照是不是我的目标快照"。版本行主键
由 (kind, scope, 快照) 决定(LibraryVersionID),登记是 ON CONFLICT (id) DO UPDATE、
会改写 source_job_id —— 快照相等这一维里没有作业身份。

改法:effectiveOwnedBy(version, jobID, snapshotID) 一份实现,接管与基线共用;
归属别的作业 ⇒ 新的 takeoverForeignEffective,走 failLibraryTakeover:不写目标、
不释放维护、终态失败并指明预备份(目标可能半写,释放等于谎称已恢复)。
本作业自己的 finalize 阶段成功仍是独立证据,不被归属改写推翻。

验证(已跑):
- go test ./cmd/worker -run TestClassifyTakeover → PASS(含 4 条新用例)
- 负例:撤掉身份判定后同两条用例红(classify="pending_final", want "foreign_effective")
- 真实 PG(一次性库 kg_takeover_foreign_test):
  TestTakeoverRefusesSameSnapshotRegisteredByAnotherJob PASS(1.41s),
  负例同一用例红(library_takeover_integration_test.go:53)
- 同一库 TestTakeoverClassificationUsesExactCurrentVersionBeyondHistoryWindow PASS
- make verify:overall success(15 项必需全绿)
2026-10-30 03:40:13 +08:00

164 lines
7.5 KiB
Go

package main
import (
"context"
"fmt"
"testing"
"time"
"knowledge-governance/internal/governance"
)
// 同一个快照被别的作业登记成生效版本时,接管必须拒绝:快照相等不是本作业的完成证据。
//
// 这条只能在真实 PostgreSQL 上证明:版本行 id 由 (kind, scope, 快照) 决定,登记走
// upsert 并会改写 source_job_id,所以"生产上有这个快照、但它不是本作业发的"是存储层
// 才能造出的真实形状。内存夹具只能造出调用方相信的那个版本。
func TestTakeoverRefusesSameSnapshotRegisteredByAnotherJob(t *testing.T) {
store, _ := openLedgerStore(t)
ctx := context.Background()
now := time.Now().UTC()
const scope = "internal"
const shared = "snap-shared-identical"
const otherJob = "libsync-internal-publisher"
const thisJob = "libsync-internal-resumed"
record := func(source string, created time.Time) {
t.Helper()
if err := store.RecordLibraryVersion(ctx, governance.LibraryVersion{
ID: governance.LibraryVersionID(governance.LibraryVersionProductionEffective, scope, shared),
Scope: scope, Kind: governance.LibraryVersionProductionEffective, SnapshotID: shared,
SourceJobID: source, CreatedBy: "worker",
Evidence: map[string]any{"action": "sync", "index_mapping_sha256": "mapping-live"},
CreatedAt: created,
}); err != nil {
t.Fatalf("record effective for %s: %v", source, err)
}
}
record(otherJob, now.Add(-time.Hour))
// 本作业被杀在写入链路的第一阶段:resources/index/wiki/verify 都还没开始。
job := governance.LibraryJob{ID: thisJob, Scope: scope, Kind: governance.LibraryJobSync,
TargetSnapshotID: shared, SnapshotID: "snap-prebackup-shared",
Stages: []governance.LibraryStage{{Stage: "database", State: "running"}}}
facts := loadLibraryVersionFacts(ctx, store, scope, shared)
if facts.Err != nil {
t.Fatalf("read facts: %v", facts.Err)
}
if !facts.HasCurrent || !facts.HasSnapshot || facts.Current.SourceJobID != otherJob {
t.Fatalf("夹具失效:生效登记不属于别的作业:%+v", facts)
}
if got := classifyTakeover(job, facts); got != takeoverForeignEffective {
t.Fatalf("同快照由别的作业登记时的接管分类 = %q, want %q(按同快照收尾 = 假完成)",
got, takeoverForeignEffective)
}
// 本作业自己登记过同一快照(upsert 把归属改写回来)⇒ 只差收尾。
record(thisJob, now)
facts = loadLibraryVersionFacts(ctx, store, scope, shared)
if facts.Err != nil {
t.Fatalf("read facts after own record: %v", facts.Err)
}
if facts.Current.SourceJobID != thisJob {
t.Fatalf("upsert 没有把归属改成本作业:%+v", facts.Current)
}
if got := classifyTakeover(job, facts); got != takeoverPendingFinal {
t.Fatalf("本作业登记的同一快照分类 = %q, want %q", got, takeoverPendingFinal)
}
}
// 接管/基线的版本判定必须走"当前生效版本"的精确查询:历史一长,窗口列表就看不到
// 那唯一一行未顶替的生效版本,于是判定会退回"没有证据"——接管就会把已经生效的
// 目标再写一遍(重写风险最高的一条)。这里用真实 PostgreSQL 把窗口挤满,证明判定不变。
func TestTakeoverClassificationUsesExactCurrentVersionBeyondHistoryWindow(t *testing.T) {
store, _ := openLedgerStore(t)
ctx := context.Background()
now := time.Now().UTC()
const scope = "internal"
const targetSnapshot = "snap-effective"
const jobID = "libsync-internal-takeover"
job := governance.LibraryJob{ID: jobID, Scope: scope, Kind: governance.LibraryJobSync,
TargetSnapshotID: targetSnapshot, SnapshotID: "snap-prebackup"}
recordEffective := func(sourceJob, snapshot string, created time.Time) {
t.Helper()
if err := store.RecordLibraryVersion(ctx, governance.LibraryVersion{
ID: governance.LibraryVersionID(governance.LibraryVersionProductionEffective, scope, snapshot),
Scope: scope, Kind: governance.LibraryVersionProductionEffective, SnapshotID: snapshot,
SourceJobID: sourceJob, CreatedBy: "worker",
Evidence: map[string]any{"action": "sync", "index_mapping_sha256": "mapping-live"},
CreatedAt: created,
}); err != nil {
t.Fatalf("record effective %s: %v", snapshot, err)
}
}
// 生效版本登记在 48 小时前,然后 250 条更新的历史记录把它挤出任何窗口。
recordEffective(jobID, targetSnapshot, now.Add(-48*time.Hour))
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, targetSnapshot) {
t.Fatal("窗口里仍能看到生效版本:本用例证明不了窗口之外仍可判定(夹具失效)")
}
// 本作业的目标快照就是当前生效版本 ⇒ 只差收尾,不许重写。
facts := loadLibraryVersionFacts(ctx, store, scope, targetSnapshot)
if facts.Err != nil {
t.Fatalf("窗口之外必须读得到生效事实:%v", facts.Err)
}
if !facts.HasCurrent || facts.Current.SnapshotID != targetSnapshot {
t.Fatalf("当前生效版本读取错误:%+v", facts)
}
if got := classifyTakeover(job, facts); got != takeoverPendingFinal {
t.Fatalf("取手接管分类 = %q, want %q(窗口一满就重写 = 本缺陷)", got, takeoverPendingFinal)
}
// 索引映射基线也走同一条精确查询:窗口之外仍要拿到生产实际用的映射。
if got := knownIndexMapping(ctx, store, scope); got != "mapping-live" {
t.Fatalf("索引映射基线 = %q, want mapping-live", got)
}
// 本快照被更新的快照顶替:接管必须拒绝用旧快照覆盖,而不是重写。
recordEffective("libsync-internal-newer", "snap-newer", now)
facts = loadLibraryVersionFacts(ctx, store, scope, targetSnapshot)
if facts.Err != nil {
t.Fatalf("顶替后仍必须读得到事实:%v", facts.Err)
}
if got := classifyTakeover(job, facts); got != takeoverSuperseded {
t.Fatalf("被顶替后的接管分类 = %q, want %q", got, takeoverSuperseded)
}
if facts.Current.SnapshotID != "snap-newer" {
t.Fatalf("当前生效版本 = %s, want snap-newer", facts.Current.SnapshotID)
}
// 一个从没生效过的快照:才是 fresh(正常流程 + 预检)。
unknown := governance.LibraryJob{ID: "libsync-internal-fresh", Scope: scope,
Kind: governance.LibraryJobSync, TargetSnapshotID: "snap-never", SnapshotID: "snap-prebackup-2"}
if got := classifyTakeover(unknown, loadLibraryVersionFacts(ctx, store, scope, "snap-never")); got != takeoverFresh {
t.Fatalf("未生效过的快照分类 = %q, want %q", got, takeoverFresh)
}
// 基线侧同一个事实:别人的生效版本必须挡住建基线;本作业登记的同一快照只收尾。
current, hasCurrent, err := store.LibraryCurrentVersion(ctx, scope)
if err != nil || !hasCurrent {
t.Fatalf("当前生效版本读取失败:found=%v err=%v", hasCurrent, err)
}
if state := classifyBaselineVersions(current, hasCurrent, "libbase-internal-x", "snap-newer"); state.Own || state.Foreign == nil {
t.Fatalf("别人的生效版本必须挡住基线:%+v", state)
}
recordEffective("libbase-internal-y", "snap-baseline", now)
current, hasCurrent, err = store.LibraryCurrentVersion(ctx, scope)
if err != nil || !hasCurrent {
t.Fatalf("再读当前生效版本失败:found=%v err=%v", hasCurrent, err)
}
if state := classifyBaselineVersions(current, hasCurrent, "libbase-internal-y", "snap-baseline"); !state.Own {
t.Fatalf("本作业同一快照必须判成只收尾:%+v (%s)", state, fmt.Sprint(current))
}
}