Files
knowledge-governance/internal/releaseadapter/v071/library_target_ids_integration_test.go
T
姚章浩 0d9091e464
build / build (push) Successful in 1m41s
fix(library): 目标隔离映射兼容旧计划与真实回归
空 mode 计划不映射;索引 source_id 按语义映射;relation 按字段表解析。
隔离回归按持久映射 ID 断言,DS02 故障注入真实命中。
2026-11-04 12:40:12 +08:00

172 lines
6.9 KiB
Go

package v071
import (
"context"
"strings"
"testing"
"knowledge-governance/internal/librarysnapshot"
"knowledge-governance/internal/libraryrelease"
)
// 同一隔离实例里已有旧库占用源快照的原始 UUID;目标换成另一个空知识库。
// 必须 Plan→Apply→Verify 成功、旧库逐字节保留,失败路径恢复目标 before-image。
func TestTargetIDMappingPlanApplyVerifyRestoreIsolated(t *testing.T) {
fx := openWriteSetFixture(t)
seedTargetData(t, fx)
ctx := fx.ctx
// 旧库占用与来源快照相同的身份(真实缺陷:原实现按原 ID 写入会撞主键/被归属检查拒绝)。
oldRows := []string{
`INSERT INTO knowledges VALUES('doc-src',10001,'` + wsOtherKB + `','completed',0,'',NULL)`,
`INSERT INTO chunks VALUES('chunk-src',10001,'` + wsOtherKB + `','doc-src','旧库正文',NULL)`,
`INSERT INTO wiki_pages VALUES('wiki-src',10001,'` + wsOtherKB + `','legacy-page','旧库 wiki',NULL,'published')`,
}
for _, statement := range oldRows {
if _, err := fx.pool.Exec(ctx, statement); err != nil {
t.Fatalf("seed old kb: %v\n%s", err, statement)
}
}
before := universeDump(t, fx.pool)
snapshot := sealSourceSnapshot(t, fx, nil)
target := fx.target(t)
backups := fx.backups(t, target)
current, err := target.Current(ctx)
if err != nil {
t.Fatal(err)
}
backup, err := backups.Prepare(ctx, snapshot, current)
if err != nil {
t.Fatal(err)
}
set, err := target.PlanWriteSet(ctx, libraryrelease.WriteSetPlan{JobID: "target-id-map-job", Target: "internal",
BackupSnapshotID: backup.SnapshotID, TargetSnapshotID: snapshot, Universe: backup.Universe})
if err != nil {
t.Fatalf("plan against a database that already owns the source ids: %v", err)
}
for _, row := range set.Rows {
if row.ID == "doc-src" || row.ID == "chunk-src" || row.ID == "wiki-src" {
t.Fatalf("plan still carries source identity %s for %s", row.ID, row.Table)
}
}
for _, stage := range []libraryrelease.Stage{libraryrelease.StageDatabase, libraryrelease.StageWiki,
libraryrelease.StageResources, libraryrelease.StageIndex} {
if err := target.Apply(ctx, stage, snapshot); err != nil {
t.Fatalf("apply %s: %v", stage, err)
}
}
if err := target.Verify(ctx, libraryrelease.Expectation{SnapshotID: snapshot}); err != nil {
t.Fatalf("verify: %v", err)
}
// 旧库原行必须原样存在(内容与 ID 都不变)。
for _, check := range []struct{ query, want string }{
{`SELECT content FROM chunks WHERE id='chunk-src' AND knowledge_base_id='` + wsOtherKB + `'`, "旧库正文"},
{`SELECT content FROM wiki_pages WHERE id='wiki-src' AND knowledge_base_id='` + wsOtherKB + `'`, "旧库 wiki"},
} {
var got string
if err := fx.pool.QueryRow(ctx, check.query).Scan(&got); err != nil || got != check.want {
t.Fatalf("old kb row changed/lost (%s): %q %v", check.query, got, err)
}
}
// 新目标里必须是映射后的身份,不能出现源 UUID。
var sourceIDs int64
if err := fx.pool.QueryRow(ctx, `SELECT count(*) FROM knowledges WHERE tenant_id=$1 AND knowledge_base_id=$2 AND id IN ('doc-src','chunk-src')`,
wsTargetTenant, wsTargetKB).Scan(&sourceIDs); err != nil {
t.Fatal(err)
}
if sourceIDs != 0 {
t.Fatalf("source ids leaked into the new target: %d", sourceIDs)
}
var mapped int64
if err := fx.pool.QueryRow(ctx, `SELECT count(*) FROM knowledges WHERE tenant_id=$1 AND knowledge_base_id=$2 AND id<>'doc-src'`,
wsTargetTenant, wsTargetKB).Scan(&mapped); err != nil {
t.Fatal(err)
}
if mapped == 0 {
t.Fatal("no mapped knowledge row written")
}
// 第二次同步(全新 target 实例、只靠持久计划)不重复、不冲突。
second := fx.target(t)
if err := second.AdoptWriteSet(set); err != nil {
t.Fatalf("adopt persisted plan: %v", err)
}
if err := second.Apply(ctx, libraryrelease.StageDatabase, snapshot); err != nil {
t.Fatalf("second apply: %v", err)
}
var duplicated int64
if err := fx.pool.QueryRow(ctx, `SELECT count(*) FROM chunks WHERE tenant_id=$1 AND knowledge_base_id=$2`,
wsTargetTenant, wsTargetKB).Scan(&duplicated); err != nil {
t.Fatal(err)
}
if duplicated != 1 {
t.Fatalf("repeat sync duplicated target chunks: %d", duplicated)
}
// 失败恢复:按持久写集合回放目标 before-image,旧库不变、残留为 0。
ref := backup
ref.WriteSet = &set
if err := target.Restore(context.WithoutCancel(ctx), ref); err != nil {
t.Fatalf("restore: %v", err)
}
if err := target.Verify(ctx, libraryrelease.Expectation{SnapshotID: backup.SnapshotID}); err != nil {
t.Fatalf("verify restored before-image: %v", err)
}
after := universeDump(t, fx.pool)
if diff := diffUniverse(before, after); diff != "" {
t.Fatalf("restore did not return to before-image: %s", diff)
}
t.Logf("plan rows=%d index=%d objects=%d; old kb preserved; restore exact", len(set.Rows), len(set.Index), len(set.Objects))
}
// 映射后的目标 ID 若真被另一个库占用,仍必须拒绝(不能只取消旧冲突预期)。
func TestTargetIDMappedIdentityCollisionStillRejectedIsolated(t *testing.T) {
fx := openWriteSetFixture(t)
seedTargetData(t, fx)
mapped := expectedTargetID(wsTargetTenant, wsTargetKB, "knowledges", "doc-src")
if _, err := fx.pool.Exec(fx.ctx, `INSERT INTO knowledges VALUES($1,10001,$2,'completed',0,'',NULL)`, mapped, wsOtherKB); err != nil {
t.Fatal(err)
}
snapshot := sealSourceSnapshot(t, fx, nil)
target := fx.target(t)
current, err := target.Current(fx.ctx)
if err != nil {
t.Fatal(err)
}
backup, err := fx.backups(t, target).Prepare(fx.ctx, snapshot, current)
if err != nil {
t.Fatal(err)
}
if _, err := target.PlanWriteSet(fx.ctx, libraryrelease.WriteSetPlan{JobID: "mapped-collision", Target: "internal",
BackupSnapshotID: backup.SnapshotID, TargetSnapshotID: snapshot, Universe: backup.Universe}); err == nil {
t.Fatal("mapped identity occupied by another KB was accepted")
}
}
// 旧空 mode 计划没有映射契约:真实写入路径必须按原 ID 落库并因此与旧库冲突,
// 证明新进程不会给历史计划隐式重映射。
func TestLegacyPlanWithoutModeDoesNotRemapIsolated(t *testing.T) {
fx := openWriteSetFixture(t)
seedTargetData(t, fx)
if _, err := fx.pool.Exec(fx.ctx, `INSERT INTO knowledges VALUES('doc-src',10001,$1,'completed',0,'',NULL)`, wsOtherKB); err != nil {
t.Fatal(err)
}
snapshot := sealSourceSnapshot(t, fx, nil)
target := fx.target(t)
archive, err := librarysnapshot.Open(fx.archiveRoot, 256*1024*1024)
if err != nil {
t.Fatal(err)
}
defer archive.Close()
manifest, err := archive.Load(snapshot)
if err != nil {
t.Fatal(err)
}
target.disableTargetMapping()
if err := target.bindSnapshotScope(manifestScope{tenantID: manifest.TenantID, knowledgeBaseID: manifest.KnowledgeBaseID}); err != nil {
t.Fatal(err)
}
err = target.importRows(context.Background(), archive, manifest, "database")
if err == nil || !strings.Contains(strings.ToLower(err.Error()), "duplicate") && !strings.Contains(err.Error(), "冲突") {
t.Fatalf("legacy path must write original ids and fail on the old-kb collision, got %v", err)
}
}