Files
knowledge-governance/internal/releaseadapter/v071/three_lane_integration_test.go
T
姚章浩 8febe12d7d test(library): 隔离数据契约与 r11 身份自然键矩阵
真实本机 PG/ES/MinIO:v071 目录镜像 10 模式、结构引用/游标 15 模式、
8 表×2 外部范围身份矩阵、13 模式自然键(含软删除与合法同 parent 正例)、
备份期间三注入、收尾故障与授权撤销两个真实治理 PG 用例。

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

139 lines
6.6 KiB
Go

package v071
import (
"bytes"
"context"
"encoding/json"
"net/http/httptest"
"os"
"strings"
"testing"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"knowledge-governance/internal/platform/weknora"
"knowledge-governance/internal/releasebundle"
releaseworkflow "knowledge-governance/internal/workflows/release"
)
func TestLegacyThreeLanePublishRefusesUnplannedWritesIntegration(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)
}
// The former document-level write lane is deliberately retired. Keep its
// original source fixture, but prove refusal rather than silently exercising
// a direct PUT/COPY path outside the frozen-plan gateway.
targetSnapshot, e := NewPostgresExporter(targetPool)
if e != nil {
t.Fatal(e)
}
identity := PostgresIdentity{TenantID: 10000, KnowledgeBaseID: "kb-release-safe", KnowledgeID: "knowledge-release-safe"}
before, e := targetSnapshot.Export(ctx, identity)
if e != nil {
t.Fatal(e)
}
if _, e = publisher.Publish(ctx, first); e == nil || !strings.Contains(e.Error(), "stage v0.7.1 release assets") {
t.Fatal("legacy lane was not rejected at object gate", e)
}
after, e := targetSnapshot.Export(ctx, identity)
if e != nil {
t.Fatal(e)
}
beforeBytes, _ := json.Marshal(before)
afterBytes, _ := json.Marshal(after)
if !bytes.Equal(beforeBytes, afterBytes) || targetSearchState.has("es-release") {
t.Fatal("retired lane changed PG or search")
}
}