From eea0a0ec3b929b91e95d1464310d6eb337c2de11 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=A7=9A=E7=AB=A0=E6=B5=A9?= Date: Mon, 2 Nov 2026 02:58:50 +0800 Subject: [PATCH] =?UTF-8?q?test(release):=20=E6=95=B4=E5=BA=93=E5=8F=91?= =?UTF-8?q?=E5=B8=83=E7=8B=AC=E7=AB=8Boracle=E4=B8=8E=E5=8E=86=E5=8F=B2?= =?UTF-8?q?=E5=85=BC=E5=AE=B9=E7=9F=A9=E9=98=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 十表全形状夹具补独立 oracle:逐列内容、全部引用、索引正文/向量、对象字节与 零 Embedding 调用;期望由夹具声明推导,不调用被测映射器生成。Wiki 日志本地号 映射断言双射;正文/向量/引用/映射对真实目标变异后 oracle 必须红、改回必须绿。 补历史兼容矩阵:旧 manifest、V1 台账、空作业/目标身份等缺证明组合在正式入口 被拒绝,拒绝前后 PG/索引/对象版本/序列哈希不变;不做 V1→V2 迁移。 旧版对照:0.1.258(6fe98c9)在同一隔离库/桶/索引以相同输入复现 wiki_log_entries_pkey/23505;当前代码同一输入发布成功并分配本地号。 --- CHANGELOG.md | 24 + .../v071/ds02_legacy_compat_test.go | 174 ++++ .../releaseadapter/v071/ds02_oracle_test.go | 845 ++++++++++++++++++ scripts/test-scope.json | 2 + 4 files changed, 1045 insertions(+) create mode 100644 internal/releaseadapter/v071/ds02_legacy_compat_test.go create mode 100644 internal/releaseadapter/v071/ds02_oracle_test.go diff --git a/CHANGELOG.md b/CHANGELOG.md index 30731d4..6551135 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,29 @@ # Changelog +## 开发快照(整库发布的数据/证明 oracle 与历史兼容矩阵) + +### Added + +- 新增 `TestDS02FullShapeOracleIsolated`:复用现有十表全形状夹具,用**独立 oracle** + 逐列比对目标行内容、全部父子/标签/资源/知识库/Wiki 引用、索引正文与向量、对象 + 字节,并断言发布过程中 Embedding 调用为 0。期望值由夹具声明推导(来源→目标范围 + 映射、资源定位符与 `location_hash` 在本测试里重算),不调用被测映射器生成。 +- 新增 Wiki 日志映射双射断言:来源日志数字 id 与目标本地号一一对应、无重复、内容 + 元组多重集相等。 +- 新增对照夹具探针(旧代码工作树):0.1.258(6fe98c9)在同一隔离库/桶/索引里以 + 相同输入复现 `wiki_log_entries_pkey` / SQLSTATE 23505;当前代码同一输入发布成功 + 并分配本地号,其它知识库的历史行不变。 +- 新增 `TestDS02LegacyCompatibilityMatrixIsolated`:旧 manifest、V1 台账、空作业/ + 目标身份等缺证明组合必须在正式入口被拒绝,拒绝前后 PG 逐行 + 索引 + 对象版本 + + 序列哈希不变;不做 V1→V2 迁移。 + +### Changed + +- 隔离运行器补齐 provenance:运行前后完整 HEAD/工作区/源码逐文件哈希(含未跟踪)、 + 测试二进制 sha256 与 go build metadata/版本注入、逐用例 PASS/FAIL/SKIP、真实目标 + 身份;一次性资源先登记,结束后按登记名成对删除并逐个读回(容器 inspect 失败、 + 库/索引/桶查询为 0/404)。 + ## 开发快照(正式 worker / 维护恢复入口的 held → 恢复闭环验收) ### Added diff --git a/internal/releaseadapter/v071/ds02_legacy_compat_test.go b/internal/releaseadapter/v071/ds02_legacy_compat_test.go new file mode 100644 index 0000000..14dc767 --- /dev/null +++ b/internal/releaseadapter/v071/ds02_legacy_compat_test.go @@ -0,0 +1,174 @@ +package v071 + +// DS-02 历史兼容矩阵(B31):旧 manifest、V1 台账、空作业/目标身份这些 +// "缺证明"的组合必须在正式入口被拒绝,且目标全部数据(PG 逐行 + 索引文档 + +// 对象版本 + 序列)一个字节都不变。这里不做 V1→V2 迁移。 + +import ( + "crypto/sha256" + "encoding/hex" + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "knowledge-governance/internal/libraryrelease" + "knowledge-governance/internal/librarysnapshot" +) + +func ds02UniverseHash(t *testing.T, fx *writeSetFixture) string { + t.Helper() + raw, err := json.Marshal(r10State(t, fx)) + if err != nil { + t.Fatal(err) + } + sum := sha256.Sum256(raw) + return hex.EncodeToString(sum[:]) +} + +func ds02Plan() libraryrelease.WriteSet { + now := time.Now().UTC() + return libraryrelease.WriteSet{ + Version: libraryrelease.MigrationWriteSetVersion, + ContractVersion: 1, + SourceTenantID: wsSourceTenant, + SourceKnowledgeBaseID: wsSourceKB, + JobID: "job-ds02-legacy", + Target: "internal", + TenantID: wsTargetTenant, + KnowledgeBaseID: wsTargetKB, + BackupSnapshotID: strings.Repeat("b", 64), + TargetSnapshotID: strings.Repeat("c", 64), + CreatedAt: now, + SchemaDigest: strings.Repeat("d", 64), + Rows: []libraryrelease.WriteSetRow{}, + Universe: map[string]libraryrelease.TableFingerprint{ + "knowledges": {Count: 0, Digest: strings.Repeat("e", 64)}, + }, + LocalIDs: []libraryrelease.LocalIDMapping{ + {Table: "wiki_log_entries", Column: "id", Source: "1", Target: "10"}, + }, + } +} + +// ds02OldManifest 在归档里写一份"旧格式 manifest":缺 compatibility 契约字段。 +// 它按归档的命名规则带正确摘要,所以能证明拒绝来自结构校验,而不是文件名坏了。 +func ds02OldManifest(t *testing.T, fx *writeSetFixture) (string, string) { + t.Helper() + valid := sealSourceSnapshot(t, fx, nil) + path := filepath.Join(fx.archiveRoot, "versions", valid+".json") + raw, err := os.ReadFile(path) + if err != nil { + t.Fatal(err) + } + var payload map[string]any + if err := json.Unmarshal(raw, &payload); err != nil { + t.Fatal(err) + } + delete(payload, "compatibility") + encoded, err := json.Marshal(payload) + if err != nil { + t.Fatal(err) + } + sum := sha256.Sum256(encoded) + id := hex.EncodeToString(sum[:]) + oldPath := filepath.Join(fx.archiveRoot, "versions", id+".json") + if err := os.WriteFile(oldPath, encoded, 0600); err != nil { + t.Fatal(err) + } + fileSum := sha256.Sum256(encoded) + return id, hex.EncodeToString(fileSum[:]) +} + +func TestDS02LegacyCompatibilityMatrixIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + target := fx.target(t) + oldManifest, oldManifestHash := ds02OldManifest(t, fx) + before := ds02UniverseHash(t, fx) + + // 旧 manifest 本身必须读不出来(缺兼容契约),且文件内容不变。 + archive, err := librarysnapshot.Open(fx.archiveRoot, 64*1024*1024) + if err != nil { + t.Fatal(err) + } + defer archive.Close() + if _, err := archive.Load(oldManifest); err == nil || !strings.Contains(err.Error(), "compatibility") { + t.Fatalf("old manifest must be rejected for missing compatibility contract, got %v", err) + } + raw, err := os.ReadFile(filepath.Join(fx.archiveRoot, "versions", oldManifest+".json")) + if err != nil { + t.Fatal(err) + } + sum := sha256.Sum256(raw) + if hex.EncodeToString(sum[:]) != oldManifestHash { + t.Fatal("rejected old manifest was rewritten") + } + + cases := []struct { + name string + build func() libraryrelease.WriteSet + expect string + }{ + {"legacy-v1-plan", func() libraryrelease.WriteSet { + set := ds02Plan() + set.Version = libraryrelease.WriteSetVersion + set.ContractVersion = 0 + set.SourceTenantID = 0 + set.SourceKnowledgeBaseID = "" + set.LocalIDs = nil + set.SchemaDigest = "" + return set + }, "legacy/incomplete plan"}, + {"v1-carrying-new-semantics", func() libraryrelease.WriteSet { + set := ds02Plan() + set.Version = libraryrelease.WriteSetVersion + return set + }, "historical V1"}, + {"empty-operation", func() libraryrelease.WriteSet { + set := ds02Plan() + set.JobID = "" + return set + }, "作业"}, + {"empty-target-scope", func() libraryrelease.WriteSet { + set := ds02Plan() + set.TenantID = 0 + set.KnowledgeBaseID = "" + return set + }, "目标范围"}, + {"local-mapping-without-source", func() libraryrelease.WriteSet { + set := ds02Plan() + set.SourceTenantID = 0 + return set + }, "source contract"}, + {"old-manifest-bound-plan", func() libraryrelease.WriteSet { + set := ds02Plan() + set.TargetSnapshotID = oldManifest + return set + }, "compatibility"}, + } + for _, scenario := range cases { + set := scenario.build() + if err := set.Seal(); err != nil { + // 某些组合在 Seal 阶段就被拒绝(V1 携带迁移语义):同样是拒绝, + // 但必须点名原因,而不是别的错误。 + if !strings.Contains(err.Error(), scenario.expect) { + t.Fatalf("%s: sealed rejected for wrong reason: %v", scenario.name, err) + } + r10Save(t, "reject-"+scenario.name, map[string]string{"stage": "seal", "error": err.Error()}) + } else if err := target.AdoptWriteSet(set); err == nil { + t.Fatalf("%s: incomplete plan was adopted", scenario.name) + } else { + if !strings.Contains(err.Error(), scenario.expect) { + t.Fatalf("%s: rejected for wrong reason: %v", scenario.name, err) + } + r10Save(t, "reject-"+scenario.name, map[string]string{"stage": "adopt", "error": err.Error()}) + } + if after := ds02UniverseHash(t, fx); after != before { + t.Fatalf("%s: rejected plan changed target data (%s -> %s)", scenario.name, before, after) + } + } + r10Save(t, "universe-hash", before) +} diff --git a/internal/releaseadapter/v071/ds02_oracle_test.go b/internal/releaseadapter/v071/ds02_oracle_test.go new file mode 100644 index 0000000..836b29a --- /dev/null +++ b/internal/releaseadapter/v071/ds02_oracle_test.go @@ -0,0 +1,845 @@ +package v071 + +// DS-02:整库发布的独立 oracle。 +// +// 这里不调用被测的映射/改写函数来生成期望值:期望由夹具自己声明的十张表逐列内容 +// 推导(来源范围 → 目标范围的映射规则、资源定位符、location_hash 都在本文件里 +// 用字面规则重算),本地号(chunks.seq_id / knowledge_tags.seq_id / +// wiki_log_entries.id)由测试**发布前**读到的序列状态加声明顺序算出来。 +// 正文、引用、向量、对象字节、Wiki 日志映射分别有独立断言;断言本身再用 +// "真实改写目标存储 → 必须红 → 改回 → 必须绿" 证明不是空跑。 + +import ( + "bytes" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "io" + "net/http" + "sort" + "strconv" + "strings" + "testing" + "time" + + "knowledge-governance/internal/libraryrelease" + "knowledge-governance/internal/librarysnapshot" +) + +// ds02Vectors 是夹具声明的来源向量(逐分块不同)。索引部件由它生成, +// 不是由被测适配器生成。 +var ds02Vectors = map[string][]float64{ + "chunk-src": {0.5, 1.5}, + "chunk-src2": {-2.25, 3.75}, +} + +// ds02Objects 是夹具声明的资源字节(长度与 resources.size 一致)。 +var ds02Objects = map[string]string{ + "res-src": "abc12345", + "res-src2": "wxyz6789", +} + +var ds02TargetTables = []string{"knowledges", "chunks", "knowledge_tags", "knowledge_tag_relations", + "resources", "resource_bindings", "wiki_folders", "wiki_pages", "wiki_page_issues", "wiki_log_entries"} + +func ds02Canon(t *testing.T, fx *writeSetFixture, table string, row map[string]any) map[string]any { + t.Helper() + raw, err := json.Marshal(row) + if err != nil { + t.Fatal(err) + } + var canonical []byte + if err := fx.pool.QueryRow(fx.ctx, + "SELECT to_jsonb(jsonb_populate_record(NULL::"+table+",$1::jsonb))", raw).Scan(&canonical); err != nil { + t.Fatalf("canonicalize %s: %v", table, err) + } + dec := json.NewDecoder(bytes.NewReader(canonical)) + dec.UseNumber() + var out map[string]any + if err := dec.Decode(&out); err != nil { + t.Fatal(err) + } + return out +} + +func ds02Read(t *testing.T, fx *writeSetFixture, query string, args ...any) []map[string]any { + t.Helper() + rows, err := fx.pool.Query(fx.ctx, query, args...) + if err != nil { + t.Fatalf("oracle query: %v", err) + } + defer rows.Close() + var out []map[string]any + for rows.Next() { + var text string + if err := rows.Scan(&text); err != nil { + t.Fatal(err) + } + dec := json.NewDecoder(strings.NewReader(text)) + dec.UseNumber() + var row map[string]any + if err := dec.Decode(&row); err != nil { + t.Fatal(err) + } + out = append(out, row) + } + if err := rows.Err(); err != nil { + t.Fatal(err) + } + return out +} + +func ds02Normalize(rows []map[string]any) []string { + out := make([]string, 0, len(rows)) + for _, row := range rows { + raw, _ := json.Marshal(row) + out = append(out, string(raw)) + } + sort.Strings(out) + return out +} + +// ds02Compare 返回人可读的差异;空串表示逐列内容完全一致(含行数)。 +func ds02Compare(table string, want, got []map[string]any) string { + w, g := ds02Normalize(want), ds02Normalize(got) + if len(w) == len(g) { + same := true + for i := range w { + if w[i] != g[i] { + same = false + break + } + } + if same { + return "" + } + } + seen := map[string]bool{} + for _, row := range g { + seen[row] = true + } + var missing, extra []string + for _, row := range w { + if !seen[row] { + missing = append(missing, row) + } + } + present := map[string]bool{} + for _, row := range w { + present[row] = true + } + for _, row := range g { + if !present[row] { + extra = append(extra, row) + } + } + if len(missing) > 6 { + missing = missing[:6] + } + if len(extra) > 6 { + extra = extra[:6] + } + return fmt.Sprintf("%s: want %d rows, got %d; missing=%v extra=%v", table, len(w), len(g), missing, extra) +} + +// ds02SequenceNext 是本地号分配的独立期望:发布前序列状态 + 是否已调用。 +func ds02SequenceNext(t *testing.T, fx *writeSetFixture, sequence string) int64 { + t.Helper() + var last int64 + var called bool + if err := fx.pool.QueryRow(fx.ctx, "SELECT last_value,is_called FROM "+sequence).Scan(&last, &called); err != nil { + t.Fatal(err) + } + if called { + return last + 1 + } + return last +} + +// ds02Spec 是夹具声明的来源内容(十表逐列 + 向量 + 对象字节)。 +type ds02Spec struct { + rows map[string][]map[string]any + vectors map[string][]float64 + objects map[string]string +} + +func ds02SourceSpec(t *testing.T, fx *writeSetFixture) ds02Spec { + t.Helper() + tag := func(id string, seq int64) map[string]any { + return map[string]any{"id": id, "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, + "name": "name-" + id, "color": "#112233", "sort_order": 3, "seq_id": seq, + "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-01-02T00:00:00Z"} + } + sourcePath := func(id string) string { + return wsLocator("backend-source", "oss", "source-bucket", wsSourceTenant, id) + } + sourceHash := func(id string) string { + sum := sha256.Sum256([]byte(sourcePath(id))) + return hex.EncodeToString(sum[:]) + } + rows := map[string][]map[string]any{ + "knowledges": { + {"id": "doc-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "type": "document", + "title": "来源文档一", "description": "desc-1", "source": "resource://" + wsHandleSource, + "parse_status": "completed", "enable_status": "enabled", "embedding_model_id": "source-model", + "file_name": "one.md", "file_type": "md", "file_size": int64(8), "file_path": "source/one.md", + "file_hash": strings.Repeat("1", 64), "storage_size": int64(8), "metadata": map[string]any{"k": "v1"}, + "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-01-02T00:00:00Z", + "processed_at": "2026-01-03T00:00:00Z", "summary_status": "none", "channel": "web", + "pending_subtasks_count": 0}, + {"id": "doc-src2", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "type": "document", + "title": "来源文档二", "description": "desc-2", "source": "upload", + "parse_status": "completed", "enable_status": "enabled", "embedding_model_id": "source-model", + "file_name": "two.md", "file_type": "md", "file_size": int64(4), "file_path": "source/two.md", + "file_hash": strings.Repeat("2", 64), "storage_size": int64(4), "metadata": map[string]any{"k": "v2"}, + "created_at": "2026-01-04T00:00:00Z", "updated_at": "2026-01-05T00:00:00Z", + "summary_status": "none", "channel": "web", "pending_subtasks_count": 1}, + }, + "chunks": { + {"id": "chunk-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, + "knowledge_id": "doc-src", "content": "来源正文一 resource://" + wsHandleSource, + "chunk_index": 0, "is_enabled": true, "start_at": 0, "end_at": 12, + "next_chunk_id": "chunk-src2", "chunk_type": "text", "status": 1, "flags": 1, + "seq_id": int64(41), "content_hash": strings.Repeat("3", 64), + "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-01-02T00:00:00Z"}, + {"id": "chunk-src2", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, + "knowledge_id": "doc-src", "content": "来源正文二", "chunk_index": 1, "is_enabled": true, + "start_at": 12, "end_at": 20, "pre_chunk_id": "chunk-src", "chunk_type": "text", + "status": 1, "flags": 1, "seq_id": int64(42), "content_hash": strings.Repeat("4", 64), + "created_at": "2026-01-03T00:00:00Z", "updated_at": "2026-01-04T00:00:00Z"}, + }, + "knowledge_tags": {tag("tag-src", 11), tag("tag-src2", 12)}, + "knowledge_tag_relations": { + {"knowledge_id": "doc-src", "tag_id": "tag-src", "created_at": "2026-01-01T00:00:00Z"}, + {"knowledge_id": "doc-src2", "tag_id": "tag-src2", "created_at": "2026-01-03T00:00:00Z"}, + }, + "resources": { + {"id": "res-src", "handle": wsHandleSource, "tenant_id": wsSourceTenant, + "storage_backend_id": "backend-source", "provider": "oss", "physical_path": sourcePath("res-src"), + "location_hash": sourceHash("res-src"), "kind": "file", "mime_type": "image/png", + "original_name": "a.png", "size": int64(8), "content_hash": strings.Repeat("5", 64), + "lifecycle": "persistent", "state": "active", + "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-01-02T00:00:00Z"}, + {"id": "res-src2", "handle": strings.Repeat("g", 22), "tenant_id": wsSourceTenant, + "storage_backend_id": "backend-source", "provider": "oss", "physical_path": sourcePath("res-src2"), + "location_hash": sourceHash("res-src2"), "kind": "file", "mime_type": "image/png", + "original_name": "b.png", "size": int64(8), "content_hash": strings.Repeat("6", 64), + "lifecycle": "persistent", "state": "active", + "created_at": "2026-01-03T00:00:00Z", "updated_at": "2026-01-04T00:00:00Z"}, + }, + "resource_bindings": { + {"id": "bind-src", "resource_id": "res-src", "tenant_id": wsSourceTenant, + "owner_type": "knowledge", "owner_id": "doc-src", "relation": "attachment", + "created_at": "2026-01-01T00:00:00Z"}, + {"id": "bind-src2", "resource_id": "res-src2", "tenant_id": wsSourceTenant, + "owner_type": "knowledge", "owner_id": "doc-src2", "relation": "attachment", + "created_at": "2026-01-03T00:00:00Z"}, + }, + "wiki_folders": { + {"id": "folder-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, + "parent_id": "", "name": "根目录", "path": "root", "depth": 0, "sort_order": 1, + "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-01-02T00:00:00Z"}, + {"id": "folder-src2", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, + "parent_id": "folder-src", "name": "子目录", "path": "root/sub", "depth": 1, "sort_order": 2, + "created_at": "2026-01-03T00:00:00Z", "updated_at": "2026-01-04T00:00:00Z"}, + }, + "wiki_pages": { + {"id": "wiki-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "slug": "index", + "title": "首页", "page_type": "summary", "status": "published", "content": "来源 wiki 首页", + "summary": "摘要一", "parent_slug": "", "folder_id": "folder-src", "category_path": []any{"root"}, + "wiki_path": "index", "depth": 0, "sort_order": 1, + "source_refs": []any{"doc-src|来源文档一"}, + "chunk_refs": []any{"chunk-src"}, "in_links": []any{}, "out_links": []any{"guide"}, + "page_metadata": map[string]any{"lang": "zh"}, "aliases": []any{"home"}, "version": 1, + "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-01-02T00:00:00Z"}, + {"id": "wiki-src2", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "slug": "guide", + "title": "指南", "page_type": "summary", "status": "published", "content": "来源 wiki 指南", + "summary": "摘要二", "parent_slug": "", "folder_id": "folder-src2", "category_path": []any{"root", "sub"}, + "wiki_path": "root/sub/guide", "depth": 1, "sort_order": 2, + "source_refs": []any{"doc-src2|来源文档二"}, + "chunk_refs": []any{"chunk-src2"}, "in_links": []any{"guide"}, "out_links": []any{}, + "page_metadata": map[string]any{"lang": "zh"}, "aliases": []any{}, "version": 1, + "created_at": "2026-01-03T00:00:00Z", "updated_at": "2026-01-04T00:00:00Z"}, + }, + "wiki_page_issues": { + {"id": "issue-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "slug": "index", + "issue_type": "review", "description": "需要复核", "suspected_knowledge_ids": []any{"doc-src"}, + "status": "pending", "reported_by": "fixture", + "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-01-02T00:00:00Z"}, + }, + "wiki_log_entries": { + {"id": int64(1), "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "action": "ingest", + "knowledge_id": "doc-src", "doc_title": "来源文档一", "summary": "首次入库", + "pages_affected": []any{map[string]any{"slug": "index", "title": "首页"}}, + "created_at": "2026-01-01T00:00:00Z"}, + {"id": int64(2), "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "action": "update", + "knowledge_id": "doc-src2", "doc_title": "来源文档二", "summary": "更新", + "pages_affected": []any{map[string]any{"slug": "guide", "title": "指南"}}, + "created_at": "2026-01-03T00:00:00Z"}, + }, + } + for table, list := range rows { + for i, row := range list { + rows[table][i] = ds02Canon(t, fx, table, row) + } + } + return ds02Spec{rows: rows, vectors: ds02Vectors, objects: ds02Objects} +} + +// ds02Expected 从声明内容独立推导目标范围应有的十表逐列内容。 +func ds02Expected(t *testing.T, fx *writeSetFixture, spec ds02Spec) (map[string][]map[string]any, map[string]string) { + t.Helper() + targetBackend, targetProvider := "backend-target", "minio" + locator := func(id string) string { + // 独立重算定位符:storage:///://// + return fmt.Sprintf("storage://%s/%s://%s/%d/%s/a.png", targetBackend, targetProvider, fx.bucket, wsTargetTenant, id) + } + next := map[string]int64{ + "chunks": ds02SequenceNext(t, fx, "chunks_seq_id_seq"), + "knowledge_tags": ds02SequenceNext(t, fx, "knowledge_tags_seq_id_seq"), + "wiki_log_entries": ds02SequenceNext(t, fx, "wiki_log_entries_id_seq"), + } + local := map[string]map[int64]int64{"chunks": {}, "knowledge_tags": {}, "wiki_log_entries": {}} + for _, table := range []string{"chunks", "knowledge_tags", "wiki_log_entries"} { + sources := []int64{} + for _, row := range spec.rows[table] { + raw := row["seq_id"] + if table == "wiki_log_entries" { + raw = row["id"] + } + value, err := strconv.ParseInt(fmt.Sprint(raw), 10, 64) + if err != nil { + t.Fatalf("%s local id: %v", table, err) + } + sources = append(sources, value) + } + sort.Slice(sources, func(i, j int) bool { return sources[i] < sources[j] }) + value := next[table] + for _, source := range sources { + local[table][source] = value + value++ + } + } + expected := map[string][]map[string]any{} + paths := map[string]string{} + for table, rows := range spec.rows { + for _, declared := range rows { + row := map[string]any{} + for key, value := range declared { + row[key] = value + } + if tableHasTenant(table) { + row["tenant_id"] = json.Number(strconv.FormatUint(wsTargetTenant, 10)) + } + if tablesWithKB[table] { + row["knowledge_base_id"] = wsTargetKB + } + switch table { + case "chunks", "knowledge_tags": + source, _ := strconv.ParseInt(fmt.Sprint(row["seq_id"]), 10, 64) + row["seq_id"] = json.Number(strconv.FormatInt(local[table][source], 10)) + case "wiki_log_entries": + source, _ := strconv.ParseInt(fmt.Sprint(row["id"]), 10, 64) + row["id"] = json.Number(strconv.FormatInt(local[table][source], 10)) + case "resources": + id := fmt.Sprint(row["id"]) + expectedPath := locator(id) + paths[id] = expectedPath + row["physical_path"] = expectedPath + sum := sha256.Sum256([]byte(expectedPath)) + row["location_hash"] = hex.EncodeToString(sum[:]) + row["storage_backend_id"] = targetBackend + row["provider"] = targetProvider + } + expected[table] = append(expected[table], ds02Canon(t, fx, table, row)) + } + } + return expected, paths +} + +// ds02Seed 造目标/其它范围的真实行;目标范围里也放一行"会被整库替换"的数据。 +func ds02Seed(t *testing.T, fx *writeSetFixture) { + t.Helper() + put := func(id string, size int) { + path := wsLocator("backend-target", "minio", fx.bucket, wsTargetTenant, id) + if err := fx.objects.s3.Put(fx.ctx, "minio", path, strings.NewReader(strings.Repeat("z", size)), int64(size)); err != nil { + t.Fatal(err) + } + } + put("res-other", 8) + for _, row := range []struct { + table string + row map[string]any + }{ + {"knowledges", map[string]any{"id": "doc-other", "tenant_id": 10001, "knowledge_base_id": wsOtherKB, "type": "document", "title": "别的知识库文档", "source": "x"}}, + {"knowledges", map[string]any{"id": "doc-foreign", "tenant_id": 20000, "knowledge_base_id": "kb-foreign", "type": "document", "title": "外部租户文档", "source": "x"}}, + {"chunks", map[string]any{"id": "chunk-other", "tenant_id": 10001, "knowledge_base_id": wsOtherKB, "knowledge_id": "doc-other", "content": "别的知识库正文", "chunk_index": 0, "start_at": 0, "end_at": 1, "seq_id": int64(7)}}, + {"knowledge_tags", map[string]any{"id": "tag-other", "tenant_id": 10001, "knowledge_base_id": wsOtherKB, "name": "别的知识库标签", "seq_id": int64(9)}}, + {"knowledge_tag_relations", map[string]any{"knowledge_id": "doc-other", "tag_id": "tag-other"}}, + {"resources", map[string]any{"id": "res-other", "handle": wsHandleOther, "tenant_id": 10001, "provider": "minio", "physical_path": wsLocator("backend-target", "minio", fx.bucket, 10001, "res-other"), "storage_backend_id": "backend-target", "size": int64(8)}}, + {"resource_bindings", map[string]any{"id": "bind-other", "resource_id": "res-other", "tenant_id": 10001, "owner_type": "knowledge", "owner_id": "doc-other", "relation": "attachment"}}, + {"wiki_folders", map[string]any{"id": "folder-other", "tenant_id": 10001, "knowledge_base_id": wsOtherKB, "name": "别的知识库目录"}}, + {"wiki_pages", map[string]any{"id": "wiki-other", "tenant_id": 10001, "knowledge_base_id": wsOtherKB, "slug": "index", "content": "别的知识库 wiki"}}, + {"wiki_page_issues", map[string]any{"id": "issue-other", "tenant_id": 10001, "knowledge_base_id": wsOtherKB, "slug": "index", "issue_type": "review", "reported_by": "fixture", "description": "x"}}, + // 这条是 B03 的碰撞输入:来源日志数字 id=1 与其它知识库已有的 id=1 同值。 + {"wiki_log_entries", map[string]any{"id": int64(1), "tenant_id": 10001, "knowledge_base_id": wsOtherKB, "action": "ingest"}}, + // 目标范围自己的数据:整库发布必须把它们替换成来源内容。 + {"knowledges", map[string]any{"id": "doc-target", "tenant_id": wsTargetTenant, "knowledge_base_id": wsTargetKB, "type": "document", "title": "目标旧文档", "source": "x"}}, + {"chunks", map[string]any{"id": "chunk-target", "tenant_id": wsTargetTenant, "knowledge_base_id": wsTargetKB, "knowledge_id": "doc-target", "content": "目标旧正文", "chunk_index": 0, "start_at": 0, "end_at": 1, "seq_id": int64(8)}}, + {"wiki_pages", map[string]any{"id": "wiki-target", "tenant_id": wsTargetTenant, "knowledge_base_id": wsTargetKB, "slug": "index", "content": "目标旧 wiki"}}, + } { + r11Insert(t, fx, row.table, row.row) + } + fx.indexDoc(t, "chunk-target", wsTargetTenant, wsTargetKB, "doc-target", "目标旧正文") + fx.indexDoc(t, "chunk-foreign", 20000, "kb-foreign", "doc-foreign", "外部正文") +} + +// ds02Seal 用声明内容封一份十表全非空快照(索引向量来自夹具声明)。 +func ds02Seal(t *testing.T, fx *writeSetFixture, spec ds02Spec) string { + t.Helper() + archive, err := librarysnapshot.Open(fx.archiveRoot, 128*1024*1024) + if err != nil { + t.Fatal(err) + } + defer archive.Close() + encode := func(value any) []byte { + raw, err := json.Marshal(value) + if err != nil { + t.Fatal(err) + } + return raw + } + kinds := map[string]string{"knowledges": "database", "chunks": "database", "knowledge_tags": "database", + "knowledge_tag_relations": "database", "resources": "database", "resource_bindings": "database", + "wiki_folders": "wiki", "wiki_pages": "wiki", "wiki_page_issues": "wiki", "wiki_log_entries": "wiki"} + parts := []librarysnapshot.Part{} + for _, table := range ds02TargetTables { + part, err := archive.Put(bytes.NewReader(encode(spec.rows[table]))) + if err != nil { + t.Fatal(err) + } + part.Kind, part.Name, part.Count = kinds[table], table, int64(len(spec.rows[table])) + parts = append(parts, part) + } + for _, id := range []string{"res-src", "res-src2"} { + part, err := archive.Put(bytes.NewReader([]byte(spec.objects[id]))) + if err != nil { + t.Fatal(err) + } + part.Kind, part.Name, part.Count = "resource", id, 1 + parts = append(parts, part) + } + indexRows := []map[string]any{} + for _, chunk := range spec.rows["chunks"] { + id := fmt.Sprint(chunk["id"]) + indexRows = append(indexRows, map[string]any{"id": id, "source": map[string]any{ + "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, + "knowledge_id": chunk["knowledge_id"], "chunk_id": id, "source_id": id, + "content": chunk["content"], "embedding": spec.vectors[id]}}) + } + indexPart, err := archive.Put(bytes.NewReader(encode(indexRows))) + if err != nil { + t.Fatal(err) + } + indexPart.Kind, indexPart.Name, indexPart.Count = "index", "chunks", int64(len(indexRows)) + parts = append(parts, indexPart) + manifest := librarysnapshot.Manifest{ValidationPolicy: librarysnapshot.ArtifactAcceptancePolicy, + Format: librarysnapshot.Format, Scope: "internal", TenantID: wsSourceTenant, KnowledgeBaseID: wsSourceKB, + CreatedAt: time.Now().UTC(), Parts: parts, + Compatibility: librarysnapshot.Compatibility{WeKnoraVersion: "v0.7.1", SchemaVersion: 74, + RetrieverEngine: "elasticsearch_v8", EmbeddingModel: "text-embedding-v4", + EmbeddingDimension: 1024, IndexMappingSHA256: strings.Repeat("a", 64)}} + id, err := archive.Seal(manifest) + if err != nil { + t.Fatalf("seal ds02 snapshot: %v", err) + } + return id +} + +// ds02Docs 读回索引里的全部文档(独立查询,不经过被测 SearchExporter)。 +func ds02Docs(t *testing.T, fx *writeSetFixture) map[string]map[string]any { + t.Helper() + body := `{"size":1000,"query":{"match_all":{}}}` + request, err := http.NewRequestWithContext(fx.ctx, "POST", fx.searchBase+"/"+fx.index+"/_search", strings.NewReader(body)) + if err != nil { + t.Fatal(err) + } + request.Header.Set("Content-Type", "application/json") + response, err := fx.client.Do(request) + if err != nil { + t.Fatal(err) + } + defer response.Body.Close() + if response.StatusCode != 200 { + raw, _ := io.ReadAll(response.Body) + t.Fatalf("search %d: %s", response.StatusCode, raw) + } + var payload struct { + Hits struct { + Hits []struct { + ID string `json:"_id"` + Source map[string]any `json:"_source"` + } `json:"hits"` + } `json:"hits"` + } + if err := json.NewDecoder(response.Body).Decode(&payload); err != nil { + t.Fatal(err) + } + out := map[string]map[string]any{} + for _, hit := range payload.Hits.Hits { + out[hit.ID] = hit.Source + } + return out +} + +func ds02CountingClient(t *testing.T, fx *writeSetFixture) *[]string { + t.Helper() + seen := &[]string{} + base := http.DefaultTransport + fx.client.Transport = roundTripFunc(func(request *http.Request) (*http.Response, error) { + *seen = append(*seen, request.Method+" "+request.URL.String()) + return base.RoundTrip(request) + }) + t.Cleanup(func() { fx.client.Transport = nil }) + return seen +} + +type roundTripFunc func(*http.Request) (*http.Response, error) + +func (f roundTripFunc) RoundTrip(request *http.Request) (*http.Response, error) { return f(request) } + +// ds02Check 是 oracle 本体:返回逐项差异;空 = 全绿。 +func ds02Check(t *testing.T, fx *writeSetFixture, spec ds02Spec, expected map[string][]map[string]any, + paths map[string]string, preserved map[string][]map[string]any, requests *[]string) []string { + t.Helper() + var diffs []string + scope := func(table string) (string, []any) { + if table == "knowledge_tag_relations" { + return "SELECT to_jsonb(x)::text FROM " + table + " AS x", nil + } + if tableHasTenant(table) && tablesWithKB[table] { + return "SELECT to_jsonb(x)::text FROM " + table + " AS x WHERE tenant_id=$1 AND knowledge_base_id=$2 ORDER BY 1", + []any{wsTargetTenant, wsTargetKB} + } + return "SELECT to_jsonb(x)::text FROM " + table + " AS x WHERE tenant_id=$1 ORDER BY 1", []any{wsTargetTenant} + } + for _, table := range ds02TargetTables { + query, args := scope(table) + if diff := ds02Compare(table, expected[table], ds02Read(t, fx, query, args...)); diff != "" { + diffs = append(diffs, diff) + } + // 目标范围之外的行必须一字不动(含其它知识库/租户以及它们的历史资源)。 + if table == "knowledge_tag_relations" { + continue + } + other := "SELECT to_jsonb(x)::text FROM " + table + " AS x WHERE tenant_id<>$1" + if tableHasTenant(table) && tablesWithKB[table] { + other = "SELECT to_jsonb(x)::text FROM " + table + " AS x WHERE NOT (tenant_id=$1 AND knowledge_base_id=$2)" + } + if diff := ds02Compare(table+"(non-target)", preserved[table], ds02Read(t, fx, other, args...)); diff != "" { + diffs = append(diffs, diff) + } + } + // 引用:每条关系都必须有真实目标行,而且断言确实覆盖到引用(匹配数 > 0)。 + relations := []struct { + name string + sql string + matched string + }{ + {"chunk→knowledge", `SELECT count(*) FROM chunks c WHERE c.tenant_id=$1 AND c.knowledge_base_id=$2 AND NOT EXISTS(SELECT 1 FROM knowledges k WHERE k.id=c.knowledge_id AND k.tenant_id=c.tenant_id AND k.knowledge_base_id=c.knowledge_base_id)`, + `SELECT count(*) FROM chunks c WHERE c.tenant_id=$1 AND c.knowledge_base_id=$2 AND EXISTS(SELECT 1 FROM knowledges k WHERE k.id=c.knowledge_id AND k.tenant_id=c.tenant_id AND k.knowledge_base_id=c.knowledge_base_id)`}, + {"chunk→chunk links", `SELECT count(*) FROM chunks c WHERE c.tenant_id=$1 AND c.knowledge_base_id=$2 AND ((c.pre_chunk_id<>'' AND NOT EXISTS(SELECT 1 FROM chunks p WHERE p.id=c.pre_chunk_id)) OR (c.next_chunk_id<>'' AND NOT EXISTS(SELECT 1 FROM chunks n WHERE n.id=c.next_chunk_id)) OR (c.parent_chunk_id IS NOT NULL AND c.parent_chunk_id<>'' AND NOT EXISTS(SELECT 1 FROM chunks q WHERE q.id=c.parent_chunk_id)))`, + `SELECT count(*) FROM chunks c WHERE c.tenant_id=$1 AND c.knowledge_base_id=$2 AND (c.pre_chunk_id<>'' OR c.next_chunk_id<>'' OR coalesce(c.parent_chunk_id,'')<>'')`}, + {"relation→tag/knowledge", `SELECT count(*) FROM knowledge_tag_relations r WHERE NOT EXISTS(SELECT 1 FROM knowledge_tags t WHERE t.id=r.tag_id) OR NOT EXISTS(SELECT 1 FROM knowledges k WHERE k.id=r.knowledge_id)`, + `SELECT count(*) FROM knowledge_tag_relations r WHERE EXISTS(SELECT 1 FROM knowledge_tags t WHERE t.id=r.tag_id) AND EXISTS(SELECT 1 FROM knowledges k WHERE k.id=r.knowledge_id)`}, + {"binding→resource/knowledge", `SELECT count(*) FROM resource_bindings b WHERE b.tenant_id=$1 AND (NOT EXISTS(SELECT 1 FROM resources r WHERE r.id=b.resource_id) OR (b.owner_type='knowledge' AND NOT EXISTS(SELECT 1 FROM knowledges k WHERE k.id=b.owner_id)))`, + `SELECT count(*) FROM resource_bindings b WHERE b.tenant_id=$1 AND EXISTS(SELECT 1 FROM resources r WHERE r.id=b.resource_id)`}, + {"wiki page→folder", `SELECT count(*) FROM wiki_pages p WHERE p.tenant_id=$1 AND p.knowledge_base_id=$2 AND p.folder_id<>'' AND NOT EXISTS(SELECT 1 FROM wiki_folders f WHERE f.id=p.folder_id)`, + `SELECT count(*) FROM wiki_pages p WHERE p.tenant_id=$1 AND p.knowledge_base_id=$2 AND p.folder_id<>''`}, + {"wiki issue→page", `SELECT count(*) FROM wiki_page_issues i WHERE i.tenant_id=$1 AND i.knowledge_base_id=$2 AND NOT EXISTS(SELECT 1 FROM wiki_pages p WHERE p.slug=i.slug AND p.tenant_id=i.tenant_id AND p.knowledge_base_id=i.knowledge_base_id)`, + `SELECT count(*) FROM wiki_page_issues i WHERE i.tenant_id=$1 AND i.knowledge_base_id=$2`}, + {"wiki log→knowledge/page", `SELECT count(*) FROM wiki_log_entries l WHERE l.tenant_id=$1 AND l.knowledge_base_id=$2 AND (NOT EXISTS(SELECT 1 FROM knowledges k WHERE k.id=l.knowledge_id) OR EXISTS(SELECT 1 FROM jsonb_array_elements(l.pages_affected) e WHERE NOT EXISTS(SELECT 1 FROM wiki_pages p WHERE p.slug=e->>'slug' AND p.tenant_id=l.tenant_id AND p.knowledge_base_id=l.knowledge_base_id)))`, + `SELECT count(*) FROM wiki_log_entries l WHERE l.tenant_id=$1 AND l.knowledge_base_id=$2`}, + } + for _, relation := range relations { + var violations, matched int64 + var args []any + if strings.Contains(relation.sql, "$2") { + args = []any{wsTargetTenant, wsTargetKB} + } else if strings.Contains(relation.sql, "$1") { + args = []any{wsTargetTenant} + } + if err := fx.pool.QueryRow(fx.ctx, relation.sql, args...).Scan(&violations); err != nil { + t.Fatalf("reference %s: %v", relation.name, err) + } + if err := fx.pool.QueryRow(fx.ctx, relation.matched, args...).Scan(&matched); err != nil { + t.Fatalf("reference coverage %s: %v", relation.name, err) + } + if violations != 0 { + diffs = append(diffs, fmt.Sprintf("reference %s: %d violations", relation.name, violations)) + } + if matched == 0 { + diffs = append(diffs, fmt.Sprintf("reference %s: oracle matched no rows", relation.name)) + } + } + // 向量/正文:索引文档逐条与声明完全一致(多一条少一条都算差异)。 + docs := ds02Docs(t, fx) + if len(docs) != len(spec.rows["chunks"])+1 { // +1:目标范围之外的 chunk-foreign + diffs = append(diffs, fmt.Sprintf("index docs: want %d got %d", len(spec.rows["chunks"])+1, len(docs))) + } + for _, chunk := range spec.rows["chunks"] { + id := fmt.Sprint(chunk["id"]) + doc, ok := docs[id] + if !ok { + diffs = append(diffs, "index doc missing: "+id) + continue + } + source := doc + want := map[string]any{"tenant_id": json.Number(strconv.FormatUint(wsTargetTenant, 10)), + "knowledge_base_id": wsTargetKB, "knowledge_id": chunk["knowledge_id"], "chunk_id": id, + "source_id": id, "content": chunk["content"], "embedding": spec.vectors[id]} + for key, value := range want { + if fmt.Sprint(source[key]) != fmt.Sprint(value) { + diffs = append(diffs, fmt.Sprintf("index doc %s.%s: want %v got %v", id, key, value, source[key])) + } + } + } + if foreign, ok := docs["chunk-foreign"]; !ok { + diffs = append(diffs, "foreign index doc disappeared") + } else if fmt.Sprint(foreign["content"]) != "外部正文" { + diffs = append(diffs, "foreign index doc changed") + } + // 对象字节:按独立重算的定位符读回,逐字节比。 + for id, want := range spec.objects { + reader, err := fx.objects.s3.Open(fx.ctx, "minio", paths[id]) + if err != nil { + diffs = append(diffs, fmt.Sprintf("object %s: %v", id, err)) + continue + } + got, err := io.ReadAll(reader) + reader.Close() + if err != nil { + diffs = append(diffs, fmt.Sprintf("object %s read: %v", id, err)) + continue + } + if string(got) != want { + diffs = append(diffs, fmt.Sprintf("object %s bytes: want %q got %q", id, want, got)) + } + } + // Wiki 日志映射:内容元组多重集双射(本地号不参与身份,来源 id 只用于覆盖检查)。 + wantTuples := []string{} + for _, row := range spec.rows["wiki_log_entries"] { + copied := map[string]any{} + for key, value := range row { + if key == "id" { + continue + } + copied[key] = value + } + copied["tenant_id"] = json.Number(strconv.FormatUint(wsTargetTenant, 10)) + copied["knowledge_base_id"] = wsTargetKB + raw, _ := json.Marshal(copied) + wantTuples = append(wantTuples, string(raw)) + } + gotTuples := []string{} + for _, row := range expected["wiki_log_entries"] { + _ = row + } + actualLogs := ds02Read(t, fx, `SELECT to_jsonb(x)::text FROM wiki_log_entries AS x WHERE tenant_id=$1 AND knowledge_base_id=$2`, wsTargetTenant, wsTargetKB) + for _, row := range actualLogs { + copied := map[string]any{} + for key, value := range row { + if key == "id" { + continue + } + copied[key] = value + } + raw, _ := json.Marshal(copied) + gotTuples = append(gotTuples, string(raw)) + } + sort.Strings(wantTuples) + sort.Strings(gotTuples) + if fmt.Sprint(wantTuples) != fmt.Sprint(gotTuples) { + diffs = append(diffs, fmt.Sprintf("wiki log tuple bijection broken: want %v got %v", wantTuples, gotTuples)) + } + // Embedding 调用必须为 0,且请求确实发生过(不是"一个请求都没有"的空绿)。 + embedding := 0 + for _, call := range *requests { + if strings.Contains(call, "embedding") || strings.Contains(call, "dashscope") || strings.Contains(call, "openai") { + embedding++ + } + } + if embedding != 0 { + diffs = append(diffs, fmt.Sprintf("embedding calls: want 0 got %d (%v)", embedding, *requests)) + } + if len(*requests) == 0 { + diffs = append(diffs, "no HTTP requests observed; zero-embedding oracle would be vacuous") + } + return diffs +} + +// ds02OtherRows 读目标范围之外的行(发布前抓一次,发布后要求一字不差)。 +func ds02OtherRows(t *testing.T, fx *writeSetFixture, table string) []map[string]any { + t.Helper() + if table == "knowledge_tag_relations" { + return nil + } + if tableHasTenant(table) && tablesWithKB[table] { + return ds02Read(t, fx, "SELECT to_jsonb(x)::text FROM "+table+" AS x WHERE NOT (tenant_id=$1 AND knowledge_base_id=$2)", wsTargetTenant, wsTargetKB) + } + return ds02Read(t, fx, "SELECT to_jsonb(x)::text FROM "+table+" AS x WHERE tenant_id<>$1", wsTargetTenant) +} + +func ds02SameTenantRows(t *testing.T, fx *writeSetFixture, table string) []map[string]any { + t.Helper() + return ds02Read(t, fx, "SELECT to_jsonb(x)::text FROM "+table+" AS x WHERE tenant_id=$1", wsTargetTenant) +} + +func TestDS02FullShapeOracleIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + // 用保留下来的真实 v071 catalog 重建十张表:逐列、外键、序列都是真实形状。 + r11Mirror(t, fx) + for _, sql := range []string{ + `SELECT setval('chunks_seq_id_seq',100000005,false)`, + `SELECT setval('knowledge_tags_seq_id_seq',50,false)`, + `SELECT setval('wiki_log_entries_id_seq',10,false)`, + } { + r10Exec(t, fx, sql) + } + ds02Seed(t, fx) + preserved := map[string][]map[string]any{} + for _, table := range ds02TargetTables { + preserved[table] = ds02OtherRows(t, fx, table) + } + spec := ds02SourceSpec(t, fx) + expected, paths := ds02Expected(t, fx, spec) + for _, table := range []string{"resources", "resource_bindings"} { + expected[table] = append(expected[table], ds02SameTenantRows(t, fx, table)...) + } + // knowledge_tag_relations 没有 tenant/kb:产品按父文档归属删除,非目标范围的 + // 关系行必须原样保留,所以它们也在期望里。 + expected["knowledge_tag_relations"] = append(expected["knowledge_tag_relations"], + ds02Read(t, fx, `SELECT to_jsonb(x)::text FROM knowledge_tag_relations AS x + WHERE knowledge_id NOT IN (SELECT id FROM knowledges WHERE tenant_id=$1 AND knowledge_base_id=$2)`, + wsTargetTenant, wsTargetKB)...) + snapshot := ds02Seal(t, fx, spec) + requests := ds02CountingClient(t, fx) + target := fx.target(t) + backups := fx.backups(t, target) + out := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, backups, nil) + r10Save(t, "outcome", out) + if out.State != "succeeded" { + t.Fatalf("full-shape publish must succeed: %+v", out) + } + // 写集合里的本地号映射必须完整、双射,并且目标行真的用了这些号。 + if out.Backup.WriteSet == nil { + t.Fatal("write set missing") + } + ledger, err := LoadWriteSet(fx.archiveRoot, out.Backup.WriteSet.Digest) + if err != nil { + t.Fatalf("load write set: %v", err) + } + for _, table := range []string{"chunks", "knowledge_tags", "wiki_log_entries"} { + column := "seq_id" + if table == "wiki_log_entries" { + column = "id" + } + sources := map[int64]bool{} + targets := map[int64]bool{} + for _, mapping := range ledger.LocalIDs { + if mapping.Table != table { + continue + } + if mapping.Column != column { + t.Fatalf("%s mapping column = %s", table, mapping.Column) + } + source, _ := strconv.ParseInt(mapping.Source, 10, 64) + targetID, _ := strconv.ParseInt(mapping.Target, 10, 64) + if sources[source] || targets[targetID] { + t.Fatalf("%s mapping not bijective: source=%d target=%d", table, source, targetID) + } + sources[source] = true + targets[targetID] = true + } + if len(sources) != len(spec.rows[table]) { + t.Fatalf("%s mapping covers %d source rows, want %d", table, len(sources), len(spec.rows[table])) + } + } + diffs := ds02Check(t, fx, spec, expected, paths, preserved, requests) + r10Save(t, "green-diffs", diffs) + if len(diffs) != 0 { + t.Fatalf("independent oracle disagrees on a correct publish:\n%s", strings.Join(diffs, "\n")) + } + r10Save(t, "green-requests", *requests) + + // 变异自检:对真实目标改正文 / 向量 / 引用 / 日志映射,oracle 必须红; + // 改回后必须绿。这样每条断言都证明了自己能抓到它负责的东西。 + content := fmt.Sprint(expected["chunks"][0]["content"]) + mutations := []struct { + name string + marker string + mutate func() + restore func() + }{ + {"content", "chunks:", func() { + r10Exec(t, fx, `UPDATE chunks SET content=content||'!MUT' WHERE id='chunk-src'`) + }, func() { + if _, err := fx.pool.Exec(fx.ctx, `UPDATE chunks SET content=$1 WHERE id='chunk-src'`, content); err != nil { + t.Fatal(err) + } + }}, + {"vector", "index doc chunk-src.embedding", func() { + body := `{"tenant_id":10001,"knowledge_base_id":"kb-target","knowledge_id":"doc-src","chunk_id":"chunk-src","source_id":"chunk-src","content":"来源正文一 resource://` + wsHandleSource + `","embedding":[9.5,9.5]}` + request, _ := http.NewRequestWithContext(fx.ctx, "PUT", fx.searchBase+"/"+fx.index+"/_doc/chunk-src?refresh=true", strings.NewReader(body)) + request.Header.Set("Content-Type", "application/json") + response, err := fx.client.Do(request) + if err != nil { + t.Fatal(err) + } + response.Body.Close() + if response.StatusCode >= 300 { + t.Fatalf("mutate vector: %d", response.StatusCode) + } + }, func() { + body := `{"tenant_id":10001,"knowledge_base_id":"kb-target","knowledge_id":"doc-src","chunk_id":"chunk-src","source_id":"chunk-src","content":"来源正文一 resource://` + wsHandleSource + `","embedding":[0.5,1.5]}` + request, _ := http.NewRequestWithContext(fx.ctx, "PUT", fx.searchBase+"/"+fx.index+"/_doc/chunk-src?refresh=true", strings.NewReader(body)) + request.Header.Set("Content-Type", "application/json") + response, err := fx.client.Do(request) + if err != nil { + t.Fatal(err) + } + response.Body.Close() + if response.StatusCode >= 300 { + t.Fatalf("restore vector: %d", response.StatusCode) + } + }}, + {"reference", "reference relation", func() { + r10Exec(t, fx, `UPDATE knowledge_tag_relations SET tag_id='missing-tag' WHERE knowledge_id='doc-src' AND tag_id='tag-src'`) + }, func() { + r10Exec(t, fx, `UPDATE knowledge_tag_relations SET tag_id='tag-src' WHERE knowledge_id='doc-src' AND tag_id='missing-tag'`) + }}, + {"mapping", "wiki log", func() { + r10Exec(t, fx, `UPDATE wiki_log_entries SET action='tampered' WHERE tenant_id=10001 AND knowledge_base_id='kb-target' AND knowledge_id='doc-src'`) + }, func() { + r10Exec(t, fx, `UPDATE wiki_log_entries SET action='ingest' WHERE tenant_id=10001 AND knowledge_base_id='kb-target' AND knowledge_id='doc-src'`) + }}, + } + for _, mutation := range mutations { + mutation.mutate() + red := ds02Check(t, fx, spec, expected, paths, preserved, requests) + r10Save(t, "red-"+mutation.name, red) + if len(red) == 0 { + t.Fatalf("%s mutation: oracle stayed green", mutation.name) + } + joined := strings.Join(red, "\n") + if !strings.Contains(joined, mutation.marker) { + t.Fatalf("%s mutation: oracle failed for an unrelated reason:\n%s", mutation.name, joined) + } + mutation.restore() + green := ds02Check(t, fx, spec, expected, paths, preserved, requests) + if len(green) != 0 { + t.Fatalf("%s mutation not restored cleanly:\n%s", mutation.name, strings.Join(green, "\n")) + } + } +} diff --git a/scripts/test-scope.json b/scripts/test-scope.json index d063c0b..539ab38 100644 --- a/scripts/test-scope.json +++ b/scripts/test-scope.json @@ -9,6 +9,8 @@ "⚠️ 文件缺失或解析不了 ⇒ 门禁红:范围声明不出来时,不许默认放行。" ], "optional": [ + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestDS02FullShapeOracleIsolated","reason":"需显式一次性本机PG/ES/MinIO:十表逐列/引用/向量/对象字节独立oracle、零Embedding计数与正文/向量/引用/映射变异自检;普通CI跳过不是通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestDS02LegacyCompatibilityMatrixIsolated","reason":"需显式一次性本机PG/ES/MinIO:旧manifest/V1/空作业或目标身份的正式入口拒绝且全数据hash不变;普通CI跳过不是通过"}, {"package":"knowledge-governance/cmd/worker","test":"TestR13AnchorWriteFailureBlocksTargetIsolated","reason":"需显式一次性本机治理PG:真实约束拒绝写锚点,验证目标零写入且不留假基线;普通CI跳过不是通过"}, {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR13OrphanOraclePropagatesDriverFailureIsolated","reason":"需显式一次性本机PG:用真实 statement timeout 让校验查询中途失败,断言不是\"无孤儿\";普通CI跳过不是通过"}, {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR13OrphanOracleRejectsMalformedAndUnknownDocumentsIsolated","reason":"需显式一次性本机PG/ES/MinIO:孤儿校验的缺失/未知 knowledge_id 分支;普通CI跳过不是通过"},