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

263 lines
11 KiB
Go

package v071
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"reflect"
"strings"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/s3"
"knowledge-governance/internal/libraryrelease"
"knowledge-governance/internal/librarysnapshot"
)
func r10Save(t *testing.T, label string, value any) {
t.Helper()
root := os.Getenv("KG_R10_RUN")
if root == "" {
return
}
name := strings.NewReplacer("/", "_", " ", "_").Replace(t.Name()+"-"+label) + ".json"
data, e := json.MarshalIndent(value, "", " ")
if e != nil {
t.Fatal(e)
}
if e = os.WriteFile(filepath.Join(root, name), data, 0600); e != nil {
t.Fatal(e)
}
}
func r10Exec(t *testing.T, fx *writeSetFixture, sql string) {
t.Helper()
if _, e := fx.pool.Exec(fx.ctx, sql); e != nil {
t.Fatal(e)
}
}
func r10State(t *testing.T, fx *writeSetFixture) map[string]any {
t.Helper()
objects, e := fx.objects.s3.client.ListObjectVersions(fx.ctx, &s3.ListObjectVersionsInput{Bucket: aws.String(fx.bucket)})
if e != nil {
t.Fatal(e)
}
if aws.ToBool(objects.IsTruncated) {
t.Fatal("truncated object evidence")
}
seq := map[string]any{}
for _, name := range []string{"chunks_seq_id_seq", "knowledge_tags_seq_id_seq", "wiki_log_entries_id_seq"} {
var exists bool
if e := fx.pool.QueryRow(fx.ctx, "SELECT to_regclass($1) IS NOT NULL", name).Scan(&exists); e != nil {
t.Fatal(e)
}
if exists {
var last int64
var called bool
if e := fx.pool.QueryRow(fx.ctx, "SELECT last_value,is_called FROM "+name).Scan(&last, &called); e != nil {
t.Fatal(e)
}
seq[name] = []any{last, called}
}
}
r10Save(t, "namespace", map[string]string{"bucket": fx.bucket, "index": fx.index})
return map[string]any{"pg": universeDump(t, fx.pool), "index": recoveryIndexReadback(t, fx), "versions": objects.Versions, "delete_markers": objects.DeleteMarkers, "sequences": seq}
}
func r10Unchanged(t *testing.T, fx *writeSetFixture, before map[string]any) {
t.Helper()
after := r10State(t, fx)
r10Save(t, "before", before)
r10Save(t, "after", after)
if !reflect.DeepEqual(before, after) {
t.Fatal("rejected contract changed rows, ES CAS, exact object versions or sequence state")
}
}
func r10Sequences(t *testing.T, fx *writeSetFixture) {
r10Exec(t, fx, `CREATE SEQUENCE chunks_seq_id_seq; ALTER TABLE chunks ADD COLUMN seq_id bigint NOT NULL DEFAULT nextval('chunks_seq_id_seq'); CREATE UNIQUE INDEX r10_chunks_seq ON chunks(seq_id);
CREATE SEQUENCE knowledge_tags_seq_id_seq; ALTER TABLE knowledge_tags ADD COLUMN seq_id bigint NOT NULL DEFAULT nextval('knowledge_tags_seq_id_seq'); CREATE UNIQUE INDEX r10_tags_seq ON knowledge_tags(seq_id);
CREATE SEQUENCE wiki_log_entries_id_seq; ALTER TABLE wiki_log_entries ALTER COLUMN id SET DEFAULT nextval('wiki_log_entries_id_seq'); ALTER SEQUENCE wiki_log_entries_id_seq OWNED BY wiki_log_entries.id; ALTER TABLE wiki_log_entries ADD PRIMARY KEY(id);
INSERT INTO knowledge_tags(id,tenant_id,knowledge_base_id) VALUES('tag-other',10001,'kb-other'); INSERT INTO wiki_log_entries(tenant_id,knowledge_base_id) VALUES(10001,'kb-other')`)
}
func r10LocalRows(parts map[string][]map[string]any) {
parts["chunks"][0]["seq_id"] = 10
parts["knowledge_tags"] = []map[string]any{{"id": "tag-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "seq_id": 10}}
parts["wiki_log_entries"] = []map[string]any{{"id": 100, "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB}, {"id": 2, "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB}}
}
func TestR10SequenceRejectionIsolated(t *testing.T) {
for _, table := range []string{"chunks", "knowledge_tags", "wiki_log_entries"} {
for _, mode := range []string{"behind", "exhausted", "explicit-null"} {
t.Run(table+"-"+mode, func(t *testing.T) {
fx := openWriteSetFixture(t)
seedTargetData(t, fx)
r10Sequences(t, fx)
column := "seq_id"
if table == "wiki_log_entries" {
column = "id"
}
sequence := table + "_" + column + "_seq"
if mode == "behind" {
r10Exec(t, fx, fmt.Sprintf("SELECT setval('%s',1,false)", sequence))
}
if mode == "exhausted" {
r10Exec(t, fx, fmt.Sprintf("SELECT setval('%s',9223372036854775807,true)", sequence))
}
snapshot := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) {
r10LocalRows(parts)
if mode == "explicit-null" {
parts[table][0][column] = nil
}
})
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 result.State != "failed" || result.FailedAt != "" {
t.Fatalf("must reject before a business stage: %+v", result)
}
r10Unchanged(t, fx, before)
})
}
}
}
func TestR10SequenceOrderingReplayIsolated(t *testing.T) {
fx := openWriteSetFixture(t)
seedTargetData(t, fx)
r10Sequences(t, fx)
r10Exec(t, fx, `ALTER TABLE chunks ADD COLUMN chunk_index integer DEFAULT 0; ALTER TABLE knowledge_tags ADD COLUMN sort_order integer DEFAULT 0; ALTER TABLE knowledge_tags ADD COLUMN created_at timestamptz DEFAULT '2026-01-01T00:00:00Z'`)
before := universeDump(t, fx.pool)
snapshot := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) {
r10LocalRows(parts)
parts["chunks"][0]["seq_id"] = 100
parts["chunks"][0]["chunk_index"] = 0
parts["chunks"] = append(parts["chunks"], map[string]any{"id": "chunk-src-2", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "knowledge_id": "doc-src", "content": "second chunk", "seq_id": 2, "chunk_index": 1})
parts["knowledge_tags"][0]["seq_id"] = 100
parts["knowledge_tags"] = append(parts["knowledge_tags"], map[string]any{"id": "tag-src-2", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "seq_id": 2})
for _, row := range parts["knowledge_tags"] {
row["sort_order"] = 0
row["created_at"] = "2026-01-01T00:00:00Z"
}
})
target := fx.target(t)
result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil)
if result.State != "succeeded" {
t.Fatalf("normal allocation: %+v", result)
}
r10Save(t, "plan", result.Backup.WriteSet)
var newest, older int64
if e := fx.pool.QueryRow(fx.ctx, `SELECT max(id),min(id) FROM wiki_log_entries WHERE knowledge_base_id='kb-target'`).Scan(&newest, &older); e != nil {
t.Fatal(e)
}
if newest <= older {
t.Fatal("numeric log ordering collapsed")
}
var cursor int64
if e := fx.pool.QueryRow(fx.ctx, `SELECT id FROM wiki_log_entries WHERE knowledge_base_id='kb-target' AND id<$1 ORDER BY id DESC LIMIT 1`, newest).Scan(&cursor); e != nil || cursor != older {
t.Fatal("consumer cursor order", e)
}
mapped := map[string]string{}
for _, m := range result.Backup.WriteSet.LocalIDs {
if m.Table == "wiki_log_entries" {
mapped[m.Source] = m.Target
}
}
if mapped["100"] != fmt.Sprint(newest) || mapped["2"] != fmt.Sprint(older) {
t.Fatal("mapping used lexical instead of numeric order")
}
var tagOrder, chunkOrder []string
if e := fx.pool.QueryRow(fx.ctx, `SELECT array_agg(id ORDER BY sort_order ASC, created_at DESC, seq_id DESC) FROM knowledge_tags WHERE knowledge_base_id='kb-target'`).Scan(&tagOrder); e != nil {
t.Fatal(e)
}
if e := fx.pool.QueryRow(fx.ctx, `SELECT array_agg(id ORDER BY chunk_index ASC) FROM chunks WHERE knowledge_base_id='kb-target'`).Scan(&chunkOrder); e != nil {
t.Fatal(e)
}
wantTags := []string{expectedTargetID(wsTargetTenant, wsTargetKB, "knowledge_tags", "tag-src"),
expectedTargetID(wsTargetTenant, wsTargetKB, "knowledge_tags", "tag-src-2")}
wantChunks := []string{expectedTargetID(wsTargetTenant, wsTargetKB, "chunks", "chunk-src"),
expectedTargetID(wsTargetTenant, wsTargetKB, "chunks", "chunk-src-2")}
if !reflect.DeepEqual(tagOrder, wantTags) || !reflect.DeepEqual(chunkOrder, wantChunks) {
t.Fatal("application sort changed after numeric remapping", tagOrder, chunkOrder)
}
for _, m := range result.Backup.WriteSet.LocalIDs {
if m.Table == "chunks" {
var id string
if e := fx.pool.QueryRow(fx.ctx, `SELECT id FROM chunks WHERE tenant_id=$1 AND seq_id=$2::bigint`, wsTargetTenant, m.Target).Scan(&id); e != nil || (m.Source == "100" && id != expectedTargetID(wsTargetTenant, wsTargetKB, "chunks", "chunk-src")) || (m.Source == "2" && id != expectedTargetID(wsTargetTenant, wsTargetKB, "chunks", "chunk-src-2")) {
t.Fatal("seq-ID consumer disagrees with frozen map", e)
}
}
}
r10Save(t, "consumer-orders", map[string]any{"tags": tagOrder, "chunks": chunkOrder, "wiki_desc": []int64{newest, older}, "wiki_cursor": cursor})
published := r10State(t, fx)
next := fx.target(t)
if e := next.AdoptWriteSet(*result.Backup.WriteSet); e != nil {
t.Fatal(e)
}
for _, stage := range libraryrelease.Stages() {
if e := next.Apply(fx.ctx, stage, snapshot); e != nil {
t.Fatal(e)
}
}
r10Unchanged(t, fx, published)
if e := next.Restore(fx.ctx, result.Backup); e != nil {
t.Fatal(e)
}
if !reflect.DeepEqual(before, universeDump(t, fx.pool)) {
t.Fatal("rollback changed original local numbers")
}
if !reflect.DeepEqual(published["sequences"], r10State(t, fx)["sequences"]) {
t.Fatal("rollback rewound sequences")
}
}
func TestR10SourceSchemaBoundIsolated(t *testing.T) {
fx := openWriteSetFixtureWith(t, writeSetFixtureOptions{reset: true, embeddingDimension: 1024})
seedTargetData(t, fx)
r10Sequences(t, fx)
fx.indexDoc(t, "chunk-target", wsTargetTenant, wsTargetKB, "doc-target", "图:resource://"+wsHandleTarget)
before := r10State(t, fx)
pg, e := ExportLibrary(fx.ctx, fx.pool, PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB})
if e != nil {
t.Fatal(e)
}
target := fx.target(t)
es, e := target.Search().ExportLibrary(fx.ctx, SearchIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}, 100)
if e != nil {
t.Fatal(e)
}
archive, e := librarysnapshot.Open(fx.archiveRoot, 128*1024*1024)
if e != nil {
t.Fatal(e)
}
defer archive.Close()
contract := librarysnapshot.Compatibility{WeKnoraVersion: "v0.7.1", SchemaVersion: 74, RetrieverEngine: "elasticsearch_v8", EmbeddingModel: "text-embedding-v4", EmbeddingDimension: 1024, IndexMappingSHA256: es.MappingSHA256}
id, e := ArchiveLibraryCandidate(fx.ctx, archive, "internal", PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}, contract, pg, es, fx.objects, time.Now().UTC())
if e != nil {
t.Fatal(e)
}
manifest, e := archive.Load(id)
if e != nil {
t.Fatal(e)
}
r10Save(t, "manifest", manifest)
bound := false
for _, part := range manifest.Parts {
if part.Kind == "schema" && part.Name == "migration-catalog" {
bound = true
}
}
r10Unchanged(t, fx, before)
if !bound {
t.Fatal("captured source has no snapshot-bound schema catalog")
}
if _, e := target.preflightMigrationCatalog(fx.ctx, archive, manifest); e != nil {
t.Fatal("matching source schema rejected", e)
}
r10Exec(t, fx, `ALTER TABLE chunks ADD COLUMN r10_drift text`)
drifted := r10State(t, fx)
if _, e := target.preflightMigrationCatalog(fx.ctx, archive, manifest); e == nil || !strings.Contains(e.Error(), "source/target schema catalog mismatch") {
t.Fatal("source schema drift not rejected", e)
} else {
r10Save(t, "schema-drift-rejection", e.Error())
}
r10Unchanged(t, fx, drifted)
}