0d9091e464
build / build (push) Successful in 1m41s
空 mode 计划不映射;索引 source_id 按语义映射;relation 按字段表解析。 隔离回归按持久映射 ID 断言,DS02 故障注入真实命中。
248 lines
10 KiB
Go
248 lines
10 KiB
Go
package v071
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"knowledge-governance/internal/libraryrelease"
|
|
)
|
|
|
|
func TestR10SourceRelationClosureIsolated(t *testing.T) {
|
|
for _, mode := range []string{"missing-tag", "missing-knowledge", "cross-kb", "cross-tenant", "orphan-chunk", "unknown-owner", "missing-resource-owner", "null-owner"} {
|
|
t.Run(mode, func(t *testing.T) {
|
|
fx := openWriteSetFixture(t)
|
|
seedTargetData(t, fx)
|
|
r10Exec(t, fx, `INSERT INTO knowledge_tags(id,tenant_id,knowledge_base_id) VALUES('tag-target',10001,'kb-target'),('tag-other',10001,'kb-other'),('tag-foreign',10002,'kb-foreign')`)
|
|
switch mode {
|
|
case "missing-tag":
|
|
r10Exec(t, fx, `INSERT INTO knowledge_tag_relations VALUES('doc-target','absent')`)
|
|
case "missing-knowledge":
|
|
r10Exec(t, fx, `INSERT INTO knowledge_tag_relations VALUES('absent','tag-target')`)
|
|
case "cross-kb":
|
|
r10Exec(t, fx, `INSERT INTO knowledge_tag_relations VALUES('doc-target','tag-other')`)
|
|
case "cross-tenant":
|
|
r10Exec(t, fx, `INSERT INTO knowledge_tag_relations VALUES('doc-target','tag-foreign')`)
|
|
case "orphan-chunk":
|
|
r10Exec(t, fx, `UPDATE chunks SET knowledge_id='absent' WHERE id='chunk-target'`)
|
|
case "unknown-owner":
|
|
r10Exec(t, fx, `UPDATE resource_bindings SET owner_type='unknown-v071-shape' WHERE id='bind-target'`)
|
|
case "missing-resource-owner":
|
|
r10Exec(t, fx, `UPDATE resource_bindings SET owner_id='absent-owner' WHERE id='bind-target'`)
|
|
case "null-owner":
|
|
r10Exec(t, fx, `UPDATE resource_bindings SET owner_type=NULL,owner_id='doc-other' WHERE id='bind-target'`)
|
|
}
|
|
before := r10State(t, fx)
|
|
_, e := ExportLibrary(fx.ctx, fx.pool, PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB})
|
|
r10Unchanged(t, fx, before)
|
|
if e == nil {
|
|
t.Fatal("source silently excluded a scoped unresolved relationship")
|
|
}
|
|
r10Save(t, "rejection", e.Error())
|
|
snapshot := sealSourceSnapshot(t, fx, nil)
|
|
target := fx.target(t)
|
|
result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil)
|
|
r10Save(t, "existing-target-rejection", result)
|
|
if result.State != "failed" || result.FailedAt != "" {
|
|
t.Fatalf("existing unresolved target relationship reached writes: %+v", result)
|
|
}
|
|
r10Unchanged(t, fx, before)
|
|
})
|
|
}
|
|
}
|
|
func TestR10IncomingRelationClosureIsolated(t *testing.T) {
|
|
for _, mode := range []string{"valid-new", "valid-existing", "missing-tag", "missing-knowledge", "cross-kb", "cross-tenant", "unknown-owner", "missing-resource"} {
|
|
t.Run(mode, func(t *testing.T) {
|
|
fx := openWriteSetFixture(t)
|
|
seedTargetData(t, fx)
|
|
positive := strings.HasPrefix(mode, "valid-")
|
|
if positive {
|
|
r10Exec(t, fx, `INSERT INTO knowledge_tags(id,tenant_id,knowledge_base_id) VALUES('tag-target',10001,'kb-target'),('tag-other',10001,'kb-other'); INSERT INTO knowledge_tag_relations(knowledge_id,tag_id) VALUES('doc-target','tag-target'),('doc-other','tag-other')`)
|
|
}
|
|
snapshot := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) {
|
|
parts["knowledge_tags"] = []map[string]any{{"id": "tag-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB}}
|
|
parts["knowledge_tag_relations"] = []map[string]any{{"knowledge_id": "doc-src", "tag_id": "tag-src"}}
|
|
switch mode {
|
|
case "valid-existing":
|
|
parts["knowledges"][0]["id"] = "doc-target"
|
|
parts["chunks"][0]["knowledge_id"] = "doc-target"
|
|
parts["resource_bindings"][0]["owner_id"] = "doc-target"
|
|
parts["knowledge_tags"][0]["id"] = "tag-target"
|
|
parts["knowledge_tag_relations"][0] = map[string]any{"knowledge_id": "doc-target", "tag_id": "tag-target"}
|
|
case "missing-tag":
|
|
parts["knowledge_tag_relations"][0]["tag_id"] = "missing"
|
|
case "missing-knowledge":
|
|
parts["knowledge_tag_relations"][0]["knowledge_id"] = "missing"
|
|
case "cross-kb":
|
|
parts["knowledge_tags"][0]["knowledge_base_id"] = wsOtherKB
|
|
case "unknown-owner":
|
|
parts["resource_bindings"][0]["owner_type"] = "unknown-v071-shape"
|
|
case "cross-tenant":
|
|
parts["knowledge_tags"][0]["tenant_id"] = 20000
|
|
case "missing-resource":
|
|
parts["resource_bindings"][0]["resource_id"] = "absent-resource"
|
|
}
|
|
})
|
|
before := r10State(t, fx)
|
|
target := fx.target(t)
|
|
result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil)
|
|
r10Save(t, "outcome", result)
|
|
if positive {
|
|
if result.State != "succeeded" {
|
|
t.Fatalf("nonempty tuple publication: %+v", result)
|
|
}
|
|
wantID := expectedTargetID(wsTargetTenant, wsTargetKB, "knowledges", "doc-src") + ":" +
|
|
expectedTargetID(wsTargetTenant, wsTargetKB, "knowledge_tags", "tag-src")
|
|
if mode == "valid-existing" {
|
|
wantID = expectedTargetID(wsTargetTenant, wsTargetKB, "knowledges", "doc-target") + ":" +
|
|
expectedTargetID(wsTargetTenant, wsTargetKB, "knowledge_tags", "tag-target")
|
|
}
|
|
found := false
|
|
for _, row := range result.Backup.WriteSet.Rows {
|
|
if row.Table == "knowledge_tag_relations" && row.ID == wantID {
|
|
found = true
|
|
// 映射后所有 tuple 都是目标新身份;即使源 ID 恰是目标库已存在的
|
|
// doc-target/tag-target,它们会被派生成本次的新 ID,写前不存在。
|
|
if row.Existing {
|
|
t.Fatal("mapped tuple misclassified as pre-existing", row)
|
|
}
|
|
}
|
|
}
|
|
if !found {
|
|
t.Fatal("tuple absent from frozen write set")
|
|
}
|
|
var outside int
|
|
if e := fx.pool.QueryRow(fx.ctx, `SELECT count(*) FROM knowledge_tag_relations WHERE knowledge_id='doc-other' AND tag_id='tag-other'`).Scan(&outside); e != nil || outside != 1 {
|
|
t.Fatal("outside tuple changed", e)
|
|
}
|
|
if e := target.Restore(fx.ctx, result.Backup); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
after := r10State(t, fx)
|
|
for _, key := range []string{"pg", "versions", "delete_markers"} {
|
|
if !reflect.DeepEqual(before[key], after[key]) {
|
|
t.Fatal("tuple rollback changed original data", key)
|
|
}
|
|
}
|
|
r10Save(t, "restored", after)
|
|
return
|
|
}
|
|
if result.State != "failed" || result.FailedAt != "" {
|
|
t.Fatalf("incoming unresolved reference passed preflight: %+v", result)
|
|
}
|
|
r10Unchanged(t, fx, before)
|
|
})
|
|
}
|
|
}
|
|
func TestR10BodyOnlyResourceIsolated(t *testing.T) {
|
|
for _, mode := range []string{"knowledge-content", "wiki-content", "knowledge-metadata", "wiki-metadata"} {
|
|
t.Run(mode, func(t *testing.T) {
|
|
fx := openWriteSetFixture(t)
|
|
seedTargetData(t, fx)
|
|
r10Exec(t, fx, `DELETE FROM resource_bindings WHERE owner_id='doc-target'; UPDATE chunks SET content='plain' WHERE id='chunk-target'; ALTER TABLE knowledges ADD COLUMN content text; ALTER TABLE knowledges ADD COLUMN metadata jsonb; ALTER TABLE wiki_pages ADD COLUMN metadata jsonb`)
|
|
table, column := "knowledges", "content"
|
|
if strings.HasPrefix(mode, "wiki") {
|
|
table = "wiki_pages"
|
|
}
|
|
if strings.HasSuffix(mode, "metadata") {
|
|
column = "metadata"
|
|
}
|
|
value := any("")
|
|
if column == "metadata" {
|
|
raw, _ := json.Marshal(map[string]any{"image_info": []any{map[string]string{"url": "resource://" + wsHandleTarget}}})
|
|
value = string(raw)
|
|
}
|
|
if _, e := fx.pool.Exec(fx.ctx, fmt.Sprintf("UPDATE %s SET %s=$1 WHERE knowledge_base_id=$2", table, column), value, wsTargetKB); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
before := r10State(t, fx)
|
|
pg, e := ExportLibrary(fx.ctx, fx.pool, PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB})
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
found := false
|
|
for _, row := range pg.Table("resources").Rows {
|
|
var id struct {
|
|
ID string `json:"id"`
|
|
}
|
|
_ = json.Unmarshal(row, &id)
|
|
if id.ID == "res-target" {
|
|
found = true
|
|
}
|
|
if id.ID == "res-orphan" {
|
|
t.Fatal("unowned historical resource adopted into source")
|
|
}
|
|
}
|
|
if !found {
|
|
t.Fatal("body/metadata resource not captured without binding")
|
|
}
|
|
if len(pg.Table("resource_bindings").Rows) != 0 {
|
|
t.Fatal("fixture unexpectedly had bindings")
|
|
}
|
|
r10Save(t, "captured-resources", pg.Table("resources"))
|
|
backup, e := exportLibraryBeforeImage(fx.ctx, fx.pool, PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB})
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
found = false
|
|
for _, raw := range backup.Table("resources").Rows {
|
|
var row struct {
|
|
ID string `json:"id"`
|
|
}
|
|
_ = json.Unmarshal(raw, &row)
|
|
if row.ID == "res-target" {
|
|
found = true
|
|
}
|
|
}
|
|
if !found {
|
|
t.Fatal("body-only target resource missing from before-image")
|
|
}
|
|
r10Unchanged(t, fx, before)
|
|
snapshot := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) {
|
|
parts["resource_bindings"] = []map[string]any{}
|
|
parts["chunks"][0]["content"] = "plain source"
|
|
parts[table][0][column] = ""
|
|
if column == "metadata" {
|
|
parts[table][0][column] = map[string]any{"image_info": []any{map[string]string{"url": "resource://" + wsHandleSource}}}
|
|
}
|
|
})
|
|
target := fx.target(t)
|
|
result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil)
|
|
r10Save(t, "publication", result)
|
|
if result.State != "succeeded" {
|
|
t.Fatalf("body-only publication: %+v", result)
|
|
}
|
|
if err := target.Restore(fx.ctx, result.Backup); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
after := r10State(t, fx)
|
|
for _, key := range []string{"pg", "versions", "delete_markers"} {
|
|
if !reflect.DeepEqual(before[key], after[key]) {
|
|
t.Fatalf("body-only restore changed %s including historical orphans", key)
|
|
}
|
|
}
|
|
r10Save(t, "restored", after)
|
|
})
|
|
}
|
|
}
|
|
func TestR10UnknownResourceShapeIsolated(t *testing.T) {
|
|
for _, body := range []string{"resource://short", "resource://" + wsHandleTarget + "extra", "resource://" + wsHandleTarget + "?download=1", "resource:\\/\\/" + wsHandleTarget} {
|
|
t.Run(fmt.Sprint(len(body))+strings.ReplaceAll(body[len(body)-3:], "/", "_"), func(t *testing.T) {
|
|
fx := openWriteSetFixture(t)
|
|
seedTargetData(t, fx)
|
|
if _, e := fx.pool.Exec(fx.ctx, `UPDATE wiki_pages SET content=$1 WHERE id='wiki-target'`, body); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
before := r10State(t, fx)
|
|
_, e := ExportLibrary(fx.ctx, fx.pool, PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB})
|
|
r10Unchanged(t, fx, before)
|
|
if e == nil {
|
|
t.Fatal("unknown resource reference shape silently accepted")
|
|
}
|
|
r10Save(t, "rejection", e.Error())
|
|
})
|
|
}
|
|
}
|