Files
knowledge-governance/internal/releaseadapter/v071/data_state_r12_test.go
T
姚章浩 8df19f9368 test(library): 补软删除共享资源与索引 oracle 隔离用例
真实本机 PG/ES/MinIO 上补五组场景:7 张带 deleted_at 表的软删除 before-image 与
恢复逐列复原;同 _id 属其它知识库时外部文档 _source/seq_no/term 逐字节不变;
正文/向量/metadata 任一篡改都让独立 oracle 变红;晚阶段失败后既有对象精确版本
不变;同 ID 共享资源在 handle/定位/字节三类差异下写前拒绝。另在复用用例里补
"no-op 复用不改写对象版本"的断言。

需隔离服务的用例继续在 test-scope.json 显式声明:普通 CI 跳过不算通过。
2026-11-01 12:08:55 +08:00

283 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 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": id, "source_id": id, "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)
}
published := r12ESDoc(t, fx, "chunk-src")
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, "chunk-src", wsTargetTenant, wsTargetKB, originalKnowledge, "被篡改的正文", []float64{0.1, 0.2})
if err := target.Verify(fx.ctx, expect); err == nil {
t.Fatal("正文篡改没有让独立 oracle 变红")
}
r12PutDoc(t, fx, "chunk-src", 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, "chunk-src", wsTargetTenant, wsTargetKB, originalKnowledge, originalContent, []float64{0.9, 0.8})
if err := target.Verify(fx.ctx, expect); err == nil {
t.Fatal("向量篡改没有让独立 oracle 变红")
}
r12PutDoc(t, fx, "chunk-src", 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, "chunk-src", 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, "chunk-src", 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)
}
})
}
}