0d9091e464
build / build (push) Successful in 1m41s
空 mode 计划不映射;索引 source_id 按语义映射;relation 按字段表解析。 隔离回归按持久映射 ID 断言,DS02 故障注入真实命中。
264 lines
10 KiB
Go
264 lines
10 KiB
Go
package v071
|
||
|
||
import (
|
||
"encoding/json"
|
||
"strings"
|
||
"testing"
|
||
|
||
"knowledge-governance/internal/libraryrelease"
|
||
)
|
||
|
||
// 目标隔离映射的行为契约:同源对象在不同目标 KB 必须得到不同 ID;同一目标
|
||
// 跨作业/跨版本稳定;引用字段与身份字段一起换,正文不得被改。
|
||
func TestTargetIDMapperIsScopedAndStable(t *testing.T) {
|
||
a := newTargetIDMapper(10000, "kb-a", nil)
|
||
b := newTargetIDMapper(10000, "kb-b", nil)
|
||
first := a.mapID("chunks", "0d25c09c-5af7-4cee-8b6e-a0b129caeb63")
|
||
if first == "0d25c09c-5af7-4cee-8b6e-a0b129caeb63" {
|
||
t.Fatalf("mapping returned the source id unchanged")
|
||
}
|
||
if len(first) != 36 || strings.Count(first, "-") != 4 {
|
||
t.Fatalf("mapped id is not uuid-shaped: %q", first)
|
||
}
|
||
if again := a.mapID("chunks", "0d25c09c-5af7-4cee-8b6e-a0b129caeb63"); again != first {
|
||
t.Fatalf("mapping is not deterministic: %q != %q", first, again)
|
||
}
|
||
if other := b.mapID("chunks", "0d25c09c-5af7-4cee-8b6e-a0b129caeb63"); other == first {
|
||
t.Fatalf("different target KB produced the same id")
|
||
}
|
||
if cross := a.mapID("wiki_pages", "0d25c09c-5af7-4cee-8b6e-a0b129caeb63"); cross == first {
|
||
t.Fatalf("different tables collided on one id")
|
||
}
|
||
}
|
||
|
||
func rawTargetRow(t *testing.T, v any) map[string]json.RawMessage {
|
||
t.Helper()
|
||
encoded, err := json.Marshal(v)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
var row map[string]json.RawMessage
|
||
if err := json.Unmarshal(encoded, &row); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
return row
|
||
}
|
||
|
||
func TestTargetIDMapperRewritesChunkReferences(t *testing.T) {
|
||
m := newTargetIDMapper(10000, "kb-a", nil)
|
||
chunk := "11111111-1111-4111-8111-111111111111"
|
||
m.registerSourceID("chunks", chunk)
|
||
know := "22222222-2222-4222-8222-222222222222"
|
||
m.registerSourceID("knowledges", know)
|
||
parent := "33333333-3333-4333-8333-333333333333"
|
||
m.registerSourceID("chunks", parent)
|
||
row := rawTargetRow(t, map[string]any{
|
||
"id": chunk, "knowledge_id": know, "parent_chunk_id": parent,
|
||
"pre_chunk_id": parent, "next_chunk_id": parent,
|
||
"relation_chunks": []string{parent},
|
||
"indirect_relation_chunks": []any{map[string]any{"id": parent}},
|
||
"metadata": map[string]any{"source_chunk": parent},
|
||
"content": "正文里出现 " + parent + " 也不能被改",
|
||
})
|
||
if err := m.remapRow("chunks", row); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if got := jsonString(t, row["id"]); got != m.mapID("chunks", chunk) {
|
||
t.Fatalf("chunk id not remapped: %s", got)
|
||
}
|
||
if got := jsonString(t, row["knowledge_id"]); got != m.mapID("knowledges", know) {
|
||
t.Fatalf("knowledge_id not remapped: %s", got)
|
||
}
|
||
if got := jsonString(t, row["parent_chunk_id"]); got != m.mapID("chunks", parent) {
|
||
t.Fatalf("parent_chunk_id not remapped: %s", got)
|
||
}
|
||
var content string
|
||
_ = json.Unmarshal(row["content"], &content)
|
||
if content != "正文里出现 "+parent+" 也不能被改" {
|
||
t.Fatalf("content was rewritten: %q", content)
|
||
}
|
||
var rel []string
|
||
_ = json.Unmarshal(row["relation_chunks"], &rel)
|
||
if rel[0] != m.mapID("chunks", parent) {
|
||
t.Fatalf("relation_chunks not remapped: %v", rel)
|
||
}
|
||
var meta map[string]any
|
||
_ = json.Unmarshal(row["metadata"], &meta)
|
||
if meta["source_chunk"] != parent {
|
||
t.Fatalf("non-reference metadata payload must stay byte-identical: %v", meta)
|
||
}
|
||
}
|
||
|
||
func TestTargetIDMapperRewritesWikiRefsPreservingShape(t *testing.T) {
|
||
m := newTargetIDMapper(10000, "kb-a", nil)
|
||
c1 := "44444444-4444-4444-8444-444444444444"
|
||
m.registerSourceID("chunks", c1)
|
||
c2 := "55555555-5555-4555-8555-555555555555"
|
||
m.registerSourceID("chunks", c2)
|
||
k := "66666666-6666-4666-8666-666666666666"
|
||
m.registerSourceID("knowledges", k)
|
||
m.registerSourceID("wiki_pages", "77777777-7777-4777-8777-777777777777")
|
||
m.registerSourceID("wiki_folders", "88888888-8888-4888-8888-888888888888")
|
||
row := rawTargetRow(t, map[string]any{
|
||
"id": "77777777-7777-4777-8777-777777777777", "folder_id": "88888888-8888-4888-8888-888888888888",
|
||
"chunk_refs": []string{c1, c1, c2},
|
||
"source_refs": []string{k + "|文档", k},
|
||
"content": "body", "title": "t",
|
||
})
|
||
if err := m.remapRow("wiki_pages", row); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
var refs []string
|
||
_ = json.Unmarshal(row["chunk_refs"], &refs)
|
||
if len(refs) != 3 || refs[0] != m.mapID("chunks", c1) || refs[1] != refs[0] || refs[2] != m.mapID("chunks", c2) {
|
||
t.Fatalf("chunk_refs shape/order/dupes not preserved: %v", refs)
|
||
}
|
||
var src []string
|
||
_ = json.Unmarshal(row["source_refs"], &src)
|
||
if src[0] != m.mapID("knowledges", k)+"|文档" || src[1] != m.mapID("knowledges", k) {
|
||
t.Fatalf("source_refs not remapped: %v", src)
|
||
}
|
||
var content string
|
||
_ = json.Unmarshal(row["content"], &content)
|
||
if content != "body" {
|
||
t.Fatal("wiki body changed")
|
||
}
|
||
}
|
||
|
||
func TestTargetIDMapperKeepsSharedResourceIdentity(t *testing.T) {
|
||
m := newTargetIDMapper(10000, "kb-a", nil)
|
||
res := "99999999-9999-4999-8999-999999999999"
|
||
m.registerSourceID("resource_bindings", "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb")
|
||
know := "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"
|
||
m.registerSourceID("knowledges", know)
|
||
row := rawTargetRow(t, map[string]any{"id": "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
|
||
"resource_id": res, "owner_id": know, "owner_type": "knowledge"})
|
||
if err := m.remapRow("resource_bindings", row); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if got := jsonString(t, row["resource_id"]); got != res {
|
||
t.Fatalf("shared resource id must not be remapped: %s", got)
|
||
}
|
||
if got := jsonString(t, row["owner_id"]); got != m.mapID("knowledges", know) {
|
||
t.Fatalf("owner_id not remapped: %s", got)
|
||
}
|
||
}
|
||
|
||
func TestTargetIDMapperRejectsUnmappedReference(t *testing.T) {
|
||
m := newTargetIDMapper(10000, "kb-a", nil)
|
||
m.registerSourceID("chunks", "cccccccc-cccc-4ccc-8ccc-cccccccccccc")
|
||
row := rawTargetRow(t, map[string]any{"id": "dddddddd-dddd-4ddd-8ddd-dddddddddddd",
|
||
"chunk_refs": []string{"eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee"}})
|
||
if err := m.remapRow("wiki_pages", row); err == nil {
|
||
t.Fatal("unmapped dangling reference was accepted")
|
||
}
|
||
}
|
||
|
||
func TestTargetIndexDocumentMapping(t *testing.T) {
|
||
m := newTargetIDMapper(10000, "kb-a", nil)
|
||
chunk := "12121212-1212-4212-8212-121212121212"
|
||
m.registerSourceID("chunks", chunk)
|
||
doc := []byte(`{"chunk_id":"` + chunk + `","knowledge_base_id":"old","content":"c"}`)
|
||
id, source, err := m.remapIndexDocument("doc-1", doc)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if id == "doc-1" {
|
||
t.Fatal("index document id not remapped")
|
||
}
|
||
var out map[string]any
|
||
if err := json.Unmarshal(source, &out); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if out["chunk_id"] != m.mapID("chunks", chunk) {
|
||
t.Fatalf("index chunk_id not remapped: %v", out["chunk_id"])
|
||
}
|
||
if out["content"] != "c" {
|
||
t.Fatal("index content changed")
|
||
}
|
||
}
|
||
|
||
func TestTargetIDMapperRewritesRelationTuple(t *testing.T) {
|
||
m := newTargetIDMapper(10000, "kb-a", nil)
|
||
know := "13131313-1313-4131-8131-131313131313"
|
||
tag := "14141414-1414-4141-8141-141414141414"
|
||
m.registerSourceID("knowledges", know)
|
||
m.registerSourceID("knowledge_tags", tag)
|
||
row := rawTargetRow(t, map[string]any{"knowledge_id": know, "tag_id": tag})
|
||
if err := m.remapRow("knowledge_tag_relations", row); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if jsonString(t, row["knowledge_id"]) != m.mapID("knowledges", know) || jsonString(t, row["tag_id"]) != m.mapID("knowledge_tags", tag) {
|
||
t.Fatal("relation tuple not remapped")
|
||
}
|
||
}
|
||
|
||
func TestTargetMappingOnlyAppliesToTargetSnapshot(t *testing.T) {
|
||
plan := &libraryrelease.WriteSet{TargetSnapshotID: "target-seal", BackupSnapshotID: "backup-seal"}
|
||
target := &ProductionLibraryTarget{activePlan: plan, targetIDMode: libraryrelease.TargetIDModeScoped}
|
||
if !target.targetMappingApplies("target-seal") {
|
||
t.Fatal("target snapshot must be mapped")
|
||
}
|
||
if target.targetMappingApplies("backup-seal") {
|
||
t.Fatal("backup/before-image must not be mapped")
|
||
}
|
||
target.preserveChunkSequence = true
|
||
if target.targetMappingApplies("target-seal") {
|
||
t.Fatal("restore replay must not be mapped")
|
||
}
|
||
target.preserveChunkSequence = false
|
||
target.targetIDMode = ""
|
||
if target.targetMappingApplies("target-seal") {
|
||
t.Fatal("legacy plan without target id mode must not be mapped")
|
||
}
|
||
}
|
||
|
||
func TestTargetIDMapperPreservesLargeNumbersAndRejectsAmbiguity(t *testing.T) {
|
||
m := newTargetIDMapper(10000, "kb-a", nil)
|
||
chunk := "15151515-1515-4515-8515-151515151515"
|
||
m.registerSourceID("chunks", chunk)
|
||
// 同列还有 9007199254740993(>2^53):必须逐字节保留。
|
||
row := rawTargetRow(t, map[string]any{"id": "16161616-1616-4616-8616-161616161616",
|
||
"relation_chunks": json.RawMessage(`["` + chunk + `",9007199254740993]`)})
|
||
m.registerSourceID("chunks", "16161616-1616-4616-8616-161616161616")
|
||
if err := m.remapRow("chunks", row); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if got := string(row["relation_chunks"]); got != `["`+m.mapID("chunks", chunk)+`",9007199254740993]` {
|
||
t.Fatalf("relation payload not preserved: %s", got)
|
||
}
|
||
// 同一字符串 ID 同时出现在两张表:不能 first-table-wins 猜映射。
|
||
same := "17171717-1717-4717-8717-171717171717"
|
||
m.registerSourceID("chunks", same)
|
||
m.registerSourceID("knowledges", same)
|
||
m.registerSourceID("chunks", "18181818-1818-4818-8818-181818181818")
|
||
shared := rawTargetRow(t, map[string]any{"id": "18181818-1818-4818-8818-181818181818",
|
||
"relation_chunks": []string{same}})
|
||
if err := m.remapRow("chunks", shared); err != nil {
|
||
t.Fatalf("typed chunk reference rejected for cross-table same id: %v", err)
|
||
}
|
||
if got := string(shared["relation_chunks"]); got != `["`+m.mapID("chunks", same)+`"]` {
|
||
t.Fatalf("relation must resolve by field semantics: %s", got)
|
||
}
|
||
}
|
||
|
||
func TestTargetIDMapperDoesNotInventEntitiesFromReferences(t *testing.T) {
|
||
// 引用值不能反向登记为实体:wiki page 的 chunk_refs 指向一个不存在的主键。
|
||
m := newTargetIDMapper(10000, "kb-a", nil)
|
||
m.registerSourceID("wiki_pages", "19191919-1919-4919-8919-191919191919")
|
||
row := rawTargetRow(t, map[string]any{"id": "19191919-1919-4919-8919-191919191919",
|
||
"chunk_refs": []string{"20202020-2020-4020-8020-202020202020"}})
|
||
if err := m.remapRow("wiki_pages", row); err == nil {
|
||
t.Fatal("dangling chunk_ref was accepted")
|
||
}
|
||
}
|
||
|
||
func jsonString(t *testing.T, raw json.RawMessage) string {
|
||
t.Helper()
|
||
var s string
|
||
if err := json.Unmarshal(raw, &s); err != nil {
|
||
t.Fatalf("not a string: %s", raw)
|
||
}
|
||
return s
|
||
}
|