Files
knowledge-governance/internal/releaseadapter/v071/library_target_ids_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

264 lines
10 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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
}