dcdc8d1ddd
全栈知识治理平台首次入库(P1-P10 + 发布链路模拟验证闭环): - 治理核心:源目录/变更集/人工审核/发布批次/发布执行(fail-closed 闸口) - 测试通道:WeKnora 测试 KB 上传/轮询/验收;poll 完成时写入 parser_generation/index_generation,修复 manual/seed 路径发布闸口永久拦截 - 发布适配器 v071(本地 source=测试角色 / 云端 target=生产角色 模拟验证通过): * ES 导出/导入 mapping 自适应(.keyword 子字段、可选 tenant_id) * OSS locator 支持嵌套 scheme;chunks.seq_id 由目标序列分配 * bundle 归档同身份重试原子替换;verifier 按 bundle chunk_type 计数 * 回滚 job payload 支持 prior_execution_id(strict 解码) - 三通道发布+回滚演练实测:publish 4/4 verified,检索命中, rollback 4/4 rolled_back,目标端 PG is_enabled=false、ES is_enabled=false - 前端 A·Data-console 风格全站统一,120 用例通过 - 门禁:go vet / go test 全包通过,gofmt 干净
159 lines
7.2 KiB
Go
159 lines
7.2 KiB
Go
package v071
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"knowledge-governance/internal/platform/weknora"
|
|
"knowledge-governance/internal/releasebundle"
|
|
releaseworkflow "knowledge-governance/internal/workflows/release"
|
|
)
|
|
|
|
func TestThreeLaneReleaseAndRollbackV071Integration(t *testing.T) {
|
|
sourceDatabaseURL := os.Getenv("TEST_WEKNORA_V071_DATABASE_URL")
|
|
targetDatabaseURL := os.Getenv("TEST_WEKNORA_V071_TARGET_DATABASE_URL")
|
|
minioEndpoint := os.Getenv("TEST_MINIO_ENDPOINT")
|
|
accessKey := os.Getenv("TEST_MINIO_ACCESS_KEY")
|
|
secretKey := os.Getenv("TEST_MINIO_SECRET_KEY")
|
|
if sourceDatabaseURL == "" || targetDatabaseURL == "" || minioEndpoint == "" || accessKey == "" || secretKey == "" {
|
|
t.Skip("three-lane integration environment is not set")
|
|
}
|
|
ctx := context.Background()
|
|
sourcePool, err := pgxpool.New(ctx, sourceDatabaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer sourcePool.Close()
|
|
targetPool, err := pgxpool.New(ctx, targetDatabaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer targetPool.Close()
|
|
|
|
sourceSearchState := newSearchState(map[string]json.RawMessage{"es-release": mustCanonicalRows(t, `{"tenant_id":10000,"knowledge_base_id":"kb-release-safe","knowledge_id":"knowledge-release-safe","chunk_id":"chunk-release-safe","content":"Synthetic release content","is_enabled":true}`)[0]})
|
|
targetSearchState := newSearchState(map[string]json.RawMessage{})
|
|
sourceSearchServer := httptest.NewServer(sourceSearchState)
|
|
defer sourceSearchServer.Close()
|
|
targetSearchServer := httptest.NewServer(targetSearchState)
|
|
defer targetSearchServer.Close()
|
|
sourceSearch, err := NewSearchExporter(SearchExporterConfig{BaseURL: sourceSearchServer.URL, Index: "chunks", AuthorizationToken: "safe-token", HTTPClient: sourceSearchServer.Client(), PageSize: 100})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
targetSearchConfig := SearchExporterConfig{BaseURL: targetSearchServer.URL, Index: "chunks", AuthorizationToken: "safe-token", HTTPClient: targetSearchServer.Client(), PageSize: 100}
|
|
targetSearch, err := NewSearchImporter(targetSearchConfig)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mappingSHA, err := sourceSearch.MappingSHA256(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sourceObjects, err := NewS3ObjectStore(S3ObjectStoreConfig{Provider: "minio", Endpoint: minioEndpoint, AccessKeyID: accessKey, SecretAccessKey: secretKey, Bucket: "release-source", ForcePathStyle: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
targetObjects, err := NewS3ObjectStore(S3ObjectStoreConfig{Provider: "minio", Endpoint: minioEndpoint, AccessKeyID: accessKey, SecretAccessKey: secretKey, Bucket: "release-target", ForcePathStyle: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := sourceObjects.EnsureBucket(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := targetObjects.EnsureBucket(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := sourceObjects.Put(ctx, "minio", "10000/knowledge-release-safe/synthetic.txt", bytes.NewReader([]byte("Synthetic release content")), 25); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := sourceObjects.Put(ctx, "minio", "10000/knowledge-release-safe/image.png", bytes.NewReader([]byte("synthetic-image!")), 16); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
objectExporter, _ := NewObjectExporter(sourceObjects, ObjectExporterLimits{})
|
|
objectImporter, _ := NewObjectImporter(targetObjects, TargetObjectConfig{StorageBackendID: "target-backend", Provider: "minio"})
|
|
postgresExporter, _ := NewPostgresExporter(sourcePool)
|
|
postgresImporter, _ := NewPostgresImporter(targetPool, PostgresImporterConfig{TargetStorageBackendID: "target-backend", TargetProvider: "minio"})
|
|
contract := releasebundle.TargetContract{WeKnoraVersion: releasebundle.WeKnoraVersionV071, MigrationVersion: releasebundle.WeKnoraMigrationV071, TenantID: 10000, KnowledgeBaseID: "kb-release-safe", RetrieverEngine: "elasticsearch_v8", EmbeddingModel: "bge-m3", EmbeddingDimension: releasebundle.EmbeddingDimensionV071, ElasticsearchMappingSHA256: mappingSHA}
|
|
exporter, err := NewDocumentExporter(DocumentExporterConfig{Contract: &stubSourceContract{contract: contract}, Postgres: postgresExporter, Search: sourceSearch, Objects: objectExporter, TenantID: 10000, EmbeddingModel: "bge-m3", Now: func() time.Time { return time.Date(2026, 9, 6, 12, 0, 0, 0, time.UTC) }})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
archiveRoot := t.TempDir()
|
|
if err := os.Chmod(archiveRoot, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
archive, err := NewBundleArchive(archiveRoot, 128*1024*1024)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
verification := &verificationClient{knowledge: weknora.Knowledge{ID: "knowledge-release-safe", KnowledgeBaseID: "kb-release-safe", ParseStatus: "completed"}, chunkTotal: 1, search: []weknora.SearchResult{{ID: "chunk-release-safe", KnowledgeID: "knowledge-release-safe", Score: 0.8}}}
|
|
verifier, _ := NewWeKnoraVerifier(verification)
|
|
target, err := NewDocumentTarget(DocumentTargetConfig{Archive: archive, Contract: &stubContractInspector{contract: contract}, Postgres: postgresImporter, Search: targetSearch, Objects: objectImporter, Verifier: verifier})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
publisher, err := releaseworkflow.NewSidecarPublisher(exporter, target)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
first := releaseworkflow.PlanItem{ReleaseExecutionID: "rx-release-1", PublicationID: "tp-release-1", SourceItemVersionID: "version-release-safe", SourceRevision: "source-v1", ParseRevision: "parser-v1@index-v1", ReleaseRevision: "review-release-1", TestKnowledgeBaseID: "kb-release-safe", KnowledgeID: "knowledge-release-safe", DecidedVisibility: "internal"}
|
|
if _, err := exporter.Export(ctx, first); err != nil {
|
|
t.Fatalf("export preflight: %v", err)
|
|
}
|
|
firstResult, err := publisher.Publish(ctx, first)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if firstResult.PreviousProductionRevision != "absent" || firstResult.ProductionRevision != "review-release-1" {
|
|
t.Fatalf("first=%#v", firstResult)
|
|
}
|
|
second := first
|
|
second.ReleaseExecutionID = "rx-release-2"
|
|
second.PublicationID = "tp-release-2"
|
|
second.SourceRevision = "source-v2"
|
|
second.ReleaseRevision = "review-release-2"
|
|
second.PreviousProductionRevision = firstResult.ProductionRevision
|
|
secondResult, err := publisher.Publish(ctx, second)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if secondResult.PreviousProductionRevision != "review-release-1" || secondResult.ProductionRevision != "review-release-2" {
|
|
t.Fatalf("second=%#v", secondResult)
|
|
}
|
|
rollback, err := publisher.Rollback(ctx, second)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if rollback.ProductionRevision != "review-release-1" {
|
|
t.Fatalf("rollback=%#v", rollback)
|
|
}
|
|
|
|
targetSnapshot, err := NewPostgresExporter(targetPool)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
actual, err := targetSnapshot.Export(ctx, PostgresIdentity{TenantID: 10000, KnowledgeBaseID: "kb-release-safe", KnowledgeID: "knowledge-release-safe"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if actual.Table("chunks").RowCount != 1 || !targetSearchState.has("es-release") {
|
|
t.Fatalf("target rows=%d search=%v", actual.Table("chunks").RowCount, targetSearchState.has("es-release"))
|
|
}
|
|
for _, key := range []string{"10000/knowledge-release-safe/synthetic.txt", "10000/knowledge-release-safe/image.png"} {
|
|
size, _, err := targetObjects.Stat(ctx, "minio", key)
|
|
if err != nil || size == 0 {
|
|
t.Fatalf("asset=%s size=%d err=%v", filepath.Base(key), size, err)
|
|
}
|
|
}
|
|
}
|