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