Files
knowledge-governance/internal/releaseadapter/v071/contract_inspector_test.go
T
姚章浩 2de7a43286 feat(release): 生产授权支持页面通道(管理员会话 + 固定确认语句)
页面原本没有任何生产入口,授权/重排/回滚只能带 Bearer 调接口,实际还要 admin 会话。
现在三个端点支持两条通道,门禁语义不变:

- 运维通道:Authorization: Bearer <token>,审计记 PRODUCTION_RELEASE_AUTHORIZER_REF
- 页面通道:已认证 admin 会话 + 固定确认语句,审计记该管理员用户名
- 请求门禁 / 备份恢复门禁 / Release Worker 执行门禁三者不受影响
- 发布管理第 6–8 步加「授权发布 / 重排 / 回滚」按钮,点击需逐字输入确认语句,
  仅 admin 可见;重排沿用原执行授权人,不改写历史
- openapi 与 P6 契约同步;测试:双通道各一条 + 非 admin/错短语拒绝 + 前端按钮与确认门禁
2026-10-08 17:00:49 +08:00

133 lines
4.8 KiB
Go

package v071
import (
"context"
"strings"
"testing"
"github.com/jackc/pgx/v5"
)
func TestTargetContractInspectorReadsOnlyCompatibilityFields(t *testing.T) {
db := &contractDB{row: contractRow{values: []any{74, false, uint64(10000), "bge-m3", 1024, "elasticsearch", "chunks"}}}
mapping := &mappingInspector{sha: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}
inspector, err := NewTargetContractInspector(TargetContractInspectorConfig{DB: db, Mapping: mapping, KnowledgeBaseID: "kb-safe", TenantID: 10000, IndexName: "chunks"})
if err != nil {
t.Fatal(err)
}
contract, err := inspector.Contract(context.Background(), releasePlanForArchive())
if err != nil {
t.Fatal(err)
}
if contract.WeKnoraVersion != "v0.7.1" || contract.MigrationVersion != 74 || contract.KnowledgeBaseID != "kb-safe" || contract.TenantID != 10000 || contract.EmbeddingModel != "bge-m3" || contract.EmbeddingDimension != 1024 || contract.RetrieverEngine != "elasticsearch_v8" || contract.ElasticsearchMappingSHA256 != mapping.sha {
t.Fatalf("contract=%#v", contract)
}
query := strings.ToLower(db.query)
for _, forbidden := range []string{"connection_config", "password", "api_key"} {
if strings.Contains(query, forbidden) {
t.Fatalf("query exposes %s: %s", forbidden, query)
}
}
for _, required := range []string{"schema_migrations", "knowledge_bases", "models", "embedding_parameters", "vector_stores", "index_config"} {
if !strings.Contains(query, required) {
t.Fatalf("query missing %s: %s", required, query)
}
}
}
func TestTargetContractInspectorRejectsMismatchedPlanKB(t *testing.T) {
db := &contractDB{row: contractRow{values: []any{74, false, uint64(10000), "bge-m3", 1024, "elasticsearch", "chunks"}}}
inspector, _ := NewTargetContractInspector(TargetContractInspectorConfig{DB: db, Mapping: &mappingInspector{sha: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, KnowledgeBaseID: "kb-safe", TenantID: 10000, IndexName: "chunks"})
plan := releasePlanForArchive()
plan.TestKnowledgeBaseID = "other-kb"
if _, err := inspector.Contract(context.Background(), plan); err == nil {
t.Fatal("mismatched KB accepted")
}
}
// With a 源库 → 目标库 mapping the two sides must read DIFFERENT bases: the
// target reads the mapped one, the source keeps reading the tested one. Reading
// the mapped base on the source plane made a real release fail with
// "source WeKnora release contract mismatch" (the target base is unknown there).
func TestTargetContractInspectorSidesPickTheRightBase(t *testing.T) {
row := contractRow{values: []any{74, false, uint64(10000), "bge-m3", 1024, "elasticsearch", "chunks"}}
mapping := &mappingInspector{sha: strings.Repeat("a", 64)}
plan := releasePlanForArchive()
plan.TargetKnowledgeBaseID = "prod-kb"
targetDB := &contractDB{row: row}
targetInspector, err := NewTargetContractInspector(TargetContractInspectorConfig{DB: targetDB, Mapping: mapping, KnowledgeBaseID: "kb-safe", TenantID: 10000, IndexName: "chunks"})
if err != nil {
t.Fatal(err)
}
targetContract, err := targetInspector.Contract(context.Background(), plan)
if err != nil {
t.Fatal(err)
}
if targetContract.KnowledgeBaseID != "prod-kb" {
t.Fatalf("target contract kb=%q, want the mapped base", targetContract.KnowledgeBaseID)
}
if len(targetDB.args) != 1 || targetDB.args[0] != "prod-kb" {
t.Fatalf("target read base=%v, want prod-kb", targetDB.args)
}
sourceDB := &contractDB{row: row}
sourceInspector, err := NewTargetContractInspector(TargetContractInspectorConfig{DB: sourceDB, Mapping: mapping, KnowledgeBaseID: "kb-safe", TenantID: 10000, IndexName: "chunks", ReadTestedBase: true})
if err != nil {
t.Fatal(err)
}
sourceContract, err := sourceInspector.Contract(context.Background(), plan)
if err != nil {
t.Fatal(err)
}
if sourceContract.KnowledgeBaseID != "kb-safe" {
t.Fatalf("source contract kb=%q, want the tested base", sourceContract.KnowledgeBaseID)
}
if len(sourceDB.args) != 1 || sourceDB.args[0] != "kb-safe" {
t.Fatalf("source read base=%v, want kb-safe", sourceDB.args)
}
}
type contractDB struct {
row contractRow
query string
args []any
}
func (d *contractDB) QueryRow(_ context.Context, query string, args ...any) pgx.Row {
d.query = query
d.args = args
return d.row
}
type contractRow struct {
values []any
err error
}
func (r contractRow) Scan(dest ...any) error {
if r.err != nil {
return r.err
}
for i, value := range r.values {
switch target := dest[i].(type) {
case *int:
*target = value.(int)
case *bool:
*target = value.(bool)
case *uint64:
*target = value.(uint64)
case *string:
*target = value.(string)
}
}
return nil
}
type mappingInspector struct {
sha string
err error
}
func (m *mappingInspector) MappingSHA256(context.Context) (string, error) { return m.sha, m.err }