fix(release): 禁止导入未被算进期望策略 —— 生产知识下不了架(计划与建批两处同源缺陷)

界面验收实测(2026-10-10):把已发布到生产的 PDF 改为「禁止导入」后,发布通道既给不出
delete、也建不了 delete 批次。

根因:禁止导入只写 source_items.policy_state='blocked',而"期望策略"的解析只看
source_item_scope_overrides / directory_scope_rules / source_items.visibility——
两处实现都不看 policy_state:
  1) release_plan.go 的 source_truth:被禁止且生产侧存在的条目被算成 unchanged/present、
     can_release=false → 永远不会出现 delete 动作;
  2) release_batches.go 的 releaseDeleteReadyCTEs.source_truth:同样口径 → 计划即使给了
     delete,创建封批仍被拒 422(实测原文「创建封批失败(HTTP 422)」)。

修复:两处都把 policy_state='blocked' 算进期望策略(各一行,注释写明成因)。
新增集成测试 release_plan_policy_state_integration_test.go:用 policy_state(真实路由的写法)
造"生产存在 + 已禁止"的条目,断言①计划给出 action=delete/can_release、②delete 批次可创建;
分别回退任一处修复,该测试即 FAIL(已实测两种回退都 FAIL)。

实测闭环:重新发布使生产存在(enable_status=enabled)→ 禁止导入 → 计划 delete(present/
can_release=true)→ v8 delete_count=1 → 批次 rb-8c1ad1c9…(sealed, action=delete) → 留档
20261010T033100Z + 门禁 PASS → 执行 rx-6c19232a… completed(项级 verified/delete、
production_revision=absent)→ 目标库该行 enable_status=disabled(行保留、检索停用、可恢复)。

