0d9091e464
build / build (push) Successful in 1m41s
空 mode 计划不映射;索引 source_id 按语义映射;relation 按字段表解析。 隔离回归按持久映射 ID 断言,DS02 故障注入真实命中。
172 lines
6.9 KiB
Go
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)
|
|
}
|
|
}
|