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

285 lines
12 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"
"fmt"
"net/http"
"reflect"
"strings"
"testing"
"knowledge-governance/internal/libraryrelease"
"knowledge-governance/internal/librarysnapshot"
)
// r12 covers the acceptance rows that had an implementation but no executed
// scenario: soft-delete before-image completeness (B09), shared-resource
// difference matrix (B11), foreign index document byte identity (B18),
// independent index oracle on content/vector/metadata (B20) and pre-existing
// object versions across a late failure (B15).
func r12ESDoc(t *testing.T, fx *writeSetFixture, id string) map[string]any {
t.Helper()
return recoveryIndexReadback(t, fx)[id]
}
func r12PutDoc(t *testing.T, fx *writeSetFixture, id, chunkID string, tenant uint64, kb, knowledge, content string, embedding []float64) {
t.Helper()
body, err := json.Marshal(map[string]any{"tenant_id": tenant, "knowledge_base_id": kb,
"knowledge_id": knowledge, "chunk_id": chunkID, "source_id": chunkID, "content": content, "embedding": embedding})
if err != nil {
t.Fatal(err)
}
request, err := http.NewRequestWithContext(fx.ctx, "PUT",
fmt.Sprintf("%s/%s/_doc/%s?refresh=true", fx.searchBase, fx.index, id), strings.NewReader(string(body)))
if err != nil {
t.Fatal(err)
}
request.Header.Set("Content-Type", "application/json")
response, err := fx.client.Do(request)
if err != nil {
t.Fatalf("put doc: %v", err)
}
defer response.Body.Close()
if response.StatusCode != 200 && response.StatusCode != 201 {
t.Fatalf("put doc %s => %d", id, response.StatusCode)
}
}
// B09:destructive predicate 能碰到的每一张带 deleted_at 的表都必须进入
// before-image;晚阶段失败后的恢复要把这些行逐列放回去(不是"恢复活跃行")。
func TestR12DeletedCascadeBeforeImageAndRestoreIsolated(t *testing.T) {
fx := openWriteSetFixture(t)
seedTargetData(t, fx)
for _, statement := range []string{
`UPDATE knowledges SET deleted_at=now() WHERE id='doc-other'`,
`UPDATE chunks SET deleted_at=now() WHERE id='chunk-other'`,
`INSERT INTO knowledge_tags(id,tenant_id,knowledge_base_id,deleted_at) VALUES('deleted-tag',10001,'kb-target',now())`,
`UPDATE resources SET deleted_at=now() WHERE id='res-orphan'`,
`INSERT INTO wiki_folders(id,tenant_id,knowledge_base_id,deleted_at) VALUES('deleted-folder',10001,'kb-target',now())`,
`INSERT INTO wiki_page_issues(id,tenant_id,knowledge_base_id,deleted_at) VALUES('deleted-issue',10001,'kb-target',now())`,
`UPDATE wiki_pages SET deleted_at=now() WHERE id='wiki-target'`,
} {
r10Exec(t, fx, statement)
}
softDeleted := []string{"knowledges", "chunks", "knowledge_tags", "resources", "wiki_folders", "wiki_page_issues", "wiki_pages"}
before := universeDump(t, fx.pool)
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, "", current)
if err != nil {
t.Fatal(err)
}
archive, err := librarysnapshot.Open(fx.archiveRoot, 256*1024*1024)
if err != nil {
t.Fatal(err)
}
manifest, err := archive.Load(backup.SnapshotID)
if err != nil {
t.Fatal(err)
}
archive.Close()
counts := map[string]int64{}
for _, part := range manifest.Parts {
if part.Kind == "database" || part.Kind == "wiki" {
counts[part.Name] = part.Count
}
}
for _, table := range softDeleted {
if counts[table] != current.Counts[table] {
t.Fatalf("before-image 漏掉 %s 的软删除行:备份 %d 行,删除谓词命中 %d 行", table, counts[table], current.Counts[table])
}
}
r10Save(t, "deleted-before-image-counts", counts)
// 晚阶段失败 → 恢复:所有行(含软删除行)逐列回到失败前的样子。
outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), contractFailWikiTarget{target}, fx.backups(t, target), nil)
if outcome.State != "rolled_back" {
t.Fatalf("late failure must roll back: %+v", outcome)
}
if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" {
t.Fatalf("rollback did not restore soft-deleted rows exactly: %s", diff)
}
var survivors int
if err := fx.pool.QueryRow(fx.ctx,
`SELECT count(*) FROM knowledge_tags WHERE deleted_at IS NOT NULL AND knowledge_base_id=$1`, wsTargetKB).Scan(&survivors); err != nil {
t.Fatal(err)
}
if survivors != 1 {
t.Fatalf("soft-deleted tag row lost after rollback: %d", survivors)
}
}
// B18:同 _id 已属其它知识库时,写前拒绝并且那份外部文档的 _source、向量和
// seq_no/term 一个字节都不能变。
func TestR12ForeignIndexDocumentStaysByteIdenticalIsolated(t *testing.T) {
fx := openWriteSetFixture(t)
seedTargetData(t, fx)
fx.indexDoc(t, "chunk-src", wsTargetTenant, wsOtherKB, "doc-other", "protected foreign vector")
before := r10State(t, fx)
foreignBefore := r12ESDoc(t, fx, "chunk-src")
if foreignBefore == nil {
t.Fatal("foreign document fixture missing")
}
snapshot := sealSourceSnapshot(t, fx, nil)
target := fx.target(t)
outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil)
if outcome.State != "failed" || outcome.FailedAt != "" {
t.Fatalf("index collision must fail before any write: %+v", outcome)
}
r10Unchanged(t, fx, before)
foreignAfter := r12ESDoc(t, fx, "chunk-src")
if !reflect.DeepEqual(foreignBefore, foreignAfter) {
t.Fatalf("foreign document changed:\n%v\n->\n%v", foreignBefore, foreignAfter)
}
source, _ := foreignAfter["_source"].(map[string]any)
if source["knowledge_base_id"] != wsOtherKB {
t.Fatalf("foreign document changed owner: %v", source["knowledge_base_id"])
}
r10Save(t, "foreign-document", foreignAfter)
}
// B20:发布成功后,正文/向量/metadata 任一被改都必须让独立 oracle 变红;
// 未改动时同一 oracle 必须通过(合法本地列映射不因这项收紧被误杀)。
func TestR12IndexOracleDetectsContentVectorAndMetadataChangesIsolated(t *testing.T) {
fx := openWriteSetFixture(t)
seedTargetData(t, fx)
snapshot := sealSourceSnapshot(t, fx, nil)
target := fx.target(t)
outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, fx.target(t)), nil)
if outcome.State != "succeeded" {
t.Fatalf("baseline publish failed: %+v", outcome)
}
expect := libraryrelease.Expectation{SnapshotID: snapshot}
if err := target.Verify(fx.ctx, expect); err != nil {
t.Fatalf("baseline oracle must pass: %v", err)
}
docID := expectedIndexID("chunk-src")
chunkID := expectedTargetID(wsTargetTenant, wsTargetKB, "chunks", "chunk-src")
published := r12ESDoc(t, fx, docID)
if published == nil {
t.Fatal("published document missing")
}
source, _ := published["_source"].(map[string]any)
originalContent, _ := source["content"].(string)
originalEmbedding := source["embedding"]
originalKnowledge, _ := source["knowledge_id"].(string)
// 1) 正文被改。
r12PutDoc(t, fx, docID, chunkID, wsTargetTenant, wsTargetKB, originalKnowledge, "被篡改的正文", []float64{0.1, 0.2})
if err := target.Verify(fx.ctx, expect); err == nil {
t.Fatal("正文篡改没有让独立 oracle 变红")
}
r12PutDoc(t, fx, docID, chunkID, wsTargetTenant, wsTargetKB, originalKnowledge, originalContent, []float64{0.1, 0.2})
if err := target.Verify(fx.ctx, expect); err != nil {
t.Fatalf("恢复正文后 oracle 必须通过:%v", err)
}
// 2) 向量被改(同维不同值)。
r12PutDoc(t, fx, docID, chunkID, wsTargetTenant, wsTargetKB, originalKnowledge, originalContent, []float64{0.9, 0.8})
if err := target.Verify(fx.ctx, expect); err == nil {
t.Fatal("向量篡改没有让独立 oracle 变红")
}
r12PutDoc(t, fx, docID, chunkID, wsTargetTenant, wsTargetKB, originalKnowledge, originalContent, []float64{0.1, 0.2})
if err := target.Verify(fx.ctx, expect); err != nil {
t.Fatalf("恢复向量后 oracle 必须通过:%v", err)
}
// 3) metadata(knowledge_id)被改。
r12PutDoc(t, fx, docID, chunkID, wsTargetTenant, wsTargetKB, "doc-target", originalContent, []float64{0.1, 0.2})
if err := target.Verify(fx.ctx, expect); err == nil {
t.Fatal("metadata 篡改没有让独立 oracle 变红")
}
r12PutDoc(t, fx, docID, chunkID, wsTargetTenant, wsTargetKB, originalKnowledge, originalContent, []float64{0.1, 0.2})
if err := target.Verify(fx.ctx, expect); err != nil {
t.Fatalf("恢复 metadata 后 oracle 必须通过:%v", err)
}
if !reflect.DeepEqual(originalEmbedding, []any{0.1, 0.2}) && !reflect.DeepEqual(originalEmbedding, []any{0.10000000149011612, 0.20000000298023224}) {
t.Logf("published embedding representation = %v", originalEmbedding)
}
}
// B15:对象已上传、Wiki 阶段失败时,本次新建对象不得残留,且**已有对象的
// 精确版本**不能因为回滚而变化。
func TestR12LateWikiFailureKeepsPreExistingObjectVersionsIsolated(t *testing.T) {
fx := openWriteSetFixture(t)
seedTargetData(t, fx)
existing := wsLocator("backend-target", "minio", wsBucket, wsTargetTenant, "res-target")
before, err := fx.objects.s3.ObserveObject(fx.ctx, "minio", existing)
if err != nil || !before.Exists {
t.Fatalf("pre-existing object missing: %+v %v", before, err)
}
snapshot := sealSourceSnapshot(t, fx, nil)
target := fx.target(t)
outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), contractFailWikiTarget{target}, fx.backups(t, target), nil)
if outcome.State != "rolled_back" || outcome.FailedAt != libraryrelease.StageWiki {
t.Fatalf("late wiki failure: %+v", outcome)
}
if fx.objects.puts.Load() == 0 {
t.Fatal("late failure never reached the real object write")
}
after, err := fx.objects.s3.ObserveObject(fx.ctx, "minio", existing)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(before, after) {
t.Fatalf("pre-existing object version changed across rollback: %+v -> %+v", before, after)
}
created, err := fx.objects.s3.ObserveObject(fx.ctx, "minio",
wsLocator("backend-target", "minio", wsBucket, wsTargetTenant, "res-src"))
if err != nil || created.Exists {
t.Fatalf("created object residue after rollback: %+v %v", created, err)
}
r10Save(t, "object-versions", map[string]any{"existing_before": before, "existing_after": after})
}
// B11:同 ID 共享资源在 handle / 定位 / 字节 三类差异下都必须写前拒绝,
// 并且其它知识库看到的字节与版本不变。
func TestR12SharedResourceDifferenceMatrixIsolated(t *testing.T) {
for _, mode := range []string{"handle", "locator", "bytes"} {
t.Run(mode, func(t *testing.T) {
fx := openWriteSetFixture(t)
seedTargetData(t, fx)
sharedPath := wsLocator("backend-target", "minio", wsBucket, wsTargetTenant, "res-shared")
sharedBefore, err := fx.objects.s3.ObserveObject(fx.ctx, "minio", sharedPath)
if err != nil || !sharedBefore.Exists {
t.Fatalf("shared object missing: %+v %v", sharedBefore, err)
}
row := map[string]any{"id": "res-shared", "handle": wsHandleShared, "tenant_id": wsSourceTenant,
"storage_backend_id": "backend-source", "provider": "oss",
"physical_path": wsLocator("backend-source", "oss", "source-bucket", wsSourceTenant, "res-shared"),
"size": int64(8)}
// 归档里必须有这条资源自己的字节,否则失败原因会变成"归档依赖不全",
// 而不是被测的差异类型。
extra := map[string]string{"res-shared": "12345678"}
switch mode {
case "handle":
row["handle"] = "hhhhhhhhhhhhhhhhhhhhhh"
case "locator":
row["physical_path"] = wsLocator("backend-source", "oss", "source-bucket", wsSourceTenant, "res-shared-moved")
case "bytes":
extra["res-shared"] = "87654321"
}
snapshot := sealSourceSnapshotScope(t, fx, wsSourceTenant, wsSourceKB, func(parts map[string][]map[string]any) {
parts["resources"] = append(parts["resources"], row)
}, extra)
before := r10State(t, fx)
target := fx.target(t)
outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil)
if outcome.State != "failed" || outcome.FailedAt != "" {
t.Fatalf("%s 差异必须写前拒绝:%+v", mode, outcome)
}
r10Unchanged(t, fx, before)
sharedAfter, err := fx.objects.s3.ObserveObject(fx.ctx, "minio", sharedPath)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(sharedBefore, sharedAfter) {
t.Fatalf("%s 差异改动了共享对象的版本:%+v -> %+v", mode, sharedBefore, sharedAfter)
}
})
}
}