附带:从未导入却被标为禁止的 82 条"等待测试"噪音不再占发布计划(195 → 113 项)。
证据与说明补进 docs/USER_FLOWS_ACCEPTANCE.md(C2b + F.3h)。
This commit is contained in:
姚章浩
2026-10-10 11:36:08 +08:00
parent fa244c447c
commit e9a643cc33
4 changed files with 149 additions and 2 deletions
@@ -74,7 +74,11 @@ acceptance_run_summary AS (
const releaseDeleteReadyCTEs = `
source_truth AS (
SELECT source.id, source.source_change,
COALESCE(item_rule.visibility, directory_rule.visibility, source.visibility) AS desired_policy
-- 与 release_plan 同一口径:「禁止导入」记在 source_items.policy_state 上,
-- 必须算进期望策略,否则 delete 就绪判定会把被禁止的条目当"仍然保留"→ 永远不
-- delete-ready(创建封批直接 422)。2026-10-10 实测:计划已给出 delete,但建批仍被拒。
CASE WHEN source.policy_state='blocked' THEN 'blocked'
ELSE COALESCE(item_rule.visibility, directory_rule.visibility, source.visibility) END AS desired_policy
FROM source_items AS source
LEFT JOIN source_item_scope_overrides AS item_rule ON item_rule.source_item_id = source.id
LEFT JOIN LATERAL (
+7 -1
View File
@@ -12,7 +12,13 @@ const listReleasePlanSQL = `
WITH ` + releaseGateCTEs + `,
source_truth AS (
SELECT source.id AS source_item_id, source.title, source.revision, source.source_change,
COALESCE(item_rule.visibility, directory_rule.visibility, source.visibility) AS desired_policy
-- 「禁止导入」记录在 source_items.policy_state 上;这里必须把它算进期望策略,
-- 否则被禁止的条目会被当成"仍然保留"→ 生产侧已存在的它只会算出 unchanged,
-- 永远不产生 delete 动作,生产知识无法通过发布通道下架
-- (2026-10-10 实测:PDF 已 enabled 于生产库、policy_state=blocked,计划给的却是
-- unchanged/present、can_release=false)。
CASE WHEN source.policy_state='blocked' THEN 'blocked'
ELSE COALESCE(item_rule.visibility, directory_rule.visibility, source.visibility) END AS desired_policy
FROM source_items source
LEFT JOIN source_item_scope_overrides item_rule ON item_rule.source_item_id=source.id
LEFT JOIN LATERAL (
@@ -0,0 +1,110 @@
package postgres
import (
"context"
"os"
"strings"
"testing"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"knowledge-governance/internal/governance"
releaseworkflow "knowledge-governance/internal/workflows/release"
)
// TestReleasePlanEmitsDeleteForBlockedPolicyStateIntegration
//
// 「禁止导入」在真实链路上只写 source_items.policy_state='blocked',并**不**写
// source_item_scope_overrides。计划的期望策略若只看 override/directory/visibility,
// 就会把被禁止的条目当"仍然保留":生产侧已 enabled 的它只会算出 unchanged/present、
// can_release=false,永远不产生 delete 动作 → 生产知识通过发布通道下不了架。
// 2026-10-10 界面验收实测到这一幕(PDF 已 enabled 于 0b217e8a、policy_state=blocked,
// 计划给的却是 unchanged/present)。上面的 release_authorization 用例用 override 造 blocked,
// 所以一直没暴露这个偏差 —— 本用例专门用 policy_state 复现。
func TestReleasePlanEmitsDeleteForBlockedPolicyStateIntegration(t *testing.T) {
databaseURL := isolatedIntegrationDatabaseURL(t, os.Getenv("TEST_DATABASE_URL"))
if databaseURL == "" {
t.Skip("TEST_DATABASE_URL is not set")
}
ctx := context.Background()
pool, err := pgxpool.New(ctx, databaseURL)
if err != nil {
t.Fatal(err)
}
defer pool.Close()
if err := ApplyMigrations(ctx, pool); err != nil {
t.Fatal(err)
}
store := NewStore(pool)
now := time.Date(2026, 9, 6, 5, 0, 0, 0, time.UTC)
if _, err := pool.Exec(ctx, `INSERT INTO source_connections (id, source_type, name) VALUES ('conn-manual', 'manual', 'Manual')`); err != nil {
t.Fatal(err)
}
insertReviewFixture(t, ctx, pool, 10, "tp-auth", now)
if _, err := store.ReviewPublication(ctx, governance.ReviewPublicationRequest{
PublicationID: "tp-auth", Decision: governance.ReviewApproved,
DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "engineer-1",
DecisionCode: "approved_for_release", Now: now.Add(time.Minute),
}); err != nil {
t.Fatal(err)
}
batch, err := store.CreateReleaseBatch(ctx, governance.CreateReleaseBatchRequest{
Name: "Policy state batch", CreatedBy: "engineer-1", PublicationIDs: []string{"tp-auth"}, Now: now.Add(2 * time.Minute),
})
if err != nil {
t.Fatal(err)
}
if _, err := store.SealReleaseBatch(ctx, governance.SealReleaseBatchRequest{BatchID: batch.ID, SealedBy: "engineer-2", Now: now.Add(3 * time.Minute)}); err != nil {
t.Fatal(err)
}
execution, err := store.AuthorizeReleaseBatch(ctx, governance.AuthorizeReleaseBatchRequest{
BatchID: batch.ID, AuthorizedBy: "release-owner", AuthorizationCode: "production_release_authorized", Now: now.Add(4 * time.Minute),
})
if err != nil {
t.Fatal(err)
}
plan, err := store.StartExecution(ctx, releaseworkflow.StartExecutionRequest{
ExecutionID: execution.ID, JobID: execution.JobID, Operation: governance.ReleaseOperationPublish, Now: now.Add(5 * time.Minute),
})
if err != nil || len(plan) != 1 {
t.Fatalf("publish plan=%#v error=%v", plan, err)
}
if err := store.CompleteItem(ctx, releaseworkflow.CompleteItemRequest{
ExecutionID: execution.ID, PublicationID: "tp-auth", BundleSHA256: strings.Repeat("a", 64),
PreviousProductionRevision: "prod-v0", ProductionRevision: plan[0].ReleaseRevision, Now: now.Add(6 * time.Minute),
}); err != nil {
t.Fatal(err)
}
if err := store.FinishExecution(ctx, execution.ID, now.Add(7*time.Minute)); err != nil {
t.Fatal(err)
}
// 发布完成 → 生产侧存在;此时按真实路由只写 policy_state。
if _, err := pool.Exec(ctx, `UPDATE source_items SET policy_state='blocked' WHERE id='si-review-10'`); err != nil {
t.Fatal(err)
}
deletePlan, err := store.ListReleasePlan(ctx)
if err != nil {
t.Fatal(err)
}
if len(deletePlan.Items) != 1 {
t.Fatalf("blocked-but-live item must produce exactly one plan row, got %#v", deletePlan.Items)
}
item := deletePlan.Items[0]
if item.Action != "delete" || !item.CanRelease || item.PublicationID != "tp-auth" || item.ProductionState != "present" || item.Blocker != "" {
t.Fatalf("blocked policy_state must yield a releasable delete row, got %#v", item)
}
// 第二处同源判定:建封批用的 releaseDeleteReadyCTEs 也解析期望策略。
// 计划给出 delete 但这里没同步修,则创建封批会被门禁拒成 422(2026-10-10 实测)。
deleteBatch, err := store.CreateReleaseBatch(ctx, governance.CreateReleaseBatchRequest{
Name: "Delete batch", CreatedBy: "engineer-1", DeletePublicationIDs: []string{"tp-auth"}, Now: now.Add(8 * time.Minute),
})
if err != nil {
t.Fatalf("blocked-but-live delete batch must be creatable, got error: %v", err)
}
if deleteBatch.ItemCount != 1 || deleteBatch.State != governance.ReleaseBatchDraft {
t.Fatalf("delete batch=%#v", deleteBatch)
}
}