From 8febe12d7df42a0a945445d709a379c52de9d4c1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=A7=9A=E7=AB=A0=E6=B5=A9?= Date: Sun, 1 Nov 2026 11:35:09 +0800 Subject: [PATCH] =?UTF-8?q?test(library):=20=E9=9A=94=E7=A6=BB=E6=95=B0?= =?UTF-8?q?=E6=8D=AE=E5=A5=91=E7=BA=A6=E4=B8=8E=20r11=20=E8=BA=AB=E4=BB=BD?= =?UTF-8?q?=E8=87=AA=E7=84=B6=E9=94=AE=E7=9F=A9=E9=98=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 真实本机 PG/ES/MinIO:v071 目录镜像 10 模式、结构引用/游标 15 模式、 8 表×2 外部范围身份矩阵、13 模式自然键(含软删除与合法同 parent 正例)、 备份期间三注入、收尾故障与授权撤销两个真实治理 PG 用例。 需隔离服务的用例在 test-scope.json 显式声明:普通 CI 跳过不算通过。 --- cmd/worker/library_attempt_timing_test.go | 16 + cmd/worker/library_contract_adopter_test.go | 51 + .../library_finalize_r11_integration_test.go | 197 ++ ...brary_grant_revoke_r11_integration_test.go | 102 + cmd/worker/library_lease_test.go | 61 + .../httpapi/library_baseline_mutex_test.go | 15 + .../httpapi/library_dispatch_fixture_test.go | 33 + internal/httpapi/library_flow_test.go | 8 + internal/httpapi/library_intent_test.go | 19 +- .../httpapi/library_legacy_source_test.go | 67 + .../httpapi/library_overview_empty_test.go | 3 +- .../httpapi/library_source_contract_test.go | 23 + .../httpapi/library_source_fixture_test.go | 63 + internal/libraryfreeze/recover_window_test.go | 10 +- internal/libraryrelease/release_test.go | 3 +- .../writeset_version_contract_test.go | 43 + .../archive_directory_durability_test.go | 40 + .../postgres/library_dispatch_test.go | 39 + .../postgres/library_execution_test.go | 51 + .../postgres/library_lease_contract_test.go | 59 + .../postgres/library_legacy_source_test.go | 152 ++ .../postgres/library_source_candidate_test.go | 42 + .../v071/data_admission_fixture_r10_test.go | 82 + .../v071/data_admission_r10_test.go | 51 + .../v071/data_boundary_r11_test.go | 126 ++ .../v071/data_closure_r10_test.go | 243 ++ .../v071/data_contract_r10_test.go | 258 +++ .../v071/data_matrix_r11_test.go | 353 +++ .../v071/data_resource_restore_r10_test.go | 42 + .../v071/data_schema_r11_test.go | 188 ++ .../v071/formal_es_fault_test.go | 81 + .../v071/formal_recovery_integration_test.go | 340 +++ .../v071/formal_worker_integration_test.go | 431 ++++ .../v071/library_contract_durability_test.go | 80 + .../v071/library_contract_external_test.go | 43 + .../library_contract_plan_integration_test.go | 171 ++ .../v071/library_evidence_directory_test.go | 47 + .../v071/library_export_test.go | 11 + .../v071/library_identity_contract_test.go | 108 + .../v071/library_index_claim_test.go | 128 ++ .../library_index_delete_reconcile_test.go | 108 + .../v071/library_index_effects_test.go | 102 + .../v071/library_index_restart_test.go | 109 + .../library_memory_object_contract_test.go | 59 + .../v071/library_natural_keys_test.go | 31 + .../v071/library_object_effects_test.go | 61 + .../v071/library_object_reconcile_test.go | 130 ++ .../library_object_version_fixture_test.go | 23 + ...rary_production_target_integration_test.go | 105 +- .../v071/library_resource_fk_test.go | 65 + .../v071/library_reuse_integration_test.go | 10 +- .../v071/library_schema_contract_test.go | 32 + .../v071/library_schema_sequence_test.go | 28 + .../v071/library_writeset_integration_test.go | 121 +- .../v071/library_writeset_kill_test.go | 17 +- .../releaseadapter/v071/object_import_test.go | 24 +- .../v071/oss_version_list_test.go | 68 + .../oss_version_store_integration_test.go | 185 ++ .../v071/oss_version_store_test.go | 168 ++ .../v071/testdata/catalog-v071-r11.json | 2004 +++++++++++++++++ .../v071/three_lane_integration_test.go | 62 +- scripts/test-scope.json | 104 + 62 files changed, 7329 insertions(+), 167 deletions(-) create mode 100644 cmd/worker/library_attempt_timing_test.go create mode 100644 cmd/worker/library_contract_adopter_test.go create mode 100644 cmd/worker/library_finalize_r11_integration_test.go create mode 100644 cmd/worker/library_grant_revoke_r11_integration_test.go create mode 100644 cmd/worker/library_lease_test.go create mode 100644 internal/httpapi/library_dispatch_fixture_test.go create mode 100644 internal/httpapi/library_legacy_source_test.go create mode 100644 internal/httpapi/library_source_contract_test.go create mode 100644 internal/httpapi/library_source_fixture_test.go create mode 100644 internal/libraryrelease/writeset_version_contract_test.go create mode 100644 internal/librarysnapshot/archive_directory_durability_test.go create mode 100644 internal/platform/postgres/library_dispatch_test.go create mode 100644 internal/platform/postgres/library_execution_test.go create mode 100644 internal/platform/postgres/library_lease_contract_test.go create mode 100644 internal/platform/postgres/library_legacy_source_test.go create mode 100644 internal/platform/postgres/library_source_candidate_test.go create mode 100644 internal/releaseadapter/v071/data_admission_fixture_r10_test.go create mode 100644 internal/releaseadapter/v071/data_admission_r10_test.go create mode 100644 internal/releaseadapter/v071/data_boundary_r11_test.go create mode 100644 internal/releaseadapter/v071/data_closure_r10_test.go create mode 100644 internal/releaseadapter/v071/data_contract_r10_test.go create mode 100644 internal/releaseadapter/v071/data_matrix_r11_test.go create mode 100644 internal/releaseadapter/v071/data_resource_restore_r10_test.go create mode 100644 internal/releaseadapter/v071/data_schema_r11_test.go create mode 100644 internal/releaseadapter/v071/formal_es_fault_test.go create mode 100644 internal/releaseadapter/v071/formal_recovery_integration_test.go create mode 100644 internal/releaseadapter/v071/formal_worker_integration_test.go create mode 100644 internal/releaseadapter/v071/library_contract_durability_test.go create mode 100644 internal/releaseadapter/v071/library_contract_external_test.go create mode 100644 internal/releaseadapter/v071/library_contract_plan_integration_test.go create mode 100644 internal/releaseadapter/v071/library_evidence_directory_test.go create mode 100644 internal/releaseadapter/v071/library_identity_contract_test.go create mode 100644 internal/releaseadapter/v071/library_index_claim_test.go create mode 100644 internal/releaseadapter/v071/library_index_delete_reconcile_test.go create mode 100644 internal/releaseadapter/v071/library_index_effects_test.go create mode 100644 internal/releaseadapter/v071/library_index_restart_test.go create mode 100644 internal/releaseadapter/v071/library_memory_object_contract_test.go create mode 100644 internal/releaseadapter/v071/library_natural_keys_test.go create mode 100644 internal/releaseadapter/v071/library_object_effects_test.go create mode 100644 internal/releaseadapter/v071/library_object_reconcile_test.go create mode 100644 internal/releaseadapter/v071/library_object_version_fixture_test.go create mode 100644 internal/releaseadapter/v071/library_resource_fk_test.go create mode 100644 internal/releaseadapter/v071/library_schema_contract_test.go create mode 100644 internal/releaseadapter/v071/library_schema_sequence_test.go create mode 100644 internal/releaseadapter/v071/oss_version_list_test.go create mode 100644 internal/releaseadapter/v071/oss_version_store_integration_test.go create mode 100644 internal/releaseadapter/v071/oss_version_store_test.go create mode 100644 internal/releaseadapter/v071/testdata/catalog-v071-r11.json diff --git a/cmd/worker/library_attempt_timing_test.go b/cmd/worker/library_attempt_timing_test.go new file mode 100644 index 0000000..661ea73 --- /dev/null +++ b/cmd/worker/library_attempt_timing_test.go @@ -0,0 +1,16 @@ +//go:build !kg_isolated_drill + +package main + +import ( + "testing" + "time" +) + +func TestProductionAttemptTimingIgnoresDrillEnvironment(t *testing.T) { + t.Setenv("KG_LIBRARY_TEST_ISOLATED", "1") + t.Setenv("WORKER_LEASE_DURATION", "1ms") + if libraryAttemptLease != 10*time.Minute { + t.Fatal("production lease shortened by drill injection") + } +} diff --git a/cmd/worker/library_contract_adopter_test.go b/cmd/worker/library_contract_adopter_test.go new file mode 100644 index 0000000..c6f6c67 --- /dev/null +++ b/cmd/worker/library_contract_adopter_test.go @@ -0,0 +1,51 @@ +package main + +import ( + "context" + "errors" + "testing" + "time" + + "knowledge-governance/internal/libraryrelease" +) + +type contractAdoptingTarget struct { + plainTarget + adopted int + planned int + reject error +} + +func (t *contractAdoptingTarget) AdoptWriteSet(set libraryrelease.WriteSet) error { + t.adopted++ + return t.reject +} +func (t *contractAdoptingTarget) PlanWriteSet(context.Context, libraryrelease.WriteSetPlan) (libraryrelease.WriteSet, error) { + t.planned++ + return libraryrelease.WriteSet{}, errors.New("must not replan") +} + +func TestContractWorkerWrapperReplaysPersistedPlan(t *testing.T) { + for _, reject := range []bool{false, true} { + inner := &contractAdoptingTarget{} + if reject { + inner.reject = errors.New("binding mismatch") + } + wrapped := &contentTrackedTarget{inner: inner, jobID: "job-1", onApply: func() {}} + set := sealedLedger(t, "") + now := time.Now().UTC() + request := libraryrelease.Request{JobID: "job-1", Target: "internal", SnapshotID: "target-snap", ParamsDigest: "digest", Now: now, + Grant: libraryrelease.Grant{Target: "internal", SnapshotID: "target-snap", ParamsDigest: "digest", ExpiresAt: now.Add(time.Hour), AuthorizedBy: "test"}} + backup := ledgerBackupStore{ref: libraryrelease.BackupRef{ID: "backup-1", SnapshotID: "backup-snap", Bytes: 4096}, write: &set} + result := libraryrelease.Run(context.Background(), request, wrapped, backup, nil) + if inner.adopted != 1 || inner.planned != 0 { + t.Fatalf("real wrapper lost adoption: adopted=%d planned=%d result=%+v", inner.adopted, inner.planned, result) + } + if reject && (inner.applied != 0 || result.State == "succeeded") { + t.Fatal("adoption failure must be zero-write") + } + if !reject && result.State != "succeeded" { + t.Fatalf("replay: %+v", result) + } + } +} diff --git a/cmd/worker/library_finalize_r11_integration_test.go b/cmd/worker/library_finalize_r11_integration_test.go new file mode 100644 index 0000000..8e646e0 --- /dev/null +++ b/cmd/worker/library_finalize_r11_integration_test.go @@ -0,0 +1,197 @@ +package main + +import ( + "context" + "errors" + "os" + "path/filepath" + "testing" + "time" + + "knowledge-governance/internal/governance" + postgresstore "knowledge-governance/internal/platform/postgres" +) + +// B28:内容已通过校验之后的两类收尾故障必须只补收尾、不重写目标,且绝不伪报成功。 +// +// 这里用真实治理 PG(维护行、作业行、版本事件行都是真表),故障只注入在 +// “释放 scope 维护占用”这一个步骤上;其余调用照旧打到真库。 +type r11FinishFaultStore struct { + *postgresstore.Store + applies *int + failOnRelease bool + releaseFailure error +} + +func (s *r11FinishFaultStore) ReleaseLibraryMaintenance(ctx context.Context, scope, ownerJobID string, now time.Time) error { + if s.failOnRelease { + return s.releaseFailure + } + return s.Store.ReleaseLibraryMaintenance(ctx, scope, ownerJobID, now) +} + +type r11HealthyTarget struct{ err error } + +func (h r11HealthyTarget) VerifyRunning(context.Context) error { return h.err } + +func TestR11FinalizeFailureAfterTerminalHoldsThenRepairsWithoutRewrite(t *testing.T) { + store, _ := openLedgerStore(t) + ctx := context.Background() + now := time.Now().UTC() + const ( + scope = "internal" + instance = "kgseal-r11-finalize" + jobID = "libsync-r11-finalize" + target = "target-snap-r11-finalize" + backup = "backup-snap-r11-finalize" + operation = "libop-r11-finalize" + ) + if _, _, err := store.CreateLibraryJob(ctx, governance.LibraryJob{ID: jobID, Scope: scope, + Kind: governance.LibraryJobSync, IdempotencyKey: "library.sync:internal:r11-finalize", + RequestDigest: "digest-r11-finalize", Actor: "admin", TargetSnapshotID: target}, + governance.SyncStages(), now); err != nil { + t.Fatalf("create library job: %v", err) + } + // 生效事件必须引用真实 operation:登记前先落这条执行意图(真表,不是夹具)。 + if _, _, err := store.EnsureLibraryOperation(ctx, governance.LibraryOperation{ID: operation, Scope: scope, + Kind: governance.LibraryJobSync, TargetSnapshotID: target, RequestDigest: "digest-r11-finalize", + OperationKey: "r11-finalize", Actor: "admin", CreatedAt: now}); err != nil { + t.Fatalf("ensure library operation: %v", err) + } + // 这次作业确实持有两把维护锁:收尾失败后必须仍然持有(页面显示维护中)。 + if _, err := store.AcquireLibraryMaintenance(ctx, postgresstore.LibraryMaintenance{Scope: scope, + OwnerJobID: jobID, TargetIdentity: "scope=" + scope, Level: "library", State: "acquired", + IngressState: "closed", Services: []string{"app"}}, now); err != nil { + t.Fatalf("acquire library maintenance: %v", err) + } + if _, err := store.AcquireInstanceMaintenance(ctx, postgresstore.LibraryInstanceMaintenance{Instance: instance, + OwnerJobID: jobID, OwnerScope: scope, TargetFingerprint: "fingerprint-r11", + Level: "instance", Services: []string{"app"}, IngressState: "closed", State: "acquired"}, now); err != nil { + t.Fatalf("acquire instance maintenance: %v", err) + } + // 完整锚点:真实字节数与写集合摘要。缺任何一项,收尾都该拒绝登记而不是补一份空台账。 + if err := store.RecordLibraryVersion(ctx, governance.LibraryVersion{ + ID: governance.LibraryVersionID(governance.LibraryVersionProductionPrebackup, scope, backup), + Scope: scope, Kind: governance.LibraryVersionProductionPrebackup, SnapshotID: backup, + SourceJobID: jobID, CreatedBy: "tester", + Evidence: map[string]any{"backup_snapshot": backup, "backup_bytes": float64(4096), + "writeset_digest": "writeset-digest-r11", "writeset_rows": float64(7)}, + CreatedAt: now, + }); err != nil { + t.Fatalf("record prebackup version: %v", err) + } + + // 目标内容落盘且计数:任何“再来一次”的重写都会让计数增长。 + root := t.TempDir() + published := filepath.Join(root, "target-content.txt") + if err := os.WriteFile(published, []byte("published-v1"), 0o600); err != nil { + t.Fatal(err) + } + applies := 1 // 内容写入(含校验)已经发生过一次 + writer := &libraryAttemptWriter{Store: store, attempt: governance.LibraryAttempt{ + OperationID: operation, JobID: jobID, Owner: "queue-r11-finalize"}} + recorder := libraryStageRecorder{store: store, jobID: jobID, scope: scope, operationID: operation} + payload := libraryReleasePayload{LibraryJobID: jobID, Scope: scope, TargetSnapshotID: target, FinalizeOnly: true} + previous := governance.LibraryJob{ID: jobID, Scope: scope, Kind: governance.LibraryJobSync, + SnapshotID: backup, TargetSnapshotID: target} + grant := governance.LibraryReleaseAuthorization{AuthorizedBy: "admin", Scope: scope, SnapshotID: target} + + // 1) 事件登记失败(这里用真实数据缺口:锚点里没有写集合摘要)必须拒绝登记, + // 不写生效版本、不进入终态、不重写目标。 + if err := store.RecordLibraryVersion(ctx, governance.LibraryVersion{ + ID: governance.LibraryVersionID(governance.LibraryVersionProductionPrebackup, scope, backup+"-noanchor"), + Scope: scope, Kind: governance.LibraryVersionProductionPrebackup, SnapshotID: backup + "-noanchor", + SourceJobID: jobID + "-noanchor", CreatedBy: "tester", + Evidence: map[string]any{"backup_snapshot": backup + "-noanchor"}, + CreatedAt: now, + }); err != nil { + t.Fatalf("record anchorless prebackup: %v", err) + } + badBoundary := payload + badBoundary.TargetSnapshotID = target + "-noanchor" + badPrevious := previous + badPrevious.SnapshotID = backup + "-noanchor" + if _, err := rebuildSuccessBoundary(ctx, writer, recorder, badBoundary, badPrevious, + governance.LibraryJobSync, grant); err == nil { + t.Fatal("anchorless prebackup was accepted as a success boundary") + } + if _, found, err := store.LibraryVersionByRef(ctx, scope, governance.LibraryVersionProductionEffective, + jobID, target+"-noanchor"); err != nil || found { + t.Fatalf("refused registration still wrote an effective version: found=%v err=%v", found, err) + } + if job, err := store.LibraryJob(ctx, jobID); err != nil || job.State == governance.LibraryJobSucceeded { + t.Fatalf("refused registration reported success: state=%v err=%v", job.State, err) + } + + // 2) journal 终态之后、释放维护占用这一步失败:不许报成功,锁必须继续持有。 + failing := &r11FinishFaultStore{Store: store, applies: &applies, failOnRelease: true, + releaseFailure: errors.New("injected: scope maintenance release failed after terminal journal")} + boundary := successBoundary{Ready: true, Backup: backup, Target: target, FinishedAt: now} + if err := finishLibrarySuccess(ctx, failing, r11HealthyTarget{}, instance, scope, jobID, boundary); err == nil { + t.Fatal("finish reported success even though the maintenance release failed") + } + if job, err := store.LibraryJob(ctx, jobID); err != nil || job.State != governance.LibraryJobFailed { + t.Fatalf("job must be failed after finalize failure: state=%v err=%v", job.State, err) + } + held, err := store.LibraryMaintenanceOf(ctx, scope) + if err != nil || held == nil || held.OwnerJobID != jobID || held.ReleasedAt != nil { + t.Fatalf("scope maintenance must stay held by this job: %+v err=%v", held, err) + } + if held.State != "needs_restore" { + t.Fatalf("held maintenance state = %q, want needs_restore", held.State) + } + if applies != 1 { + t.Fatalf("finalize failure rewrote target content: applies=%d", applies) + } + content, err := os.ReadFile(published) + if err != nil || string(content) != "published-v1" { + t.Fatalf("target bytes changed during finalize failure: %q err=%v", content, err) + } + + // 3) 修复只补收尾:同一个持久凭据再收尾一次即可成功,且仍然不重写。 + repaired := &r11FinishFaultStore{Store: store, applies: &applies} + if err := finishLibrarySuccess(ctx, repaired, r11HealthyTarget{}, instance, scope, jobID, boundary); err != nil { + t.Fatalf("finalize-only repair failed: %v", err) + } + if job, err := store.LibraryJob(ctx, jobID); err != nil || job.State != governance.LibraryJobSucceeded { + t.Fatalf("job not succeeded after repair: state=%v err=%v", job.State, err) + } + released, err := store.LibraryMaintenanceOf(ctx, scope) + if err != nil || released == nil || released.ReleasedAt == nil { + t.Fatalf("scope maintenance not released after repair: %+v err=%v", released, err) + } + if applies != 1 { + t.Fatalf("finalize-only repair rewrote target content: applies=%d", applies) + } + content, err = os.ReadFile(published) + if err != nil || string(content) != "published-v1" { + t.Fatalf("target bytes changed during repair: %q err=%v", content, err) + } + + // 4) current/event 与实际内容一致:补登记的生效版本恰好一条,重复收尾不再新增。 + if _, err := rebuildSuccessBoundary(ctx, writer, recorder, payload, previous, + governance.LibraryJobSync, grant); err != nil { + t.Fatalf("rebuild boundary after repair: %v", err) + } + if _, err := rebuildSuccessBoundary(ctx, writer, recorder, payload, previous, + governance.LibraryJobSync, grant); err != nil { + t.Fatalf("idempotent rebuild: %v", err) + } + current, found, err := store.LibraryCurrentVersion(ctx, scope) + if err != nil || !found || current.SnapshotID != target || current.SourceJobID != jobID { + t.Fatalf("current does not point at the repaired snapshot: %+v found=%v err=%v", current, found, err) + } + versions, err := store.LibraryVersionsBySnapshot(ctx, scope, target) + if err != nil { + t.Fatalf("read effective versions: %v", err) + } + same := 0 + for _, version := range versions { + if version.Kind == governance.LibraryVersionProductionEffective { + same++ + } + } + if same != 1 { + t.Fatalf("effective version rows for %s = %d, want exactly 1", target, same) + } +} diff --git a/cmd/worker/library_grant_revoke_r11_integration_test.go b/cmd/worker/library_grant_revoke_r11_integration_test.go new file mode 100644 index 0000000..d8e2b2f --- /dev/null +++ b/cmd/worker/library_grant_revoke_r11_integration_test.go @@ -0,0 +1,102 @@ +package main + +import ( + "context" + "strings" + "testing" + "time" + + "knowledge-governance/internal/governance" + "knowledge-governance/internal/libraryrelease" +) + +// r11RevokingBackups 在真实预备份完成之后撤销授权:这正是"排空之后、首次写之前" +// 被撤销的那个窗口,不是凭空造一个失败。 +type r11RevokingBackups struct { + inner libraryrelease.BackupStore + after func() +} + +func (b r11RevokingBackups) Prepare(ctx context.Context, id string, current libraryrelease.CurrentState) (libraryrelease.BackupRef, error) { + ref, err := b.inner.Prepare(ctx, id, current) + if err == nil && b.after != nil { + b.after() + } + return ref, err +} + +// B30:授权在预备份之后被撤销,必须一笔目标写都不发生;同一链路在没有撤销时 +// 正常完成(正例对照,证明这条门不是靠"永远失败"通过的)。 +func TestR11RevokedAuthorizationStopsBeforeFirstWrite(t *testing.T) { + store, _ := openLedgerStore(t) + ctx := context.Background() + now := time.Now().UTC() + const ( + scope = "internal" + jobID = "libsync-r11-revoke" + snapshot = "control-snap-r11-revoke" + target = "target-snap-r11-revoke" + params = "params-r11-revoke" + operation = "libop-r11-revoke" + backup = "backup-snap-r11-revoke" + authID = "libauth-r11-revoke" + ) + if _, _, err := store.CreateLibraryJob(ctx, governance.LibraryJob{ID: jobID, Scope: scope, + Kind: governance.LibraryJobSync, IdempotencyKey: "library.sync:internal:r11-revoke", + RequestDigest: params, Actor: "admin", TargetSnapshotID: target}, governance.SyncStages(), now); err != nil { + t.Fatalf("create library job: %v", err) + } + if _, _, err := store.EnsureLibraryOperation(ctx, governance.LibraryOperation{ID: operation, Scope: scope, + Kind: governance.LibraryJobSync, TargetSnapshotID: target, RequestDigest: params, + OperationKey: "r11-revoke", Actor: "admin", CreatedAt: now}); err != nil { + t.Fatalf("ensure library operation: %v", err) + } + if err := store.CreateLibraryAuthorization(ctx, governance.LibraryReleaseAuthorization{ID: authID, Scope: scope, + SnapshotID: target, ParamsDigest: params, AuthorizedBy: "admin", ExpiresAt: now.Add(time.Hour), CreatedAt: now}); err != nil { + t.Fatalf("create authorization: %v", err) + } + grant := libraryrelease.Grant{Target: scope, SnapshotID: target, ParamsDigest: params, + ExpiresAt: now.Add(time.Hour), AuthorizedBy: "admin"} + request := libraryrelease.Request{JobID: jobID, Target: scope, SnapshotID: target, + ParamsDigest: params, Now: now, Grant: grant} + backups := ledgerTestBackups{ref: libraryrelease.BackupRef{ID: "backup-" + backup, SnapshotID: backup, + Bytes: 4096, Universe: map[string]libraryrelease.TableFingerprint{"resources": {Count: 1, Digest: "universe"}}}} + + // 正例对照:授权有效时同一条链路写完四个阶段。 + control := &planningTarget{} + controlTarget := &contentTrackedTarget{inner: control, jobID: jobID, onApply: func() {}, + revalidateGrant: revalidateLibraryGrant(store)} + if out := libraryrelease.Run(ctx, request, controlTarget, backups, nil); out.State != "succeeded" { + t.Fatalf("control run did not succeed with a live authorization: %+v", out) + } + if control.applied != 4 { + t.Fatalf("control run applied %d stages, want 4", control.applied) + } + + // 撤销后:预备份成功、授权随即失效,写集合都不该被算出来(那会分配序列)。 + guarded := &planningTarget{} + guardedTarget := &contentTrackedTarget{inner: guarded, jobID: jobID, onApply: func() {}, + revalidateGrant: revalidateLibraryGrant(store)} + revoking := r11RevokingBackups{inner: backups, after: func() { + if err := store.RevokeLibraryAuthorization(ctx, authID, time.Now().UTC()); err != nil { + t.Fatalf("revoke authorization: %v", err) + } + }} + out := libraryrelease.Run(ctx, request, guardedTarget, revoking, nil) + if out.State != "failed" { + t.Fatalf("revoked authorization still produced state %q: %+v", out.State, out) + } + if !strings.Contains(out.Error, "持久授权") { + t.Fatalf("refusal reason does not name the persisted authorization: %q", out.Error) + } + if guarded.applied != 0 || guarded.planned != 0 { + t.Fatalf("revoked authorization wrote target: applied=%d planned=%d", guarded.applied, guarded.planned) + } + if out.Backup.SnapshotID != backup || !strings.Contains(out.Recovery, "预备份保留") { + t.Fatalf("prebackup must be preserved for a retry: backup=%+v recovery=%q", out.Backup, out.Recovery) + } + // 撤销是持久的:再读一次仍然查不到有效授权。 + if _, ok, err := store.ActiveLibraryAuthorization(ctx, scope, target, params, time.Now().UTC()); err != nil || ok { + t.Fatalf("revocation did not persist: ok=%v err=%v", ok, err) + } +} diff --git a/cmd/worker/library_lease_test.go b/cmd/worker/library_lease_test.go new file mode 100644 index 0000000..fdcc985 --- /dev/null +++ b/cmd/worker/library_lease_test.go @@ -0,0 +1,61 @@ +package main + +import ( + "context" + "errors" + "testing" + "time" +) + +func TestContractLeaseLossWaitsForActualWriteExit(t *testing.T) { + lost := errors.New("lease lost") + entered := make(chan struct{}) + cancelled := make(chan struct{}) + release := make(chan struct{}) + finished := make(chan error, 1) + go func() { + finished <- runWithLibraryLease(context.Background(), time.Millisecond, func(context.Context) error { <-entered; return lost }, func(ctx context.Context) error { close(entered); <-ctx.Done(); close(cancelled); <-release; return nil }) + }() + select { + case <-cancelled: + case <-time.After(time.Second): + t.Fatal("loss did not cancel actual writer") + } + select { + case <-finished: + t.Fatal("returned while actual write still running") + default: + } + close(release) + select { + case err := <-finished: + if !errors.Is(err, lost) { + t.Fatalf("loss hidden: %v", err) + } + case <-time.After(time.Second): + t.Fatal("writer not joined") + } +} + +func TestContractLeaseRenewsDuringLongWrite(t *testing.T) { + renewed := make(chan struct{}, 1) + err := runWithLibraryLease(context.Background(), time.Millisecond, func(context.Context) error { + select { + case renewed <- struct{}{}: + default: + } + return nil + }, func(ctx context.Context) error { + select { + case <-renewed: + return nil + case <-time.After(time.Second): + return errors.New("no renewal") + case <-ctx.Done(): + return ctx.Err() + } + }) + if err != nil { + t.Fatal(err) + } +} diff --git a/internal/httpapi/library_baseline_mutex_test.go b/internal/httpapi/library_baseline_mutex_test.go index 842afc2..512a1ac 100644 --- a/internal/httpapi/library_baseline_mutex_test.go +++ b/internal/httpapi/library_baseline_mutex_test.go @@ -45,6 +45,21 @@ func (s *baselineMutexStore) CreateLibraryJob(ctx context.Context, job governanc return s.fakeLibraryStore.CreateLibraryJob(ctx, job, stages, now) } +func (s *baselineMutexStore) CreateLibraryDispatch(ctx context.Context, job governance.LibraryJob, stages []string, handoff bool, now time.Time) (governance.LibraryJob, bool, error) { + if s.activeByScope == nil { + s.activeByScope = map[string]string{} + } + if s.activeByScope[job.Scope] != "" { + return governance.LibraryJob{}, false, governance.ErrLibraryJobActive + } + created, reused, err := s.fakeLibraryStore.CreateLibraryDispatch(ctx, job, stages, handoff, now) + if err == nil { + s.activeByScope[job.Scope] = created.ID + s.enqueues++ + } + return created, reused, err +} + func (s *baselineMutexStore) Enqueue(ctx context.Context, request jobs.EnqueueRequest, now time.Time) (*jobs.Job, error) { s.enqueues++ return s.fakeLibraryStore.fakeJobStore.Enqueue(ctx, request, now) diff --git a/internal/httpapi/library_dispatch_fixture_test.go b/internal/httpapi/library_dispatch_fixture_test.go new file mode 100644 index 0000000..b7a54f9 --- /dev/null +++ b/internal/httpapi/library_dispatch_fixture_test.go @@ -0,0 +1,33 @@ +package httpapi + +import ( + "context" + "knowledge-governance/internal/governance" + "knowledge-governance/internal/jobs" + "time" +) + +// In-memory API fixture mirrors dispatch shape; atomicity is tested against PG. +func (s *fakeLibraryStore) CreateLibraryDispatch(ctx context.Context, job governance.LibraryJob, stages []string, handoff bool, now time.Time) (governance.LibraryJob, bool, error) { + created, reused, err := s.CreateLibraryJob(ctx, job, stages, now) + if err != nil { + return created, reused, err + } + if reused && (created.State != governance.LibraryJobPending || created.QueueJobID != "") { + return created, reused, nil + } + id, kind, payload, err := governance.LibraryQueueRequest(handoff, created.ID, created.Scope, created.TargetSnapshotID, "library."+string(created.Kind)) + if err != nil { + return created, reused, err + } + queued, err := s.Enqueue(ctx, jobs.EnqueueRequest{ID: id, Type: kind, Payload: payload, AvailableAt: now, MaxAttempts: 1, IdempotencyKey: kind + ".queue:" + created.ID}, now) + if err != nil { + s.lastJob = governance.LibraryJob{} + return governance.LibraryJob{}, false, err + } + if err = s.AttachLibraryQueueJob(ctx, created.ID, queued.ID, now); err != nil { + return created, reused, err + } + created.QueueJobID = queued.ID + return created, reused, nil +} diff --git a/internal/httpapi/library_flow_test.go b/internal/httpapi/library_flow_test.go index c588453..d1fd197 100644 --- a/internal/httpapi/library_flow_test.go +++ b/internal/httpapi/library_flow_test.go @@ -18,6 +18,7 @@ import ( // 复用既有 fakeJobStore 提供 Store 的其余方法,只覆盖整库作业这几个。 type fakeLibraryStore struct { + sourceCandidate *governance.LibraryVersion fakeJobStore grant *governance.LibraryReleaseAuthorization versions []governance.LibraryVersion @@ -345,8 +346,11 @@ func TestLibrarySyncEnqueueCreatesJobOnlyWithGrant(t *testing.T) { store.enqueueEchoRequestedID = true config := Config{Store: store, ProductionReleaseRequestsEnabled: true, ProductionBackupRestoreVerified: true, LibraryProductionDatabaseURL: "postgres://prod.invalid/db", LibraryProductionInternalKB: "kb-int", LibraryCapacityBudgetBytes: 1 << 40} + sourceID := bindSourceFixture(t, &config, store, &target) + digest, _ = librarySyncParamsDigest("internal", target) body := `{"scope":"internal","target_snapshot_id":"` + target + `"}` + body = sourceRequestBody(t, body, sourceID) // 先没有授权 recorder := httptest.NewRecorder() librarySyncEnqueue(recorder, httptest.NewRequest(http.MethodPost, "/api/v1/library/syncs", strings.NewReader(body)), config) @@ -393,6 +397,7 @@ func TestLibraryOverviewShowsLatestPrebackupWhenTargetDiffers(t *testing.T) { SnapshotID: sealed, CreatedAt: now.Add(-2 * time.Hour)}, }} config := Config{Store: store, LibraryArchiveRoot: root, LibraryCapacityBudgetBytes: 1 << 30} + bindSourceFixture(t, &config, store, &sealed) request := httptest.NewRequest(http.MethodGet, "/api/v1/library/overview?scope=internal", nil) recorder := httptest.NewRecorder() libraryOverviewHandler(recorder, request, config) @@ -510,7 +515,10 @@ func TestLibrarySyncEnqueueUsesExactCurrentVersionBeyondWindow(t *testing.T) { config := Config{Store: store, ProductionReleaseRequestsEnabled: true, ProductionBackupRestoreVerified: true, LibraryProductionDatabaseURL: "postgres://prod.invalid/db", LibraryProductionInternalKB: "kb-int", LibraryCapacityBudgetBytes: 1 << 40} + sourceID := bindSourceFixture(t, &config, store, &target) + digest, _ = librarySyncParamsDigest("internal", target) body := `{"scope":"internal","target_snapshot_id":"` + target + `"}` + body = sourceRequestBody(t, body, sourceID) recorder := httptest.NewRecorder() librarySyncEnqueue(recorder, httptest.NewRequest(http.MethodPost, "/api/v1/library/syncs", strings.NewReader(body)), config) if recorder.Code != http.StatusAccepted { diff --git a/internal/httpapi/library_intent_test.go b/internal/httpapi/library_intent_test.go index 4dcc7f8..c563884 100644 --- a/internal/httpapi/library_intent_test.go +++ b/internal/httpapi/library_intent_test.go @@ -18,7 +18,8 @@ import ( // 判据:换 operation_key ⇒ 新 operation(ID 不同、作业幂等键不同); // 同一个 operation_key ⇒ 同一 operation(重放)。 func TestLibrarySyncNewIntentReExecutesInsteadOfReusingHistory(t *testing.T) { - target := "snap-1" + root := libraryFixtureRoot(t) + target := sealSharedVersions(t, root, 1, 4)[0] digest, err := librarySyncParamsDigest("internal", target) if err != nil { t.Fatal(err) @@ -36,14 +37,19 @@ func TestLibrarySyncNewIntentReExecutesInsteadOfReusingHistory(t *testing.T) { return store } config := func(store *fakeLibraryStore) Config { - return Config{Store: store, ProductionReleaseRequestsEnabled: true, ProductionBackupRestoreVerified: true, + c := Config{Store: store, LibraryArchiveRoot: root, ProductionReleaseRequestsEnabled: true, ProductionBackupRestoreVerified: true, LibraryProductionDatabaseURL: "postgres://prod.invalid/db", LibraryProductionInternalKB: "kb-int", LibraryCapacityBudgetBytes: 1 << 40} + bindSourceFixture(t, &c, store, &target) + return c } post := func(store *fakeLibraryStore, body string) *httptest.ResponseRecorder { + c := config(store) + id, _ := configuredLibrarySource(c, "internal").ID() + body = sourceRequestBody(t, body, id) recorder := httptest.NewRecorder() librarySyncEnqueue(recorder, httptest.NewRequest(http.MethodPost, "/api/v1/library/syncs", - strings.NewReader(body)), config(store)) + strings.NewReader(body)), c) return recorder } withKey := `{"scope":"internal","target_snapshot_id":"` + target + `","operation_key":"%s"}` @@ -85,7 +91,8 @@ func TestLibrarySyncNewIntentReExecutesInsteadOfReusingHistory(t *testing.T) { // 同一个意图键配上不同快照 = 冲突,不能悄悄共享谱系。 func TestLibrarySyncIntentKeyReusedWithAnotherSnapshotConflicts(t *testing.T) { - target := "snap-1" + root := libraryFixtureRoot(t) + target := sealSharedVersions(t, root, 1, 4)[0] digest, _ := librarySyncParamsDigest("internal", target) now := time.Now().UTC() store := &fakeLibraryStore{current: &governance.LibraryVersion{ID: "ver-prod", Scope: "internal", @@ -101,7 +108,9 @@ func TestLibrarySyncIntentKeyReusedWithAnotherSnapshotConflicts(t *testing.T) { config := Config{Store: store, ProductionReleaseRequestsEnabled: true, ProductionBackupRestoreVerified: true, LibraryProductionDatabaseURL: "postgres://prod.invalid/db", LibraryProductionInternalKB: "kb-int", LibraryCapacityBudgetBytes: 1 << 40} - body := `{"scope":"internal","target_snapshot_id":"` + target + `","operation_key":"intent-1"}` + config.LibraryArchiveRoot = root + sourceID := bindSourceFixture(t, &config, store, &target) + body := sourceRequestBody(t, `{"scope":"internal","target_snapshot_id":"`+target+`","operation_key":"intent-1"}`, sourceID) recorder := httptest.NewRecorder() librarySyncEnqueue(recorder, httptest.NewRequest(http.MethodPost, "/api/v1/library/syncs", strings.NewReader(body)), config) if recorder.Code != http.StatusConflict { diff --git a/internal/httpapi/library_legacy_source_test.go b/internal/httpapi/library_legacy_source_test.go new file mode 100644 index 0000000..9fef8ab --- /dev/null +++ b/internal/httpapi/library_legacy_source_test.go @@ -0,0 +1,67 @@ +package httpapi + +import ( + "context" + "errors" + "knowledge-governance/internal/governance" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" +) + +type legacySourceAPIStore struct { + fakeLibraryStore + calls int + actor string + source governance.LibrarySourceIdentity + err error +} + +func (s *legacySourceAPIStore) BindLegacyLibrarySource(_ context.Context, _ string, _ string, source governance.LibrarySourceIdentity, actor string, _ time.Time) error { + s.calls++ + s.actor = actor + s.source = source + return s.err +} +func TestContractLegacySourceAssociationAPI(t *testing.T) { + for _, role := range []string{roleViewer, roleEngineer, roleAdmin} { + store := &legacySourceAPIStore{} + config := Config{Store: store, LibrarySourceProject: "configured-project", LibrarySourceApp: "configured-app", LibrarySourceTenantID: 10000, LibrarySourceInternalKB: "configured-kb"} + request := httptest.NewRequest(http.MethodPost, "/api/v1/library/source-associations", strings.NewReader(`{"scope":"internal","snapshot_id":"exact-snapshot"}`)) + request = request.WithContext(context.WithValue(request.Context(), sessionKey{}, sessionIdentity{Username: "real-session-actor", Role: role})) + response := httptest.NewRecorder() + libraryLegacySourceBind(response, request, config) + if role == roleAdmin { + if response.Code != 200 || store.calls != 1 || store.actor != "real-session-actor" || store.source.Project != "configured-project" || store.source.KnowledgeBaseID != "configured-kb" { + t.Fatal("association contract", response.Code, response.Body.String()) + } + } else if response.Code != 403 || store.calls != 0 { + t.Fatal("non-admin associated source") + } + } + if classifyRole("POST", "/api/v1/library/source-associations") != roleAdmin { + t.Fatal("route is not administrator only") + } +} +func TestContractLegacySourceAssociationAPIRejectsSpoofAndEvidenceFailure(t *testing.T) { + for _, body := range []string{`{"scope":"internal","snapshot_id":"x","actor":"forged"}`, `{"scope":"internal","snapshot_id":"x","source_identity":{"project":"forged"}}`, `{"scope":"internal","snapshot_id":"x"} {}`} { + store := &legacySourceAPIStore{} + req := httptest.NewRequest("POST", "/", strings.NewReader(body)) + req = req.WithContext(context.WithValue(req.Context(), sessionKey{}, sessionIdentity{Username: "admin", Role: roleAdmin})) + out := httptest.NewRecorder() + libraryLegacySourceBind(out, req, Config{Store: store}) + if out.Code != 400 || store.calls != 0 { + t.Fatal("spoofed or trailing payload accepted") + } + } + store := &legacySourceAPIStore{err: errors.New("original proof mismatch")} + req := httptest.NewRequest("POST", "/", strings.NewReader(`{"scope":"internal","snapshot_id":"x"}`)) + req = req.WithContext(context.WithValue(req.Context(), sessionKey{}, sessionIdentity{Username: "admin", Role: roleAdmin})) + out := httptest.NewRecorder() + libraryLegacySourceBind(out, req, Config{Store: store, LibrarySourceProject: "p", LibrarySourceApp: "app", LibrarySourceTenantID: 1, LibrarySourceInternalKB: "kb"}) + if out.Code != 409 { + t.Fatal("unproven association reported success") + } +} diff --git a/internal/httpapi/library_overview_empty_test.go b/internal/httpapi/library_overview_empty_test.go index fc32142..104660b 100644 --- a/internal/httpapi/library_overview_empty_test.go +++ b/internal/httpapi/library_overview_empty_test.go @@ -30,6 +30,7 @@ func TestEmptyTargetOverviewAndEnqueueAgree(t *testing.T) { } return true, nil, nil }} + sourceID := bindSourceFixture(t, &config, store, &target) rec := httptest.NewRecorder() libraryOverviewHandler(rec, httptest.NewRequest(http.MethodGet, "/api/v1/library/overview?scope=internal", nil), config) var overview libraryOverview @@ -40,7 +41,7 @@ func TestEmptyTargetOverviewAndEnqueueAgree(t *testing.T) { t.Fatalf("failed=%v gate=%+v", failed, overview.Gate) } rec = httptest.NewRecorder() - librarySyncEnqueue(rec, httptest.NewRequest(http.MethodPost, "/api/v1/library/syncs", strings.NewReader(`{"scope":"internal","target_snapshot_id":"`+target+`"}`)), config) + librarySyncEnqueue(rec, httptest.NewRequest(http.MethodPost, "/api/v1/library/syncs", strings.NewReader(sourceRequestBody(t, `{"scope":"internal","target_snapshot_id":"`+target+`"}`, sourceID))), config) if failed { if rec.Code != http.StatusServiceUnavailable || store.createN != 0 { t.Fatalf("unreachable target enqueued: %d %s", rec.Code, rec.Body.String()) diff --git a/internal/httpapi/library_source_contract_test.go b/internal/httpapi/library_source_contract_test.go new file mode 100644 index 0000000..afee0f9 --- /dev/null +++ b/internal/httpapi/library_source_contract_test.go @@ -0,0 +1,23 @@ +package httpapi + +import ( + "knowledge-governance/internal/governance" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" +) + +func TestContractSyncRejectsUnboundSourceBeforeCreatingJob(t *testing.T) { + store := &fakeLibraryStore{current: &governance.LibraryVersion{SnapshotID: "current"}, grant: &governance.LibraryReleaseAuthorization{Scope: "internal", SnapshotID: "foreign", ExpiresAt: time.Now().Add(time.Hour)}} + digest, _ := librarySyncParamsDigest("internal", "foreign") + store.grant.ParamsDigest = digest + config := Config{Store: store, ProductionReleaseRequestsEnabled: true, ProductionBackupRestoreVerified: true, LibraryProductionDatabaseURL: "postgres://unreachable.invalid/db", LibraryCapacityBudgetBytes: 1 << 40} + request := httptest.NewRequest(http.MethodPost, "/api/v1/library/syncs", strings.NewReader(`{"scope":"internal","target_snapshot_id":"foreign"}`)) + response := httptest.NewRecorder() + librarySyncEnqueue(response, request, config) + if store.createN != 0 { + t.Fatalf("unbound foreign source created %d jobs; response=%s", store.createN, response.Body.String()) + } +} diff --git a/internal/httpapi/library_source_fixture_test.go b/internal/httpapi/library_source_fixture_test.go new file mode 100644 index 0000000..705a188 --- /dev/null +++ b/internal/httpapi/library_source_fixture_test.go @@ -0,0 +1,63 @@ +package httpapi + +import ( + "context" + "encoding/json" + "knowledge-governance/internal/governance" + "knowledge-governance/internal/librarysnapshot" + "testing" +) + +func (f *fakeLibraryStore) LibrarySourceCandidate(_ context.Context, scope, sourceID string) (governance.LibraryVersion, bool, error) { + if f.sourceCandidate != nil && f.sourceCandidate.Scope == scope && f.sourceCandidate.Evidence["source_id"] == sourceID { + return *f.sourceCandidate, true, nil + } + return governance.LibraryVersion{}, false, nil +} + +// These fixtures now contain the same capture identity and real immutable +// manifest required by the production admission path. No production bypass. +func bindSourceFixture(t *testing.T, config *Config, store *fakeLibraryStore, target *string) string { + t.Helper() + if config.LibraryArchiveRoot == "" { + config.LibraryArchiveRoot = libraryFixtureRoot(t) + *target = sealSharedVersions(t, config.LibraryArchiveRoot, 1, 4)[0] + } + archive, err := librarysnapshot.Open(config.LibraryArchiveRoot, 256*1024*1024) + if err != nil { + t.Fatal(err) + } + defer archive.Close() + manifest, err := archive.Load(*target) + if err != nil { + t.Fatal(err) + } + config.LibrarySourceProject = "fixture-project" + config.LibrarySourceApp = "fixture-app" + config.LibrarySourceTenantID = manifest.TenantID + config.LibrarySourceInternalKB = manifest.KnowledgeBaseID + source := configuredLibrarySource(*config, "internal") + id, err := source.ID() + if err != nil { + t.Fatal(err) + } + store.sourceCandidate = &governance.LibraryVersion{Scope: "internal", Kind: governance.LibraryVersionTestSealed, SnapshotID: *target, Evidence: map[string]any{"source_id": id}} + if store.grant != nil { + store.grant.SnapshotID = *target + store.grant.ParamsDigest, _ = librarySyncParamsDigest("internal", *target) + } + return id +} +func sourceRequestBody(t *testing.T, body, id string) string { + t.Helper() + var v map[string]any + if err := json.Unmarshal([]byte(body), &v); err != nil { + t.Fatal(err) + } + v["source_id"] = id + raw, err := json.Marshal(v) + if err != nil { + t.Fatal(err) + } + return string(raw) +} diff --git a/internal/libraryfreeze/recover_window_test.go b/internal/libraryfreeze/recover_window_test.go index b2fc1bf..378b97b 100644 --- a/internal/libraryfreeze/recover_window_test.go +++ b/internal/libraryfreeze/recover_window_test.go @@ -127,7 +127,7 @@ func TestRecoverWindowRequiresPersistedBackup(t *testing.T) { } } -// 目标换了(指纹不一致)就不许拿旧窗口收尾。 +// 目标换了(指纹不一致)就不许拿旧窗口收尾:另一个目标上不许有任何写/停动作。 func TestRecoverWindowRejectsDifferentTarget(t *testing.T) { _, c, e := instanceFixture(t) stopAllServices(c) @@ -137,11 +137,15 @@ func TestRecoverWindowRejectsDifferentTarget(t *testing.T) { if err := e.save(heldJournal("job-other", strings.Repeat("a", 64), strings.Repeat("b", 64))); err != nil { t.Fatal(err) } + restored, verified := false, false if _, err := e.RecoverWindow(context.Background(), "job-other", - restorerFunc(func(context.Context, string) error { return nil }), - verifierFunc(func(context.Context, string) (string, error) { return "x", nil })); err == nil { + restorerFunc(func(context.Context, string) error { restored = true; return nil }), + verifierFunc(func(context.Context, string) (string, error) { verified = true; return "x", nil })); err == nil { t.Fatal("recovery accepted another target's journal") } + if restored || verified { + t.Fatalf("recovery touched another target: restored=%v verified=%v", restored, verified) + } } // 后台任务还在跑时不许开窗口(HTTP 排空覆盖不到它们)。 diff --git a/internal/libraryrelease/release_test.go b/internal/libraryrelease/release_test.go index 997ea19..0319bad 100644 --- a/internal/libraryrelease/release_test.go +++ b/internal/libraryrelease/release_test.go @@ -119,7 +119,8 @@ func TestRunRefusesExpiredOrMismatchedGrantBeforeTouchingTarget(t *testing.T) { mutate func(*Request) want error }{ - {"expired", func(r *Request) { r.Now = r.Grant.ExpiresAt.Add(time.Minute) }, ErrGrantExpired}, + // Run uses the live clock, not the caller's diagnostic timestamp. + {"expired", func(r *Request) { r.Grant.ExpiresAt = time.Now().Add(-time.Minute) }, ErrGrantExpired}, {"other target", func(r *Request) { r.Target = "external-prod" }, ErrGrantTarget}, {"other snapshot", func(r *Request) { r.SnapshotID = "snap-2" }, ErrGrantSnapshot}, {"params changed", func(r *Request) { r.ParamsDigest = "digest-2" }, ErrGrantParams}, diff --git a/internal/libraryrelease/writeset_version_contract_test.go b/internal/libraryrelease/writeset_version_contract_test.go new file mode 100644 index 0000000..0be15f9 --- /dev/null +++ b/internal/libraryrelease/writeset_version_contract_test.go @@ -0,0 +1,43 @@ +package libraryrelease + +import ( + "crypto/sha256" + "encoding/hex" + "encoding/json" + "testing" +) + +// Literal canonical bytes follow d0c6d57's V1 field order, not today's struct. +const historicalV1Canonical = `{"version":1,"job_id":"job-v1","target":"internal","tenant_id":10001,"knowledge_base_id":"kb-target","backup_snapshot_id":"before","target_snapshot_id":"source","created_at":"2026-01-01T00:00:00Z","rows":[],"universe":{"chunks":{"count":0,"digest":"empty"}},"digest":""}` + +func TestContractHistoricalV1CanonicalBytesFrozen(t *testing.T) { + var set WriteSet + if err := json.Unmarshal([]byte(historicalV1Canonical), &set); err != nil { + t.Fatal(err) + } + raw, err := set.CanonicalBytes() + if err != nil { + t.Fatal(err) + } + if string(raw) != historicalV1Canonical { + t.Fatalf("V1 bytes changed: %s", raw) + } + hash := sha256.Sum256([]byte(historicalV1Canonical)) + set.Digest = hex.EncodeToString(hash[:]) + if err := set.Verify(); err != nil { + t.Fatal(err) + } +} + +func TestContractV1CannotCarryNewExecutionSemantics(t *testing.T) { + var set WriteSet + if err := json.Unmarshal([]byte(historicalV1Canonical), &set); err != nil { + t.Fatal(err) + } + set.ContractVersion = 1 + set.SourceTenantID = 10000 + set.SourceKnowledgeBaseID = "source" + if err := set.Seal(); err == nil { + t.Fatal("new execution fields were sealed as historical V1") + } +} diff --git a/internal/librarysnapshot/archive_directory_durability_test.go b/internal/librarysnapshot/archive_directory_durability_test.go new file mode 100644 index 0000000..27962b8 --- /dev/null +++ b/internal/librarysnapshot/archive_directory_durability_test.go @@ -0,0 +1,40 @@ +package librarysnapshot + +import ( + "errors" + "os" + "testing" +) + +func TestArchiveOpenPersistsDirectoryEntriesAndPropagatesSyncFailure(t *testing.T) { + root := t.TempDir() + if err := os.Chmod(root, 0700); err != nil { + t.Fatal(err) + } + calls := 0 + archive, err := openArchive(root, 1024*1024, func(r *os.Root) error { calls++; return syncRoot(r) }) + if err != nil { + t.Fatal(err) + } + archive.Close() + if calls != 2 { + t.Fatalf("root and root-parent durability missing: sync calls=%d", calls) + } + for _, failAt := range []int{1, 2} { + injected := errors.New("directory fsync failed") + n := 0 + archive, err = openArchive(root, 1024*1024, func(r *os.Root) error { + n++ + if n == failAt { + return injected + } + return syncRoot(r) + }) + if !errors.Is(err, injected) || archive != nil { + if archive != nil { + archive.Close() + } + t.Fatal("directory fsync failure did not block archive publication", err) + } + } +} diff --git a/internal/platform/postgres/library_dispatch_test.go b/internal/platform/postgres/library_dispatch_test.go new file mode 100644 index 0000000..6995d28 --- /dev/null +++ b/internal/platform/postgres/library_dispatch_test.go @@ -0,0 +1,39 @@ +package postgres + +import ( + "context" + "knowledge-governance/internal/governance" + "testing" + "time" +) + +func TestContractDispatchAttachFailureLeavesNoQueueOrBusinessJob(t *testing.T) { + store, pool := newIdentityStore(t) + ctx := context.Background() + now := time.Now().UTC() + if _, err := pool.Exec(ctx, `CREATE FUNCTION fail_dispatch_attach() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF NEW.queue_job_id <> '' THEN RAISE EXCEPTION 'injected attach failure'; END IF; RETURN NEW; END $$; CREATE TRIGGER fail_attach BEFORE UPDATE ON library_jobs FOR EACH ROW EXECUTE FUNCTION fail_dispatch_attach()`); err != nil { + t.Fatal(err) + } + job := governance.LibraryJob{ID: "atomic-dispatch", Scope: "internal", Kind: governance.LibraryJobSync, RequestDigest: "request", IdempotencyKey: "intent-atomic", TargetSnapshotID: "snapshot"} + if _, _, err := store.CreateLibraryDispatch(ctx, job, governance.SyncStages(), false, now); err == nil { + t.Fatal("injected attach did not fail") + } + var business, queue int + if err := pool.QueryRow(ctx, `SELECT (SELECT count(*) FROM library_jobs),(SELECT count(*) FROM jobs)`).Scan(&business, &queue); err != nil { + t.Fatal(err) + } + if business != 0 || queue != 0 { + t.Fatalf("partial dispatch escaped transaction: business=%d queue=%d", business, queue) + } + if _, err := pool.Exec(ctx, `DROP TRIGGER fail_attach ON library_jobs`); err != nil { + t.Fatal(err) + } + first, reused, err := store.CreateLibraryDispatch(ctx, job, governance.SyncStages(), false, now) + if err != nil || reused || first.QueueJobID == "" { + t.Fatalf("dispatch after failure: %+v %v %v", first, reused, err) + } + replay, reused, err := store.CreateLibraryDispatch(ctx, job, governance.SyncStages(), false, now) + if err != nil || !reused || replay.QueueJobID != first.QueueJobID { + t.Fatalf("dispatch replay: %+v %v %v", replay, reused, err) + } +} diff --git a/internal/platform/postgres/library_execution_test.go b/internal/platform/postgres/library_execution_test.go new file mode 100644 index 0000000..6cd1da8 --- /dev/null +++ b/internal/platform/postgres/library_execution_test.go @@ -0,0 +1,51 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + "testing" + "time" +) + +func TestContractExecutionMutexWaitsForActualWriter(t *testing.T) { + store, _ := newIdentityStore(t) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + key := fmt.Sprintf("isolated-%s-%d", t.Name(), time.Now().UnixNano()) + entered := make(chan struct{}) + release := make(chan struct{}) + finished := make(chan error, 1) + go func() { + finished <- store.WithLibraryExecution(ctx, key, func(ctx context.Context, ping func(context.Context) error) error { + if err := ping(ctx); err != nil { + return err + } + close(entered) + <-ctx.Done() + <-release + return ctx.Err() + }) + }() + select { + case <-entered: + case err := <-finished: + t.Fatalf("first executor: %v", err) + case <-time.After(5 * time.Second): + t.Fatal("first executor timeout") + } + cancel() + called := false + err := store.WithLibraryExecution(context.Background(), key, func(context.Context, func(context.Context) error) error { called = true; return nil }) + close(release) + if err2 := <-finished; !errors.Is(err2, context.Canceled) { + t.Fatalf("first executor exit: %v", err2) + } + if !errors.Is(err, ErrLibraryExecutionBusy) || called { + t.Fatalf("cancelled but still-writing executor was overlapped: err=%v called=%v", err, called) + } + called = false + if err = store.WithLibraryExecution(context.Background(), key, func(context.Context, func(context.Context) error) error { called = true; return nil }); err != nil || !called { + t.Fatalf("finished executor not released: %v %v", err, called) + } +} diff --git a/internal/platform/postgres/library_lease_contract_test.go b/internal/platform/postgres/library_lease_contract_test.go new file mode 100644 index 0000000..96d8e3c --- /dev/null +++ b/internal/platform/postgres/library_lease_contract_test.go @@ -0,0 +1,59 @@ +package postgres + +import ( + "context" + "errors" + "knowledge-governance/internal/governance" + "testing" + "time" +) + +func TestContractExpiredAttemptCannotRenewOrWrite(t *testing.T) { + store, pool := newIdentityStore(t) + ctx := context.Background() + now := time.Now().UTC() + seedOperationJob(t, store, pool, "internal", "contract-expired", "sync", now) + attempt, err := store.BeginLibraryAttempt(ctx, "contract-expired", "writer", time.Minute, now) + if err != nil { + t.Fatal(err) + } + if _, err = pool.Exec(ctx, `UPDATE library_jobs SET lease_until=now()-interval '1 minute'; UPDATE library_attempts SET lease_until=now()-interval '1 minute'`); err != nil { + t.Fatal(err) + } + if err = store.RenewLibraryAttempt(ctx, attempt, time.Minute, now); !errors.Is(err, governance.ErrLibraryEpochStale) { + t.Errorf("expired renewal resurrected ownership: %v", err) + } + if err = store.AdvanceLibraryJobGuarded(ctx, attempt, governance.LibraryJobRunning, "database", "", "", "", "", now); !errors.Is(err, governance.ErrLibraryEpochStale) { + t.Errorf("expired owner still writes: %v", err) + } +} + +func TestContractRenewalIsAtomicAcrossJobAndAttempt(t *testing.T) { + store, pool := newIdentityStore(t) + ctx := context.Background() + now := time.Now().UTC() + op := seedOperationJob(t, store, pool, "internal", "contract-revoke", "sync", now) + attempt, err := store.BeginLibraryAttempt(ctx, "contract-revoke", "writer", time.Minute, now) + if err != nil { + t.Fatal(err) + } + if err = store.RenewLibraryAttempt(ctx, attempt, 2*time.Minute, now); err != nil { + t.Fatalf("valid renewal: %v", err) + } + if _, err = pool.Exec(ctx, `UPDATE library_jobs SET lease_owner='new-owner' WHERE id=$1`, attempt.JobID); err != nil { + t.Fatal(err) + } + var before, after time.Time + if err = pool.QueryRow(ctx, `SELECT lease_until FROM library_attempts WHERE operation_id=$1`, op).Scan(&before); err != nil { + t.Fatal(err) + } + if err = store.RenewLibraryAttempt(ctx, attempt, time.Hour, now); !errors.Is(err, governance.ErrLibraryEpochStale) { + t.Errorf("revoked job still renews: %v", err) + } + if err = pool.QueryRow(ctx, `SELECT lease_until FROM library_attempts WHERE operation_id=$1`, op).Scan(&after); err != nil { + t.Fatal(err) + } + if !before.Equal(after) { + t.Fatal("partial renewal escaped transaction") + } +} diff --git a/internal/platform/postgres/library_legacy_source_test.go b/internal/platform/postgres/library_legacy_source_test.go new file mode 100644 index 0000000..c5d9945 --- /dev/null +++ b/internal/platform/postgres/library_legacy_source_test.go @@ -0,0 +1,152 @@ +package postgres + +import ( + "context" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "knowledge-governance/internal/governance" + "knowledge-governance/internal/libraryagent" + "knowledge-governance/internal/librarysnapshot" +) + +func legacySourceFixture(t *testing.T, store *Store) (string, string, governance.LibrarySourceIdentity) { + t.Helper() + ctx := context.Background() + root := t.TempDir() + if e := os.Chmod(root, 0700); e != nil { + t.Fatal(e) + } + archive, e := librarysnapshot.Open(root, 1024*1024) + if e != nil { + t.Fatal(e) + } + defer archive.Close() + m := librarysnapshot.Manifest{ValidationPolicy: librarysnapshot.ArtifactAcceptancePolicy, Format: librarysnapshot.Format, Scope: "internal", TenantID: 10000, KnowledgeBaseID: "kb-legacy", CreatedAt: time.Now().UTC(), Compatibility: librarysnapshot.Compatibility{WeKnoraVersion: "v0.7.1", SchemaVersion: 74, RetrieverEngine: "elasticsearch_v8", EmbeddingModel: "text-embedding-v4", EmbeddingDimension: 1024, IndexMappingSHA256: strings.Repeat("a", 64)}} + for _, entry := range []string{"database/knowledges", "database/chunks", "database/resources", "database/resource_bindings", "database/knowledge_tags", "database/knowledge_tag_relations", "wiki/wiki_pages", "wiki/wiki_folders", "wiki/wiki_page_issues", "wiki/wiki_log_entries", "index/chunks"} { + p, e := archive.Put(strings.NewReader("[]")) + if e != nil { + t.Fatal(e) + } + x := strings.Split(entry, "/") + p.Kind = x[0] + p.Name = x[1] + m.Parts = append(m.Parts, p) + } + snapshot, e := archive.Seal(m) + if e != nil { + t.Fatal(e) + } + source := governance.LibrarySourceIdentity{Project: "historical-project", App: "historical-app", Scope: m.Scope, TenantID: m.TenantID, KnowledgeBaseID: m.KnowledgeBaseID} + exp := libraryagent.NewExpectation(source.Project, source.App, "/original/archive") + e = store.RecordLibraryVersion(ctx, governance.LibraryVersion{ID: governance.LibraryVersionID(governance.LibraryVersionTestSealed, m.Scope, snapshot), Scope: m.Scope, Kind: governance.LibraryVersionTestSealed, SnapshotID: snapshot, SourceJobID: "legacy-capture", CreatedAt: m.CreatedAt, Evidence: map[string]any{"expectation_fingerprint": exp.Fingerprint, "capture_job": "legacy", "agent_result": map[string]any{"snapshot_id": snapshot, "agent_identity": map[string]any{"project": source.Project, "source_app": source.App, "archive_root": "/original/archive", "expectation_fingerprint": exp.Fingerprint}}}}) + if e != nil { + t.Fatal(e) + } + return root, snapshot, source +} + +func TestContractLegacySourceAssociationPreservesOriginalEvidence(t *testing.T) { + store, _ := newIdentityStore(t) + ctx := context.Background() + root, snapshot, source := legacySourceFixture(t, store) + binder, ok := any(store).(interface { + BindLegacyLibrarySource(context.Context, string, string, governance.LibrarySourceIdentity, string, time.Time) error + }) + if !ok { + t.Fatal("verified legacy source association unavailable") + } + original, e := os.ReadFile(filepath.Join(root, "versions", snapshot+".json")) + if e != nil { + t.Fatal(e) + } + if _, err := store.db.Exec(ctx, `UPDATE library_versions SET evidence=evidence || '{"large_proof":9223372036854775807}'::jsonb`); err != nil { + t.Fatal(err) + } + var originalEvidence string + if err := store.db.QueryRow(ctx, `SELECT evidence::text FROM library_versions`).Scan(&originalEvidence); err != nil { + t.Fatal(err) + } + id, _ := source.ID() + if _, found, e := store.LibrarySourceCandidate(ctx, source.Scope, id); e != nil || found { + t.Fatal("legacy unbound candidate adopted without explicit association", e) + } + now := time.Now().UTC() + if e = binder.BindLegacyLibrarySource(ctx, snapshot, root, source, "admin", now); e != nil { + t.Fatal(e) + } + candidate, found, e := store.LibrarySourceCandidate(ctx, source.Scope, id) + if e != nil || !found || candidate.SnapshotID != snapshot || candidate.SourceJobID != "legacy-capture" { + t.Fatal("association not readable", e) + } + if candidate.Evidence["capture_job"] != "legacy" { + t.Fatal("original evidence overwritten") + } + if e = binder.BindLegacyLibrarySource(ctx, snapshot, root, source, "another-admin", now.Add(time.Second)); e != nil { + t.Fatal("idempotent association", e) + } + var preserved bool + if err := store.db.QueryRow(ctx, `SELECT (evidence - 'source_id' - 'source_identity' - 'legacy_source_binding')=$1::jsonb FROM library_versions`, originalEvidence).Scan(&preserved); err != nil || !preserved { + t.Fatal("historical evidence changed, including bigint", err) + } + var bindingActor string + if err := store.db.QueryRow(ctx, `SELECT evidence->'legacy_source_binding'->>'actor' FROM library_versions`).Scan(&bindingActor); err != nil || bindingActor != "admin" { + t.Fatal("association replay rewrote audit actor", err) + } + changed := source + changed.App = "other-app" + if e = binder.BindLegacyLibrarySource(ctx, snapshot, root, changed, "admin", now); e == nil { + t.Fatal("source rebound") + } + after, e := os.ReadFile(filepath.Join(root, "versions", snapshot+".json")) + if e != nil || string(original) != string(after) { + t.Fatal("historical manifest changed", e) + } +} + +func TestContractLegacySourceAssociationRejectsInsufficientProof(t *testing.T) { + for _, scenario := range []string{"project", "tenant", "fingerprint", "missing-origin", "snapshot", "partial-binding"} { + t.Run(scenario, func(t *testing.T) { + store, _ := newIdentityStore(t) + ctx := context.Background() + root, snapshot, source := legacySourceFixture(t, store) + var mutation string + switch scenario { + case "project": + source.Project = "other-project" + case "tenant": + source.TenantID++ + case "fingerprint": + mutation = `UPDATE library_versions SET evidence=jsonb_set(evidence,'{expectation_fingerprint}','"wrong"'::jsonb)` + case "missing-origin": + mutation = `UPDATE library_versions SET evidence=evidence-'agent_result'` + case "snapshot": + mutation = `UPDATE library_versions SET evidence=jsonb_set(evidence,'{agent_result,snapshot_id}','"different"'::jsonb)` + case "partial-binding": + mutation = `UPDATE library_versions SET evidence=evidence || '{"source_identity":{}}'::jsonb` + } + if mutation != "" { + if _, e := store.db.Exec(ctx, mutation); e != nil { + t.Fatal(e) + } + } + var before string + if e := store.db.QueryRow(ctx, `SELECT evidence::text FROM library_versions`).Scan(&before); e != nil { + t.Fatal(e) + } + if e := store.BindLegacyLibrarySource(ctx, snapshot, root, source, "admin", time.Now()); e == nil { + t.Fatal("unproven source accepted") + } + var after string + if e := store.db.QueryRow(ctx, `SELECT evidence::text FROM library_versions`).Scan(&after); e != nil { + t.Fatal(e) + } + if before != after { + t.Fatal("rejected association changed historical evidence") + } + }) + } +} diff --git a/internal/platform/postgres/library_source_candidate_test.go b/internal/platform/postgres/library_source_candidate_test.go new file mode 100644 index 0000000..67b7374 --- /dev/null +++ b/internal/platform/postgres/library_source_candidate_test.go @@ -0,0 +1,42 @@ +package postgres + +import ( + "context" + "fmt" + "knowledge-governance/internal/governance" + "testing" + "time" +) + +func TestContractSourceCandidateBeyondHistoryWindow(t *testing.T) { + store, _ := newIdentityStore(t) + ctx := context.Background() + now := time.Now().UTC() + source := governance.LibrarySourceIdentity{Project: "source-project", App: "source-app", Scope: "internal", TenantID: 10000, KnowledgeBaseID: "kb-source"} + id, err := source.ID() + if err != nil { + t.Fatal(err) + } + for i := 0; i < 65; i++ { + sid := "other-source" + if i == 0 { + sid = id + } + snapshot := fmt.Sprintf("candidate-%d", i) + if err := store.RecordLibraryVersion(ctx, governance.LibraryVersion{ID: governance.LibraryVersionID(governance.LibraryVersionTestSealed, "internal", snapshot), Scope: "internal", Kind: governance.LibraryVersionTestSealed, SnapshotID: snapshot, Evidence: map[string]any{"source_id": sid}, CreatedAt: now.Add(time.Duration(i) * time.Second)}); err != nil { + t.Fatal(err) + } + } + candidate, found, err := store.LibrarySourceCandidate(ctx, "internal", id) + if err != nil || !found || candidate.SnapshotID != "candidate-0" { + t.Fatalf("exact candidate missing: %+v %v %v", candidate, found, err) + } + source.KnowledgeBaseID = "new-kb" + newID, _ := source.ID() + if _, found, err = store.LibrarySourceCandidate(ctx, "internal", newID); err != nil || found { + t.Fatalf("new source inherited old candidate: %v %v", found, err) + } + if _, found, err = store.LibrarySourceCandidate(ctx, "external", id); err != nil || found { + t.Fatalf("cross scope candidate: %v %v", found, err) + } +} diff --git a/internal/releaseadapter/v071/data_admission_fixture_r10_test.go b/internal/releaseadapter/v071/data_admission_fixture_r10_test.go new file mode 100644 index 0000000..5195f5d --- /dev/null +++ b/internal/releaseadapter/v071/data_admission_fixture_r10_test.go @@ -0,0 +1,82 @@ +package v071 + +import ( + "context" + "net/http/httptest" + "os" + "testing" + + "github.com/jackc/pgx/v5/pgxpool" + "knowledge-governance/internal/appconfig" + "knowledge-governance/internal/objectgateway" + postgresstore "knowledge-governance/internal/platform/postgres" + "knowledge-governance/internal/platform/postgres/pgtest" +) + +// Exported only into the test binary, so the external-package test exercises +// librarystack.OpenProductionStack without an import cycle or duplicated fixture. +type R10AdmissionFixture struct { + Context context.Context + Config appconfig.Config + Snapshot string + Exec func(string) + State func() map[string]any + Unchanged func(map[string]any) + Save func(string, any) +} + +func OpenR10AdmissionFixture(t *testing.T) R10AdmissionFixture { + t.Helper() + fx := openWriteSetFixtureWith(t, writeSetFixtureOptions{reset: true, embeddingDimension: 1024}) + seedTargetData(t, fx) + r10Exec(t, fx, `ALTER TABLE knowledge_bases ADD COLUMN embedding_model_id text; ALTER TABLE knowledge_bases ADD COLUMN vector_store_id text; + CREATE TABLE models(id text PRIMARY KEY,name text,parameters jsonb,deleted_at timestamptz); + CREATE TABLE vector_stores(id text PRIMARY KEY,engine_type text,index_config jsonb,deleted_at timestamptz); + INSERT INTO models VALUES('r10-model','text-embedding-v4','{"embedding_parameters":{"dimension":1024}}',NULL); + INSERT INTO vector_stores VALUES('r10-vector','elasticsearch_v8','{}',NULL); + UPDATE knowledge_bases SET embedding_model_id='r10-model',vector_store_id='r10-vector'`) + if _, e := fx.pool.Exec(fx.ctx, `UPDATE vector_stores SET index_config=jsonb_build_object('index_name',$1::text)`, fx.index); e != nil { + t.Fatal(e) + } + dsn := pgtest.IsolatedDatabaseURL(t, os.Getenv("KG_LIBRARY_TEST_DATABASE_URL")) + governancePool, e := pgxpool.New(fx.ctx, dsn) + if e != nil { + t.Fatal(e) + } + t.Cleanup(governancePool.Close) + if e = postgresstore.ApplyMigrations(fx.ctx, governancePool); e != nil { + t.Fatal(e) + } + if _, e = governancePool.Exec(fx.ctx, objectgateway.Schema); e != nil { + t.Fatal(e) + } + reader := gatewayReadOnlyGovernance(t, fx.ctx, governancePool, dsn) + authority := &GatewayGovernanceAuthority{Pool: reader, ArchiveRoot: fx.archiveRoot, TargetID: "r10-admission", Provider: "minio", Bucket: fx.bucket} + endpoint := os.Getenv("KG_LIBRARY_TEST_S3_ENDPOINT") + scope := objectgateway.Digest([]byte("minio\x00" + endpoint + "\x00" + fx.bucket)) + gateway := &objectgateway.Gateway{Pool: governancePool, Scope: scope, Backend: &objectgateway.S3Backend{Client: fx.objects.s3.client, Bucket: fx.bucket, MaxBytes: 1 << 20}, Authority: authority, Isolation: gatewayFixtureIsolation{}, MaxBytes: 1 << 20} + token := objectgateway.Digest([]byte("r10-admission-data")) + server := httptest.NewServer(objectgateway.HTTPServer{Gateway: gateway, DataToken: token, ControlToken: objectgateway.Digest([]byte("r10-admission-control"))}) + t.Cleanup(server.Close) + config := appconfig.Config{LibraryProductionDatabaseURL: os.Getenv("KG_LIBRARY_TEST_DATABASE_URL"), LibraryProductionElasticURL: fx.searchBase, LibraryProductionIndex: fx.index, LibraryProductionTenantID: wsTargetTenant, LibraryProductionInternalKB: wsTargetKB, LibraryProductionS3Endpoint: endpoint, LibraryProductionS3Provider: "minio", LibraryProductionS3Bucket: fx.bucket, LibraryProductionS3AccessKey: os.Getenv("KG_LIBRARY_TEST_S3_ACCESS_KEY"), LibraryProductionS3SecretKey: os.Getenv("KG_LIBRARY_TEST_S3_SECRET_KEY"), LibraryArchiveRoot: fx.archiveRoot, LibraryObjectGatewayURL: server.URL, LibraryObjectGatewayToken: token} + snapshot := sealSourceSnapshot(t, fx, nil) + state := func() map[string]any { + out := r10State(t, fx) + for _, table := range []string{"knowledge_bases", "models", "vector_stores", "schema_migrations"} { + var raw []byte + if e := fx.pool.QueryRow(fx.ctx, "SELECT coalesce(jsonb_agg(to_jsonb(t) ORDER BY to_jsonb(t)::text),'[]') FROM "+table+" t").Scan(&raw); e != nil { + t.Fatal(e) + } + out[table] = string(raw) + } + for _, table := range []string{"kg_object_gateway_plans", "kg_object_gateway_intents", "kg_object_gateway_receipts", "kg_object_gateway_deliveries", "kg_object_gateway_grants"} { + var count int64 + if e := governancePool.QueryRow(fx.ctx, "SELECT count(*) FROM "+table).Scan(&count); e != nil { + t.Fatal(e) + } + out[table] = count + } + return out + } + return R10AdmissionFixture{Context: fx.ctx, Config: config, Snapshot: snapshot, Exec: func(sql string) { r10Exec(t, fx, sql) }, State: state, Save: func(label string, value any) { r10Save(t, label, value) }} +} diff --git a/internal/releaseadapter/v071/data_admission_r10_test.go b/internal/releaseadapter/v071/data_admission_r10_test.go new file mode 100644 index 0000000..bcf7b29 --- /dev/null +++ b/internal/releaseadapter/v071/data_admission_r10_test.go @@ -0,0 +1,51 @@ +package v071_test + +import ( + "reflect" + "strings" + "testing" + + "knowledge-governance/internal/librarystack" + v071 "knowledge-governance/internal/releaseadapter/v071" +) + +func TestR10ProductionAdmissionIsolated(t *testing.T) { + cases := []struct{ name, sql, want string }{ + {"matching", "", ""}, + {"same-dimension-other-model", `UPDATE models SET name='different-embedding-model'`, "不同"}, + {"missing-model", `DELETE FROM models`, "模型"}, + {"empty-model-name", `UPDATE models SET name=''`, "模型"}, + {"graph-enabled", `UPDATE knowledge_bases SET indexing_strategy='{"graph_enabled":true}' WHERE id='kb-target'`, "图谱"}, + {"schema-dirty", `UPDATE schema_migrations SET dirty=true`, "dirty"}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + fx := v071.OpenR10AdmissionFixture(t) + if c.sql != "" { + fx.Exec(c.sql) + } + before := fx.State() + target, backups, e := librarystack.OpenProductionStack(fx.Context, fx.Config, "internal", fx.Snapshot, "") + if target != nil { + target.Close() + } + after := fx.State() + fx.Save("before", before) + fx.Save("after", after) + if !reflect.DeepEqual(before, after) { + t.Fatal("actual admission path changed PG/ES/object versions/gateway journal") + } + if c.want == "" { + if e != nil || target == nil || backups == nil { + t.Fatal("positive admission", e) + } + fx.Save("outcome", "matching contract admitted without business writes") + } else { + if e == nil || !strings.Contains(e.Error(), c.want) || target != nil || backups != nil { + t.Fatalf("wrong admission result target=%t backups=%t error=%v", target != nil, backups != nil, e) + } + fx.Save("rejection", e.Error()) + } + }) + } +} diff --git a/internal/releaseadapter/v071/data_boundary_r11_test.go b/internal/releaseadapter/v071/data_boundary_r11_test.go new file mode 100644 index 0000000..d5e6f95 --- /dev/null +++ b/internal/releaseadapter/v071/data_boundary_r11_test.go @@ -0,0 +1,126 @@ +package v071 + +import ( + "bytes" + "context" + "io" + "knowledge-governance/internal/libraryrelease" + "sync" + "testing" + "time" +) + +type r11BackupHook struct { + libraryrelease.BackupStore + after func() +} + +func (b r11BackupHook) Prepare(ctx context.Context, id string, current libraryrelease.CurrentState) (libraryrelease.BackupRef, error) { + ref, e := b.BackupStore.Prepare(ctx, id, current) + if e == nil { + b.after() + } + return ref, e +} + +type r11PlanHook struct { + libraryrelease.NoopRecorder + after func() +} + +func (r r11PlanHook) WriteSetPlanned(_ context.Context, _ libraryrelease.WriteSet) error { + r.after() + return nil +} +func TestR11GrantBoundaryIsolated(t *testing.T) { + for _, mode := range []string{"stale-request-clock", "expires-during-backup", "expires-before-first-apply"} { + t.Run(mode, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + req := requestFor(snapshot) + req.Grant.ExpiresAt = time.Now().Add(350 * time.Millisecond) + wait := func() { + if d := time.Until(req.Grant.ExpiresAt) + 10*time.Millisecond; d > 0 { + time.Sleep(d) + } + } + var backups libraryrelease.BackupStore = fx.backups(t, target) + var recorder libraryrelease.Recorder + if mode == "stale-request-clock" { + req.Now = time.Now().Add(-time.Hour) + req.Grant.ExpiresAt = time.Now().Add(-time.Second) + } + if mode == "expires-during-backup" { + backups = r11BackupHook{BackupStore: backups, after: wait} + } + if mode == "expires-before-first-apply" { + recorder = r11PlanHook{after: wait} + } + before := r10State(t, fx) + out := libraryrelease.Run(fx.ctx, req, target, backups, recorder) + r10Save(t, "outcome", out) + if out.State != "failed" || out.FailedAt != "" { + t.Errorf("expired authority performed business stages: %+v", out) + } + r10Unchanged(t, fx, before) + }) + } +} + +type r11ObjectReadHook struct { + *flakyStore + once sync.Once + after func(provider, path string) +} + +func (r *r11ObjectReadHook) Open(ctx context.Context, provider, path string) (io.ReadCloser, error) { + stream, e := r.flakyStore.Open(ctx, provider, path) + if e != nil { + return nil, e + } + data, e := io.ReadAll(stream) + stream.Close() + if e != nil { + return nil, e + } + r.once.Do(func() { r.after(provider, path) }) + return io.NopCloser(bytes.NewReader(data)), nil +} +func TestR11BackupMutationIsolated(t *testing.T) { + for _, mode := range []string{"es-body", "object-body", "object-same-bytes-new-version"} { + t.Run(mode, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + backups := fx.backups(t, target) + var injected map[string]any + backups.objects = &r11ObjectReadHook{flakyStore: fx.objects, after: func(provider, path string) { + if mode == "es-body" { + fx.indexDoc(t, "chunk-target", wsTargetTenant, wsTargetKB, "doc-target", "external edit") + } else { + body := "87654321" + if mode == "object-same-bytes-new-version" { + body = "12345678" + } + if e := fx.objects.s3.Put(fx.ctx, provider, path, bytes.NewReader([]byte(body)), 8); e != nil { + t.Fatal(e) + } + } + injected = r10State(t, fx) + r10Save(t, "external-change", injected) + }} + out := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, backups, nil) + r10Save(t, "outcome", out) + if injected == nil { + t.Fatal("injection not reached") + } + if out.State != "failed" || out.FailedAt != "" { + t.Errorf("changed backup admitted writes: %+v", out) + } + r10Unchanged(t, fx, injected) + }) + } +} diff --git a/internal/releaseadapter/v071/data_closure_r10_test.go b/internal/releaseadapter/v071/data_closure_r10_test.go new file mode 100644 index 0000000..e562d13 --- /dev/null +++ b/internal/releaseadapter/v071/data_closure_r10_test.go @@ -0,0 +1,243 @@ +package v071 + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "knowledge-governance/internal/libraryrelease" +) + +func TestR10SourceRelationClosureIsolated(t *testing.T) { + for _, mode := range []string{"missing-tag", "missing-knowledge", "cross-kb", "cross-tenant", "orphan-chunk", "unknown-owner", "missing-resource-owner", "null-owner"} { + t.Run(mode, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + r10Exec(t, fx, `INSERT INTO knowledge_tags(id,tenant_id,knowledge_base_id) VALUES('tag-target',10001,'kb-target'),('tag-other',10001,'kb-other'),('tag-foreign',10002,'kb-foreign')`) + switch mode { + case "missing-tag": + r10Exec(t, fx, `INSERT INTO knowledge_tag_relations VALUES('doc-target','absent')`) + case "missing-knowledge": + r10Exec(t, fx, `INSERT INTO knowledge_tag_relations VALUES('absent','tag-target')`) + case "cross-kb": + r10Exec(t, fx, `INSERT INTO knowledge_tag_relations VALUES('doc-target','tag-other')`) + case "cross-tenant": + r10Exec(t, fx, `INSERT INTO knowledge_tag_relations VALUES('doc-target','tag-foreign')`) + case "orphan-chunk": + r10Exec(t, fx, `UPDATE chunks SET knowledge_id='absent' WHERE id='chunk-target'`) + case "unknown-owner": + r10Exec(t, fx, `UPDATE resource_bindings SET owner_type='unknown-v071-shape' WHERE id='bind-target'`) + case "missing-resource-owner": + r10Exec(t, fx, `UPDATE resource_bindings SET owner_id='absent-owner' WHERE id='bind-target'`) + case "null-owner": + r10Exec(t, fx, `UPDATE resource_bindings SET owner_type=NULL,owner_id='doc-other' WHERE id='bind-target'`) + } + before := r10State(t, fx) + _, e := ExportLibrary(fx.ctx, fx.pool, PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}) + r10Unchanged(t, fx, before) + if e == nil { + t.Fatal("source silently excluded a scoped unresolved relationship") + } + r10Save(t, "rejection", e.Error()) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + r10Save(t, "existing-target-rejection", result) + if result.State != "failed" || result.FailedAt != "" { + t.Fatalf("existing unresolved target relationship reached writes: %+v", result) + } + r10Unchanged(t, fx, before) + }) + } +} +func TestR10IncomingRelationClosureIsolated(t *testing.T) { + for _, mode := range []string{"valid-new", "valid-existing", "missing-tag", "missing-knowledge", "cross-kb", "cross-tenant", "unknown-owner", "missing-resource"} { + t.Run(mode, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + positive := strings.HasPrefix(mode, "valid-") + if positive { + r10Exec(t, fx, `INSERT INTO knowledge_tags(id,tenant_id,knowledge_base_id) VALUES('tag-target',10001,'kb-target'),('tag-other',10001,'kb-other'); INSERT INTO knowledge_tag_relations(knowledge_id,tag_id) VALUES('doc-target','tag-target'),('doc-other','tag-other')`) + } + snapshot := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) { + parts["knowledge_tags"] = []map[string]any{{"id": "tag-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB}} + parts["knowledge_tag_relations"] = []map[string]any{{"knowledge_id": "doc-src", "tag_id": "tag-src"}} + switch mode { + case "valid-existing": + parts["knowledges"][0]["id"] = "doc-target" + parts["chunks"][0]["knowledge_id"] = "doc-target" + parts["resource_bindings"][0]["owner_id"] = "doc-target" + parts["knowledge_tags"][0]["id"] = "tag-target" + parts["knowledge_tag_relations"][0] = map[string]any{"knowledge_id": "doc-target", "tag_id": "tag-target"} + case "missing-tag": + parts["knowledge_tag_relations"][0]["tag_id"] = "missing" + case "missing-knowledge": + parts["knowledge_tag_relations"][0]["knowledge_id"] = "missing" + case "cross-kb": + parts["knowledge_tags"][0]["knowledge_base_id"] = wsOtherKB + case "unknown-owner": + parts["resource_bindings"][0]["owner_type"] = "unknown-v071-shape" + case "cross-tenant": + parts["knowledge_tags"][0]["tenant_id"] = 20000 + case "missing-resource": + parts["resource_bindings"][0]["resource_id"] = "absent-resource" + } + }) + before := r10State(t, fx) + target := fx.target(t) + result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + r10Save(t, "outcome", result) + if positive { + if result.State != "succeeded" { + t.Fatalf("nonempty tuple publication: %+v", result) + } + wantID := "doc-src:tag-src" + if mode == "valid-existing" { + wantID = "doc-target:tag-target" + } + found := false + for _, row := range result.Backup.WriteSet.Rows { + if row.Table == "knowledge_tag_relations" && row.ID == wantID { + found = true + if row.Existing != (mode == "valid-existing") { + t.Fatal("tuple existence misclassified", row) + } + } + } + if !found { + t.Fatal("tuple absent from frozen write set") + } + var outside int + if e := fx.pool.QueryRow(fx.ctx, `SELECT count(*) FROM knowledge_tag_relations WHERE knowledge_id='doc-other' AND tag_id='tag-other'`).Scan(&outside); e != nil || outside != 1 { + t.Fatal("outside tuple changed", e) + } + if e := target.Restore(fx.ctx, result.Backup); e != nil { + t.Fatal(e) + } + after := r10State(t, fx) + for _, key := range []string{"pg", "versions", "delete_markers"} { + if !reflect.DeepEqual(before[key], after[key]) { + t.Fatal("tuple rollback changed original data", key) + } + } + r10Save(t, "restored", after) + return + } + if result.State != "failed" || result.FailedAt != "" { + t.Fatalf("incoming unresolved reference passed preflight: %+v", result) + } + r10Unchanged(t, fx, before) + }) + } +} +func TestR10BodyOnlyResourceIsolated(t *testing.T) { + for _, mode := range []string{"knowledge-content", "wiki-content", "knowledge-metadata", "wiki-metadata"} { + t.Run(mode, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + r10Exec(t, fx, `DELETE FROM resource_bindings WHERE owner_id='doc-target'; UPDATE chunks SET content='plain' WHERE id='chunk-target'; ALTER TABLE knowledges ADD COLUMN content text; ALTER TABLE knowledges ADD COLUMN metadata jsonb; ALTER TABLE wiki_pages ADD COLUMN metadata jsonb`) + table, column := "knowledges", "content" + if strings.HasPrefix(mode, "wiki") { + table = "wiki_pages" + } + if strings.HasSuffix(mode, "metadata") { + column = "metadata" + } + value := any("![image](resource://" + wsHandleTarget + ")") + if column == "metadata" { + raw, _ := json.Marshal(map[string]any{"image_info": []any{map[string]string{"url": "resource://" + wsHandleTarget}}}) + value = string(raw) + } + if _, e := fx.pool.Exec(fx.ctx, fmt.Sprintf("UPDATE %s SET %s=$1 WHERE knowledge_base_id=$2", table, column), value, wsTargetKB); e != nil { + t.Fatal(e) + } + before := r10State(t, fx) + pg, e := ExportLibrary(fx.ctx, fx.pool, PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}) + if e != nil { + t.Fatal(e) + } + found := false + for _, row := range pg.Table("resources").Rows { + var id struct { + ID string `json:"id"` + } + _ = json.Unmarshal(row, &id) + if id.ID == "res-target" { + found = true + } + if id.ID == "res-orphan" { + t.Fatal("unowned historical resource adopted into source") + } + } + if !found { + t.Fatal("body/metadata resource not captured without binding") + } + if len(pg.Table("resource_bindings").Rows) != 0 { + t.Fatal("fixture unexpectedly had bindings") + } + r10Save(t, "captured-resources", pg.Table("resources")) + backup, e := exportLibraryBeforeImage(fx.ctx, fx.pool, PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}) + if e != nil { + t.Fatal(e) + } + found = false + for _, raw := range backup.Table("resources").Rows { + var row struct { + ID string `json:"id"` + } + _ = json.Unmarshal(raw, &row) + if row.ID == "res-target" { + found = true + } + } + if !found { + t.Fatal("body-only target resource missing from before-image") + } + r10Unchanged(t, fx, before) + snapshot := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) { + parts["resource_bindings"] = []map[string]any{} + parts["chunks"][0]["content"] = "plain source" + parts[table][0][column] = "![image](resource://" + wsHandleSource + ")" + if column == "metadata" { + parts[table][0][column] = map[string]any{"image_info": []any{map[string]string{"url": "resource://" + wsHandleSource}}} + } + }) + target := fx.target(t) + result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + r10Save(t, "publication", result) + if result.State != "succeeded" { + t.Fatalf("body-only publication: %+v", result) + } + if err := target.Restore(fx.ctx, result.Backup); err != nil { + t.Fatal(err) + } + after := r10State(t, fx) + for _, key := range []string{"pg", "versions", "delete_markers"} { + if !reflect.DeepEqual(before[key], after[key]) { + t.Fatalf("body-only restore changed %s including historical orphans", key) + } + } + r10Save(t, "restored", after) + }) + } +} +func TestR10UnknownResourceShapeIsolated(t *testing.T) { + for _, body := range []string{"resource://short", "resource://" + wsHandleTarget + "extra", "resource://" + wsHandleTarget + "?download=1", "resource:\\/\\/" + wsHandleTarget} { + t.Run(fmt.Sprint(len(body))+strings.ReplaceAll(body[len(body)-3:], "/", "_"), func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + if _, e := fx.pool.Exec(fx.ctx, `UPDATE wiki_pages SET content=$1 WHERE id='wiki-target'`, body); e != nil { + t.Fatal(e) + } + before := r10State(t, fx) + _, e := ExportLibrary(fx.ctx, fx.pool, PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}) + r10Unchanged(t, fx, before) + if e == nil { + t.Fatal("unknown resource reference shape silently accepted") + } + r10Save(t, "rejection", e.Error()) + }) + } +} diff --git a/internal/releaseadapter/v071/data_contract_r10_test.go b/internal/releaseadapter/v071/data_contract_r10_test.go new file mode 100644 index 0000000..164e24b --- /dev/null +++ b/internal/releaseadapter/v071/data_contract_r10_test.go @@ -0,0 +1,258 @@ +package v071 + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" + "reflect" + "strings" + "testing" + "time" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/s3" + "knowledge-governance/internal/libraryrelease" + "knowledge-governance/internal/librarysnapshot" +) + +func r10Save(t *testing.T, label string, value any) { + t.Helper() + root := os.Getenv("KG_R10_RUN") + if root == "" { + return + } + name := strings.NewReplacer("/", "_", " ", "_").Replace(t.Name()+"-"+label) + ".json" + data, e := json.MarshalIndent(value, "", " ") + if e != nil { + t.Fatal(e) + } + if e = os.WriteFile(filepath.Join(root, name), data, 0600); e != nil { + t.Fatal(e) + } +} +func r10Exec(t *testing.T, fx *writeSetFixture, sql string) { + t.Helper() + if _, e := fx.pool.Exec(fx.ctx, sql); e != nil { + t.Fatal(e) + } +} +func r10State(t *testing.T, fx *writeSetFixture) map[string]any { + t.Helper() + objects, e := fx.objects.s3.client.ListObjectVersions(fx.ctx, &s3.ListObjectVersionsInput{Bucket: aws.String(fx.bucket)}) + if e != nil { + t.Fatal(e) + } + if aws.ToBool(objects.IsTruncated) { + t.Fatal("truncated object evidence") + } + seq := map[string]any{} + for _, name := range []string{"chunks_seq_id_seq", "knowledge_tags_seq_id_seq", "wiki_log_entries_id_seq"} { + var exists bool + if e := fx.pool.QueryRow(fx.ctx, "SELECT to_regclass($1) IS NOT NULL", name).Scan(&exists); e != nil { + t.Fatal(e) + } + if exists { + var last int64 + var called bool + if e := fx.pool.QueryRow(fx.ctx, "SELECT last_value,is_called FROM "+name).Scan(&last, &called); e != nil { + t.Fatal(e) + } + seq[name] = []any{last, called} + } + } + r10Save(t, "namespace", map[string]string{"bucket": fx.bucket, "index": fx.index}) + return map[string]any{"pg": universeDump(t, fx.pool), "index": recoveryIndexReadback(t, fx), "versions": objects.Versions, "delete_markers": objects.DeleteMarkers, "sequences": seq} +} +func r10Unchanged(t *testing.T, fx *writeSetFixture, before map[string]any) { + t.Helper() + after := r10State(t, fx) + r10Save(t, "before", before) + r10Save(t, "after", after) + if !reflect.DeepEqual(before, after) { + t.Fatal("rejected contract changed rows, ES CAS, exact object versions or sequence state") + } +} +func r10Sequences(t *testing.T, fx *writeSetFixture) { + r10Exec(t, fx, `CREATE SEQUENCE chunks_seq_id_seq; ALTER TABLE chunks ADD COLUMN seq_id bigint NOT NULL DEFAULT nextval('chunks_seq_id_seq'); CREATE UNIQUE INDEX r10_chunks_seq ON chunks(seq_id); + CREATE SEQUENCE knowledge_tags_seq_id_seq; ALTER TABLE knowledge_tags ADD COLUMN seq_id bigint NOT NULL DEFAULT nextval('knowledge_tags_seq_id_seq'); CREATE UNIQUE INDEX r10_tags_seq ON knowledge_tags(seq_id); + CREATE SEQUENCE wiki_log_entries_id_seq; ALTER TABLE wiki_log_entries ALTER COLUMN id SET DEFAULT nextval('wiki_log_entries_id_seq'); ALTER SEQUENCE wiki_log_entries_id_seq OWNED BY wiki_log_entries.id; ALTER TABLE wiki_log_entries ADD PRIMARY KEY(id); + INSERT INTO knowledge_tags(id,tenant_id,knowledge_base_id) VALUES('tag-other',10001,'kb-other'); INSERT INTO wiki_log_entries(tenant_id,knowledge_base_id) VALUES(10001,'kb-other')`) +} +func r10LocalRows(parts map[string][]map[string]any) { + parts["chunks"][0]["seq_id"] = 10 + parts["knowledge_tags"] = []map[string]any{{"id": "tag-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "seq_id": 10}} + parts["wiki_log_entries"] = []map[string]any{{"id": 100, "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB}, {"id": 2, "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB}} +} +func TestR10SequenceRejectionIsolated(t *testing.T) { + for _, table := range []string{"chunks", "knowledge_tags", "wiki_log_entries"} { + for _, mode := range []string{"behind", "exhausted", "explicit-null"} { + t.Run(table+"-"+mode, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + r10Sequences(t, fx) + column := "seq_id" + if table == "wiki_log_entries" { + column = "id" + } + sequence := table + "_" + column + "_seq" + if mode == "behind" { + r10Exec(t, fx, fmt.Sprintf("SELECT setval('%s',1,false)", sequence)) + } + if mode == "exhausted" { + r10Exec(t, fx, fmt.Sprintf("SELECT setval('%s',9223372036854775807,true)", sequence)) + } + snapshot := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) { + r10LocalRows(parts) + if mode == "explicit-null" { + parts[table][0][column] = nil + } + }) + before := r10State(t, fx) + target := fx.target(t) + result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + r10Save(t, "outcome", result) + if result.State != "failed" || result.FailedAt != "" { + t.Fatalf("must reject before a business stage: %+v", result) + } + r10Unchanged(t, fx, before) + }) + } + } +} +func TestR10SequenceOrderingReplayIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + r10Sequences(t, fx) + r10Exec(t, fx, `ALTER TABLE chunks ADD COLUMN chunk_index integer DEFAULT 0; ALTER TABLE knowledge_tags ADD COLUMN sort_order integer DEFAULT 0; ALTER TABLE knowledge_tags ADD COLUMN created_at timestamptz DEFAULT '2026-01-01T00:00:00Z'`) + before := universeDump(t, fx.pool) + snapshot := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) { + r10LocalRows(parts) + parts["chunks"][0]["seq_id"] = 100 + parts["chunks"][0]["chunk_index"] = 0 + parts["chunks"] = append(parts["chunks"], map[string]any{"id": "chunk-src-2", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "knowledge_id": "doc-src", "content": "second chunk", "seq_id": 2, "chunk_index": 1}) + parts["knowledge_tags"][0]["seq_id"] = 100 + parts["knowledge_tags"] = append(parts["knowledge_tags"], map[string]any{"id": "tag-src-2", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "seq_id": 2}) + for _, row := range parts["knowledge_tags"] { + row["sort_order"] = 0 + row["created_at"] = "2026-01-01T00:00:00Z" + } + }) + target := fx.target(t) + result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if result.State != "succeeded" { + t.Fatalf("normal allocation: %+v", result) + } + r10Save(t, "plan", result.Backup.WriteSet) + var newest, older int64 + if e := fx.pool.QueryRow(fx.ctx, `SELECT max(id),min(id) FROM wiki_log_entries WHERE knowledge_base_id='kb-target'`).Scan(&newest, &older); e != nil { + t.Fatal(e) + } + if newest <= older { + t.Fatal("numeric log ordering collapsed") + } + var cursor int64 + if e := fx.pool.QueryRow(fx.ctx, `SELECT id FROM wiki_log_entries WHERE knowledge_base_id='kb-target' AND id<$1 ORDER BY id DESC LIMIT 1`, newest).Scan(&cursor); e != nil || cursor != older { + t.Fatal("consumer cursor order", e) + } + mapped := map[string]string{} + for _, m := range result.Backup.WriteSet.LocalIDs { + if m.Table == "wiki_log_entries" { + mapped[m.Source] = m.Target + } + } + if mapped["100"] != fmt.Sprint(newest) || mapped["2"] != fmt.Sprint(older) { + t.Fatal("mapping used lexical instead of numeric order") + } + var tagOrder, chunkOrder []string + if e := fx.pool.QueryRow(fx.ctx, `SELECT array_agg(id ORDER BY sort_order ASC, created_at DESC, seq_id DESC) FROM knowledge_tags WHERE knowledge_base_id='kb-target'`).Scan(&tagOrder); e != nil { + t.Fatal(e) + } + if e := fx.pool.QueryRow(fx.ctx, `SELECT array_agg(id ORDER BY chunk_index ASC) FROM chunks WHERE knowledge_base_id='kb-target'`).Scan(&chunkOrder); e != nil { + t.Fatal(e) + } + if !reflect.DeepEqual(tagOrder, []string{"tag-src", "tag-src-2"}) || !reflect.DeepEqual(chunkOrder, []string{"chunk-src", "chunk-src-2"}) { + t.Fatal("application sort changed after numeric remapping", tagOrder, chunkOrder) + } + for _, m := range result.Backup.WriteSet.LocalIDs { + if m.Table == "chunks" { + var id string + if e := fx.pool.QueryRow(fx.ctx, `SELECT id FROM chunks WHERE tenant_id=$1 AND seq_id=$2::bigint`, wsTargetTenant, m.Target).Scan(&id); e != nil || (m.Source == "100" && id != "chunk-src") || (m.Source == "2" && id != "chunk-src-2") { + t.Fatal("seq-ID consumer disagrees with frozen map", e) + } + } + } + r10Save(t, "consumer-orders", map[string]any{"tags": tagOrder, "chunks": chunkOrder, "wiki_desc": []int64{newest, older}, "wiki_cursor": cursor}) + published := r10State(t, fx) + next := fx.target(t) + if e := next.AdoptWriteSet(*result.Backup.WriteSet); e != nil { + t.Fatal(e) + } + for _, stage := range libraryrelease.Stages() { + if e := next.Apply(fx.ctx, stage, snapshot); e != nil { + t.Fatal(e) + } + } + r10Unchanged(t, fx, published) + if e := next.Restore(fx.ctx, result.Backup); e != nil { + t.Fatal(e) + } + if !reflect.DeepEqual(before, universeDump(t, fx.pool)) { + t.Fatal("rollback changed original local numbers") + } + if !reflect.DeepEqual(published["sequences"], r10State(t, fx)["sequences"]) { + t.Fatal("rollback rewound sequences") + } +} +func TestR10SourceSchemaBoundIsolated(t *testing.T) { + fx := openWriteSetFixtureWith(t, writeSetFixtureOptions{reset: true, embeddingDimension: 1024}) + seedTargetData(t, fx) + r10Sequences(t, fx) + fx.indexDoc(t, "chunk-target", wsTargetTenant, wsTargetKB, "doc-target", "图:resource://"+wsHandleTarget) + before := r10State(t, fx) + pg, e := ExportLibrary(fx.ctx, fx.pool, PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}) + if e != nil { + t.Fatal(e) + } + target := fx.target(t) + es, e := target.Search().ExportLibrary(fx.ctx, SearchIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}, 100) + if e != nil { + t.Fatal(e) + } + archive, e := librarysnapshot.Open(fx.archiveRoot, 128*1024*1024) + if e != nil { + t.Fatal(e) + } + defer archive.Close() + contract := librarysnapshot.Compatibility{WeKnoraVersion: "v0.7.1", SchemaVersion: 74, RetrieverEngine: "elasticsearch_v8", EmbeddingModel: "text-embedding-v4", EmbeddingDimension: 1024, IndexMappingSHA256: es.MappingSHA256} + id, e := ArchiveLibraryCandidate(fx.ctx, archive, "internal", PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}, contract, pg, es, fx.objects, time.Now().UTC()) + if e != nil { + t.Fatal(e) + } + manifest, e := archive.Load(id) + if e != nil { + t.Fatal(e) + } + r10Save(t, "manifest", manifest) + bound := false + for _, part := range manifest.Parts { + if part.Kind == "schema" && part.Name == "migration-catalog" { + bound = true + } + } + r10Unchanged(t, fx, before) + if !bound { + t.Fatal("captured source has no snapshot-bound schema catalog") + } + if _, e := target.preflightMigrationCatalog(fx.ctx, archive, manifest); e != nil { + t.Fatal("matching source schema rejected", e) + } + r10Exec(t, fx, `ALTER TABLE chunks ADD COLUMN r10_drift text`) + drifted := r10State(t, fx) + if _, e := target.preflightMigrationCatalog(fx.ctx, archive, manifest); e == nil || !strings.Contains(e.Error(), "source/target schema catalog mismatch") { + t.Fatal("source schema drift not rejected", e) + } else { + r10Save(t, "schema-drift-rejection", e.Error()) + } + r10Unchanged(t, fx, drifted) +} diff --git a/internal/releaseadapter/v071/data_matrix_r11_test.go b/internal/releaseadapter/v071/data_matrix_r11_test.go new file mode 100644 index 0000000..bc3df05 --- /dev/null +++ b/internal/releaseadapter/v071/data_matrix_r11_test.go @@ -0,0 +1,353 @@ +package v071 + +import ( + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "os" + "reflect" + "sort" + "strings" + "testing" + + "github.com/jackc/pgx/v5" + "knowledge-governance/internal/libraryrelease" +) + +type r11Column struct { + Table string `json:"table_name"` + Name string `json:"column_name"` + Type string `json:"type"` + Default string `json:"default_expr"` + Required bool `json:"not_null"` +} +type r11Catalog struct { + Columns []r11Column `json:"columns"` + Constraints []struct { + Table string `json:"table_name"` + Name string `json:"name"` + Definition string `json:"definition"` + } `json:"constraints"` + Indexes []struct { + Name string `json:"name"` + Definition string `json:"definition"` + } `json:"indexes"` + Sequences []struct { + Name string `json:"sequence"` + Start int64 `json:"seqstart"` + } `json:"sequences"` +} + +func r11CatalogData(t *testing.T) r11Catalog { + t.Helper() + raw, e := os.ReadFile("testdata/catalog-v071-r11.json") + if e != nil { + t.Fatal(e) + } + var c r11Catalog + if e = json.Unmarshal(raw, &c); e != nil { + t.Fatal(e) + } + return c +} +func r11Fill(t *testing.T, fx *writeSetFixture, table string, row map[string]any) map[string]any { + t.Helper() + if table == "resources" && row["location_hash"] == nil { + sum := sha256.Sum256([]byte(fmt.Sprint(row["physical_path"]))) + row["location_hash"] = hex.EncodeToString(sum[:]) + } + for _, c := range r11CatalogData(t).Columns { + if c.Table != table { + continue + } + if v, ok := row[c.Name]; ok && (v != nil || !c.Required) { + continue + } + expr := c.Default + if c.Name == "seq_id" { + expr = "10" + } + if table == "wiki_log_entries" && c.Name == "id" { + expr = "100" + } + if expr == "" { + if !c.Required { + row[c.Name] = nil + continue + } + switch c.Type { + case "bigint", "integer": + expr = "0" + case "boolean": + expr = "false" + default: + expr = "''" + } + } + var raw []byte + if e := fx.pool.QueryRow(fx.ctx, "SELECT to_jsonb(("+expr+")::"+c.Type+")").Scan(&raw); e != nil { + t.Fatal(table, c.Name, e) + } + var v any + dec := json.NewDecoder(strings.NewReader(string(raw))) + dec.UseNumber() + if e := dec.Decode(&v); e != nil { + t.Fatal(e) + } + row[c.Name] = v + } + raw, e := json.Marshal(row) + if e != nil { + t.Fatal(e) + } + var canonical []byte + if e = fx.pool.QueryRow(fx.ctx, "SELECT to_jsonb(jsonb_populate_record(NULL::"+table+",$1::jsonb))", raw).Scan(&canonical); e != nil { + t.Fatal(e) + } + dec := json.NewDecoder(strings.NewReader(string(canonical))) + dec.UseNumber() + if e = dec.Decode(&row); e != nil { + t.Fatal(e) + } + return row +} +func r11Insert(t *testing.T, fx *writeSetFixture, table string, row map[string]any) { + t.Helper() + r11Fill(t, fx, table, row) + keys := []string{} + for k := range row { + keys = append(keys, k) + } + sort.Strings(keys) + cols := []string{} + for _, k := range keys { + cols = append(cols, pgx.Identifier{k}.Sanitize()) + } + raw, e := json.Marshal(row) + if e != nil { + t.Fatal(e) + } + if _, e = fx.pool.Exec(fx.ctx, "INSERT INTO "+table+"("+strings.Join(cols, ",")+") SELECT "+strings.Join(cols, ",")+" FROM jsonb_populate_record(NULL::"+table+",$1::jsonb)", raw); e != nil { + t.Fatal(table, e) + } +} + +// Reconstruct only the ten migration tables from preserved real v071 catalog. +// The grant table is an inbound-FK fixture, not a claimed whole business mirror. +func r11Mirror(t *testing.T, fx *writeSetFixture) { + t.Helper() + old := universeDump(t, fx.pool) + c := r11CatalogData(t) + r10Exec(t, fx, `CREATE EXTENSION IF NOT EXISTS "uuid-ossp"; CREATE EXTENSION IF NOT EXISTS pg_trgm; DROP TABLE IF EXISTS resource_access_grants CASCADE; DROP TABLE `+strings.Join(productionLibraryTables, ",")+` CASCADE`) + for _, s := range c.Sequences { + r10Exec(t, fx, fmt.Sprintf("CREATE SEQUENCE %s START %d", s.Name, s.Start)) + } + for _, table := range productionLibraryTables { + defs := []string{} + for _, col := range c.Columns { + if col.Table != table { + continue + } + d := pgx.Identifier{col.Name}.Sanitize() + " " + col.Type + if col.Required { + d += " NOT NULL" + } + if col.Default != "" { + d += " DEFAULT " + col.Default + } + defs = append(defs, d) + } + r10Exec(t, fx, "CREATE TABLE "+table+"("+strings.Join(defs, ",")+")") + } + r10Exec(t, fx, `ALTER SEQUENCE wiki_log_entries_id_seq OWNED BY wiki_log_entries.id; CREATE TABLE resource_access_grants(id text,resource_id varchar(36))`) + names := map[string]bool{} + sort.SliceStable(c.Constraints, func(i, j int) bool { + return !strings.HasPrefix(c.Constraints[i].Definition, "FOREIGN KEY") && strings.HasPrefix(c.Constraints[j].Definition, "FOREIGN KEY") + }) + for _, constraint := range c.Constraints { + r10Exec(t, fx, "ALTER TABLE "+constraint.Table+" ADD CONSTRAINT "+constraint.Name+" "+constraint.Definition) + names[constraint.Name] = true + } + for _, index := range c.Indexes { + if !names[index.Name] { + r10Exec(t, fx, index.Definition) + } + } + n := int64(100000000) + for _, table := range []string{"knowledges", "chunks", "knowledge_tags", "knowledge_tag_relations", "resources", "resource_bindings", "wiki_folders", "wiki_pages", "wiki_page_issues", "wiki_log_entries"} { + for _, raw := range old[table] { + row := map[string]any{} + dec := json.NewDecoder(strings.NewReader(raw)) + dec.UseNumber() + if e := dec.Decode(&row); e != nil { + t.Fatal(e) + } + allowed := map[string]bool{} + for _, col := range c.Columns { + if col.Table == table { + allowed[col.Name] = true + } + } + for k := range row { + if !allowed[k] { + delete(row, k) + } + } + if table == "chunks" || table == "knowledge_tags" { + n++ + row["seq_id"] = n + } + r11Insert(t, fx, table, row) + } + } + r10Exec(t, fx, fmt.Sprintf("SELECT setval('chunks_seq_id_seq',%d,true);SELECT setval('knowledge_tags_seq_id_seq',%d,true)", n, n)) +} +func r11Source(t *testing.T, fx *writeSetFixture, tweak func(map[string][]map[string]any)) string { + return sealSourceSnapshot(t, fx, func(p map[string][]map[string]any) { + p["knowledge_tags"] = []map[string]any{{"id": "tag-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "name": "source-tag"}} + p["knowledge_tag_relations"] = []map[string]any{{"knowledge_id": "doc-src", "tag_id": "tag-src"}} + p["wiki_folders"] = []map[string]any{{"id": "folder-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "name": "folder", "parent_id": ""}} + p["wiki_pages"][0]["folder_id"] = "folder-src" + p["wiki_page_issues"] = []map[string]any{{"id": "issue-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "slug": "index", "issue_type": "review", "reported_by": "fixture", "description": "example"}} + p["wiki_log_entries"] = []map[string]any{{"id": 100, "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "action": "ingest", "knowledge_id": "doc-src", "pages_affected": []any{map[string]any{"slug": "index", "title": "historic title"}}}} + if tweak != nil { + tweak(p) + } + for table, rows := range p { + for _, row := range rows { + r11Fill(t, fx, table, row) + } + } + }) +} +func r11Reject(t *testing.T, fx *writeSetFixture, snapshot string) { + t.Helper() + before := r10State(t, fx) + target := fx.target(t) + out := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + r10Save(t, "outcome", out) + if out.State != "failed" || out.FailedAt != "" { + t.Errorf("expected pre-stage rejection: %+v", out) + } + r10Unchanged(t, fx, before) +} +func TestR11StableIdentityMatrixIsolated(t *testing.T) { + for _, table := range []string{"knowledges", "chunks", "knowledge_tags", "resources", "resource_bindings", "wiki_folders", "wiki_pages", "wiki_page_issues"} { + for _, foreign := range []string{"same-tenant-other-kb", "other-tenant"} { + t.Run(table+"/"+foreign, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + r11Mirror(t, fx) + tenant := uint64(wsTargetTenant) + kb := wsOtherKB + if foreign == "other-tenant" { + tenant = 10003 + kb = "kb-alien" + } + id := map[string]string{"knowledges": "doc-src", "chunks": "chunk-src", "knowledge_tags": "tag-src", "resources": "res-src", "resource_bindings": "bind-src", "wiki_folders": "folder-src", "wiki_pages": "wiki-src", "wiki_page_issues": "issue-src"}[table] + row := map[string]any{"id": id, "tenant_id": tenant, "knowledge_base_id": kb} + switch table { + case "chunks": + row["knowledge_id"] = "doc-other" + row["seq_id"] = int64(900000001) + case "resources": + delete(row, "knowledge_base_id") + row["handle"] = strings.Repeat("x", 22) + row["provider"] = "minio" + row["physical_path"] = "outside" + row["location_hash"] = "outside" + case "resource_bindings": + delete(row, "knowledge_base_id") + row["resource_id"] = "res-other" + row["owner_type"] = "knowledge" + row["owner_id"] = "doc-other" + row["relation"] = "preview" + case "wiki_pages", "wiki_page_issues": + row["slug"] = "foreign" + } + r11Insert(t, fx, table, row) + snapshot := r11Source(t, fx, nil) + r11Reject(t, fx, snapshot) + }) + } + } +} +func TestR11NaturalKeyMatrixIsolated(t *testing.T) { + for _, mode := range []string{"valid", "tag-name", "tag-name-soft-deleted", "binding-tuple", "folder-name", "folder-deleted-positive", "folder-parent-distinct-positive", "page-slug", "page-deleted-positive", "resource-handle", "resource-location", "resource-location-deleted-positive", "physical-key"} { + t.Run(mode, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + r11Mirror(t, fx) + if mode == "resource-handle" { + r10Exec(t, fx, `UPDATE resources SET handle='`+wsHandleSource+`' WHERE id='res-other'`) + } + if strings.HasPrefix(mode, "resource-location") { + path := wsLocator("backend-target", "minio", fx.bucket, wsTargetTenant, "res-src") + sum := sha256.Sum256([]byte(path)) + deleted := "NULL" + if strings.HasSuffix(mode, "positive") { + deleted = "now()" + } + r10Exec(t, fx, `UPDATE resources SET location_hash='`+hex.EncodeToString(sum[:])+`',deleted_at=`+deleted+` WHERE id='res-other'`) + } + if mode == "physical-key" { + if e := fx.objects.s3.Put(fx.ctx, "minio", wsLocator("backend-target", "minio", fx.bucket, wsTargetTenant, "res-src"), strings.NewReader("foreign-data"), 12); e != nil { + t.Fatal(e) + } + } + snapshot := r11Source(t, fx, func(p map[string][]map[string]any) { + table := "" + switch mode { + case "tag-name", "tag-name-soft-deleted": + table = "knowledge_tags" + case "binding-tuple": + table = "resource_bindings" + case "folder-name", "folder-deleted-positive", "folder-parent-distinct-positive": + table = "wiki_folders" + case "page-slug", "page-deleted-positive": + table = "wiki_pages" + } + if table == "" { + return + } + cp := map[string]any{} + for k, v := range p[table][0] { + cp[k] = v + } + cp["id"] = cp["id"].(string) + "-second" + if table == "knowledge_tags" { + cp["seq_id"] = 11 + } + if strings.Contains(mode, "deleted") { + cp["deleted_at"] = "2026-01-01T00:00:00Z" + } + if mode == "folder-parent-distinct-positive" { + cp["parent_id"] = "folder-src" + } + p[table] = append(p[table], cp) + }) + if mode != "valid" && !strings.HasSuffix(mode, "positive") { + r11Reject(t, fx, snapshot) + return + } + before := r10State(t, fx) + target := fx.target(t) + out := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + r10Save(t, "outcome", out) + if out.State != "succeeded" { + t.Fatalf("normal admitted data must succeed: %+v", out) + } + if e := target.Restore(fx.ctx, out.Backup); e != nil { + t.Fatal(e) + } + after := r10State(t, fx) + for _, key := range []string{"pg", "versions", "delete_markers"} { + if !reflect.DeepEqual(before[key], after[key]) { + t.Fatal("restore changed", key) + } + } + r10Save(t, "restored", after) + }) + } +} diff --git a/internal/releaseadapter/v071/data_resource_restore_r10_test.go b/internal/releaseadapter/v071/data_resource_restore_r10_test.go new file mode 100644 index 0000000..c173d10 --- /dev/null +++ b/internal/releaseadapter/v071/data_resource_restore_r10_test.go @@ -0,0 +1,42 @@ +package v071 + +import ( + "knowledge-governance/internal/libraryrelease" + "testing" +) + +func TestR10RestoreForeignResourceReferencesIsolated(t *testing.T) { + for _, mode := range []string{"unknown-binding", "foreign-wiki-body", "foreign-knowledge-metadata"} { + t.Run(mode, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + r10Exec(t, fx, `ALTER TABLE knowledges ADD COLUMN metadata jsonb`) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if result.State != "succeeded" { + t.Fatalf("prepare publication: %+v", result) + } + switch mode { + case "unknown-binding": + r10Exec(t, fx, `INSERT INTO resource_bindings(id,tenant_id,resource_id,owner_type,owner_id) VALUES('binding-unknown',10001,'res-src','unknown','outside-owner')`) + case "foreign-wiki-body": + if _, e := fx.pool.Exec(fx.ctx, `INSERT INTO wiki_pages(id,tenant_id,knowledge_base_id,slug,content) VALUES('foreign-wiki',10001,'kb-other','foreign',$1)`, "![external](resource://"+wsHandleSource+")"); e != nil { + t.Fatal(e) + } + case "foreign-knowledge-metadata": + if _, e := fx.pool.Exec(fx.ctx, `UPDATE knowledges SET metadata=jsonb_build_object('image_info',jsonb_build_object('url',$1::text)) WHERE id='doc-other'`, "resource://"+wsHandleSource); e != nil { + t.Fatal(e) + } + } + before := r10State(t, fx) + e := target.Restore(fx.ctx, result.Backup) + if e == nil { + t.Error("restore deleted a resource with an out-of-plan reference") + } else { + r10Save(t, "held", e.Error()) + } + r10Unchanged(t, fx, before) + }) + } +} diff --git a/internal/releaseadapter/v071/data_schema_r11_test.go b/internal/releaseadapter/v071/data_schema_r11_test.go new file mode 100644 index 0000000..e0bf1b0 --- /dev/null +++ b/internal/releaseadapter/v071/data_schema_r11_test.go @@ -0,0 +1,188 @@ +package v071 + +import ( + "encoding/json" + "knowledge-governance/internal/libraryrelease" + "knowledge-governance/internal/librarysnapshot" + "os" + "reflect" + "strings" + "testing" + "time" +) + +func TestR11CatalogBindingIsolated(t *testing.T) { + for _, mode := range []string{"matching", "default", "unique-predicate", "sequence-definition", "sequence-ownership", "incoming-fk", "outgoing-fk", "internal-local-fk", "generated", "trigger"} { + t.Run(mode, func(t *testing.T) { + fx := openWriteSetFixtureWith(t, writeSetFixtureOptions{reset: true, embeddingDimension: 1024}) + seedTargetData(t, fx) + r11Mirror(t, fx) + target := fx.target(t) + pg, e := ExportLibrary(fx.ctx, fx.pool, PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}) + if e != nil { + t.Fatal(e) + } + catalog, digest, e := target.migrationCatalog(fx.ctx) + if e != nil { + t.Fatal(e) + } + if !reflect.DeepEqual(catalog, pg.Catalog) { + t.Fatal("captured source and target catalogs differ") + } + expected := r11CatalogData(t) + var cols []r11Column + if e = json.Unmarshal(catalog["columns"], &cols); e != nil { + t.Fatal(e) + } + if !reflect.DeepEqual(cols, expected.Columns) { + t.Fatal("real v071 columns/defaults/types differ from reconstructed target") + } + var indexes []map[string]any + json.Unmarshal(catalog["indexes"], &indexes) + if len(indexes) != len(expected.Indexes) { + t.Fatal("missing actual indexes") + } + expectedRaw, e := os.ReadFile("testdata/catalog-v071-r11.json") + if e != nil { + t.Fatal(e) + } + var original map[string]json.RawMessage + json.Unmarshal(expectedRaw, &original) + for _, kind := range []string{"columns", "constraints", "indexes", "triggers", "relations"} { + var a, b any + json.Unmarshal(original[kind], &a) + json.Unmarshal(catalog[kind], &b) + if !reflect.DeepEqual(a, b) { + t.Fatal("catalog mismatch", kind) + } + } + r10Save(t, "source-catalog", pg.Catalog) + r10Save(t, "schema-digest", digest) + es, e := target.Search().ExportLibrary(fx.ctx, SearchIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}, 100) + if e != nil { + t.Fatal(e) + } + archive, e := librarysnapshot.Open(fx.archiveRoot, 128*1024*1024) + if e != nil { + t.Fatal(e) + } + defer archive.Close() + compatibility := librarysnapshot.Compatibility{WeKnoraVersion: "v0.7.1", SchemaVersion: 74, RetrieverEngine: "elasticsearch_v8", EmbeddingModel: "text-embedding-v4", EmbeddingDimension: 1024, IndexMappingSHA256: es.MappingSHA256} + snapshot, e := ArchiveLibraryCandidate(fx.ctx, archive, "internal", PostgresIdentity{TenantID: wsTargetTenant, KnowledgeBaseID: wsTargetKB}, compatibility, pg, es, fx.objects, time.Now().UTC()) + if e != nil { + t.Fatal(e) + } + if mode == "matching" { + before := r10State(t, fx) + manifest, e := archive.Load(snapshot) + if e != nil { + t.Fatal(e) + } + got, e := target.preflightMigrationCatalog(fx.ctx, archive, manifest) + if e != nil || got != digest { + t.Fatal(got, e) + } + r10Unchanged(t, fx, before) + return + } + statements := map[string]string{ + "default": `ALTER TABLE chunks ALTER COLUMN flags SET DEFAULT 7`, + "unique-predicate": `DROP INDEX idx_wiki_pages_kb_slug;CREATE UNIQUE INDEX idx_wiki_pages_kb_slug ON wiki_pages(knowledge_base_id,slug) WHERE deleted_at IS NOT NULL`, + "sequence-definition": `ALTER SEQUENCE chunks_seq_id_seq INCREMENT 2`, + "sequence-ownership": `ALTER SEQUENCE chunks_seq_id_seq OWNED BY chunks.seq_id`, + "incoming-fk": `CREATE TABLE outside_cursor(log_id bigint REFERENCES wiki_log_entries(id))`, + "outgoing-fk": `CREATE TABLE outside_models(id varchar(64) PRIMARY KEY);ALTER TABLE knowledges ADD FOREIGN KEY(embedding_model_id) REFERENCES outside_models(id)`, + "internal-local-fk": `ALTER TABLE wiki_page_issues ADD COLUMN log_id bigint REFERENCES wiki_log_entries(id)`, + "generated": `ALTER TABLE wiki_pages ADD COLUMN lower_slug text GENERATED ALWAYS AS(lower(slug)) STORED`, + "trigger": `CREATE FUNCTION r11_noop() RETURNS trigger LANGUAGE plpgsql AS 'BEGIN RETURN NEW; END';CREATE TRIGGER r11_noop BEFORE INSERT ON wiki_pages FOR EACH ROW EXECUTE FUNCTION r11_noop()`, + } + r10Exec(t, fx, statements[mode]) + r11Reject(t, fx, snapshot) + // An identically extended source/target must not make an unreviewed FK safe. + if strings.Contains(mode, "fk") { + now, _, e := target.migrationCatalog(fx.ctx) + if e != nil { + t.Fatal(e) + } + if e = validateMigrationCatalog(now); e == nil { + t.Fatal("unreviewed FK admitted when both sides match") + } + r10Save(t, "unknown-fk-rejection", e.Error()) + } + }) + } +} +func TestR11ReferenceAndCursorIsolated(t *testing.T) { + for _, mode := range []string{"valid", "linked-valid", "legacy-pages", "historical-log", "chunk-parent", "chunk-pre", "chunk-next", "chunk-tag", "wiki-folder", "folder-parent", "folder-cycle", "wiki-source", "wiki-chunk", "log-object-id", "log-array-number"} { + t.Run(mode, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + r11Mirror(t, fx) + snapshot := r11Source(t, fx, func(p map[string][]map[string]any) { + switch mode { + case "linked-valid": + p["chunks"] = append(p["chunks"], map[string]any{"id": "chunk-src-2", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "knowledge_id": "doc-src", "content": "second", "seq_id": 11, "pre_chunk_id": "chunk-src", "parent_chunk_id": "chunk-src"}) + p["chunks"][0]["next_chunk_id"] = "chunk-src-2" + p["chunks"][0]["tag_id"] = "tag-src" + p["wiki_pages"][0]["source_refs"] = []string{"doc-src|Source title"} + p["wiki_pages"][0]["chunk_refs"] = []string{"chunk-src-2"} + p["wiki_pages"][0]["page_metadata"] = map[string]any{"literal_number": 100, "tags": []string{"literal"}} + case "legacy-pages": + p["wiki_log_entries"][0]["pages_affected"] = []string{"index", "historic-removed-page"} + case "historical-log": + p["wiki_log_entries"][0]["knowledge_id"] = "deleted-knowledge" + p["wiki_log_entries"][0]["pages_affected"] = []any{map[string]any{"slug": "deleted-page", "title": "historic"}} + case "chunk-parent": + p["chunks"][0]["parent_chunk_id"] = "chunk-other" + case "chunk-pre": + p["chunks"][0]["pre_chunk_id"] = "chunk-other" + case "chunk-next": + p["chunks"][0]["next_chunk_id"] = "chunk-other" + case "chunk-tag": + p["chunks"][0]["tag_id"] = "tag-outside" + case "wiki-folder": + p["wiki_pages"][0]["folder_id"] = "foreign-folder" + case "folder-parent": + p["wiki_folders"][0]["parent_id"] = "foreign-folder" + case "folder-cycle": + p["wiki_folders"][0]["parent_id"] = "folder-src" + case "wiki-source": + p["wiki_pages"][0]["source_refs"] = []string{"doc-other"} + case "wiki-chunk": + p["wiki_pages"][0]["chunk_refs"] = []string{"chunk-other"} + case "log-object-id": + p["wiki_log_entries"][0]["pages_affected"] = []any{map[string]any{"slug": "index", "log_id": 100}} + case "log-array-number": + p["wiki_log_entries"][0]["pages_affected"] = []int{100} + } + }) + if mode != "valid" && mode != "linked-valid" && mode != "legacy-pages" && mode != "historical-log" { + r11Reject(t, fx, snapshot) + return + } + target := fx.target(t) + out := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if out.State != "succeeded" { + t.Fatal(out) + } + var actual int64 + if e := fx.pool.QueryRow(fx.ctx, `SELECT id FROM wiki_log_entries WHERE knowledge_base_id=$1`, wsTargetKB).Scan(&actual); e != nil { + t.Fatal(e) + } + var sourceCursor, validCursor int + if e := fx.pool.QueryRow(fx.ctx, `SELECT count(*) FROM wiki_log_entries WHERE knowledge_base_id=$1 AND id<100`, wsTargetKB).Scan(&sourceCursor); e != nil { + t.Fatal(e) + } + if e := fx.pool.QueryRow(fx.ctx, `SELECT count(*) FROM wiki_log_entries WHERE knowledge_base_id=$1 AND id<$2`, wsTargetKB, actual).Scan(&validCursor); e != nil { + t.Fatal(e) + } + if actual == 100 || sourceCursor == validCursor { + t.Fatal("expected evidence of DB-local old cursor not transferable") + } + r10Save(t, "cursor-boundary", map[string]any{"source_cursor": 100, "mapped_id": actual, "source_cursor_count": sourceCursor, "mapped_cursor_count": validCursor, "policy": "fresh target cursor works; cross-source or pre-replace external cursor is not automatically translated"}) + if e := target.Restore(fx.ctx, out.Backup); e != nil { + t.Fatal(e) + } + }) + } +} diff --git a/internal/releaseadapter/v071/formal_es_fault_test.go b/internal/releaseadapter/v071/formal_es_fault_test.go new file mode 100644 index 0000000..32cf44c --- /dev/null +++ b/internal/releaseadapter/v071/formal_es_fault_test.go @@ -0,0 +1,81 @@ +package v071 + +import ( + "bytes" + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "sync" + "testing" +) + +// This is only a faulting wire: every response, commit and CAS originates in +// the real isolated ES. Successful bodies are recorded, then one is withheld. +func formalElasticFaultProxy(t *testing.T, root, upstream, fault string) string { + t.Helper() + var mu sync.Mutex + dropped := false + events := []map[string]any{} + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + raw, e := io.ReadAll(r.Body) + if e != nil { + http.Error(w, "read failed", 500) + return + } + request, e := http.NewRequestWithContext(r.Context(), r.Method, upstream+r.URL.RequestURI(), bytes.NewReader(raw)) + if e != nil { + http.Error(w, "request failed", 500) + return + } + request.Header = r.Header.Clone() + response, e := http.DefaultClient.Do(request) + if e != nil { + http.Error(w, "upstream failed", 502) + return + } + body, e := io.ReadAll(response.Body) + response.Body.Close() + if e != nil { + http.Error(w, "upstream body failed", 502) + return + } + mutating := r.Method == "PUT" || r.Method == "DELETE" || strings.Contains(r.URL.Path, "_bulk") + mu.Lock() + selected := fault == "apply-clean" && strings.HasSuffix(r.URL.Path, "/_doc/chunk-src") && !bytes.Contains(raw, []byte(indexClaimPrefix)) + selected = selected || (fault == "restore-write" && strings.HasSuffix(r.URL.Path, "/_create/chunk-target")) + selected = selected || (fault == "restore-clean" && r.Method == http.MethodPut && strings.HasSuffix(r.URL.Path, "/_doc/chunk-target") && !bytes.Contains(raw, []byte(indexRestoreClaimPrefix))) + drop := !dropped && selected && response.StatusCode >= 200 && response.StatusCode < 300 + if mutating { + events = append(events, map[string]any{"method": r.Method, "path": r.URL.RequestURI(), "request": string(raw), "response": string(body), "status": response.StatusCode, "dropped": drop}) + encoded, _ := json.MarshalIndent(events, "", " ") + _ = os.WriteFile(filepath.Join(root, "es-wire.json"), encoded, 0600) + } + if drop { + dropped = true + _ = os.WriteFile(filepath.Join(root, "es-response-dropped"), []byte(fault), 0600) + } + mu.Unlock() + if drop { + if hijacker, ok := w.(http.Hijacker); ok { + connection, _, err := hijacker.Hijack() + if err == nil { + connection.Close() + } + } + return + } + for k, values := range response.Header { + for _, v := range values { + w.Header().Add(k, v) + } + } + w.WriteHeader(response.StatusCode) + _, _ = w.Write(body) + })) + t.Cleanup(server.Close) + return server.URL +} diff --git a/internal/releaseadapter/v071/formal_recovery_integration_test.go b/internal/releaseadapter/v071/formal_recovery_integration_test.go new file mode 100644 index 0000000..04da305 --- /dev/null +++ b/internal/releaseadapter/v071/formal_recovery_integration_test.go @@ -0,0 +1,340 @@ +package v071 + +import ( + "context" + "encoding/json" + "fmt" + "net/http" + "os" + "os/exec" + "path/filepath" + "reflect" + "strings" + "syscall" + "testing" + "time" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/s3" + "github.com/jackc/pgx/v5/pgxpool" + "knowledge-governance/internal/governance" + "knowledge-governance/internal/jobs" + postgresstore "knowledge-governance/internal/platform/postgres" +) + +func recoveryIndexReadback(t *testing.T, fx *writeSetFixture) map[string]map[string]any { + t.Helper() + response, e := http.Get(fx.searchBase + "/" + fx.index + "/_search?size=100&seq_no_primary_term=true") + if e != nil { + t.Fatal(e) + } + defer response.Body.Close() + var body struct { + Hits struct { + Hits []map[string]any `json:"hits"` + } `json:"hits"` + } + if e = json.NewDecoder(response.Body).Decode(&body); e != nil { + t.Fatal(e) + } + if response.StatusCode != 200 || len(body.Hits.Hits) >= 100 { + t.Fatal("invalid independent index readback") + } + result := map[string]map[string]any{} + for _, hit := range body.Hits.Hits { + result[hit["_id"].(string)] = hit + } + return result +} + +// Only the worker executable performs recovery writes. Test code submits a new +// request, kills an actual recovery process, and independently compares stores. +func runRecoveryIntentProcess(t *testing.T, root string, fx *writeSetFixture, gov *pgxpool.Pool, store *postgresstore.Store, original governance.LibraryJob, env map[string]string, start func(string, string, map[string]string) *exec.Cmd, checkpoint func(string), save func(string, any)) { + t.Helper() + ctx := context.Background() + must := func(e error) { + t.Helper() + if e != nil { + t.Fatal(e) + } + } + inventory := func() *s3.ListObjectVersionsOutput { + v, e := fx.objects.s3.client.ListObjectVersions(ctx, &s3.ListObjectVersionsInput{Bucket: aws.String(fx.bucket)}) + must(e) + if aws.ToBool(v.IsTruncated) || len(v.DeleteMarkers) > 0 { + t.Fatal("invalid object inventory") + } + return v + } + readJSON := func(name string, out any) { + raw, e := os.ReadFile(filepath.Join(root, name)) + must(e) + must(json.Unmarshal(raw, out)) + } + kill := func(cmd *exec.Cmd, name string) { + must(cmd.Process.Kill()) + _ = cmd.Wait() + s := cmd.ProcessState.Sys().(syscall.WaitStatus) + if !s.Signaled() || s.Signal() != syscall.SIGKILL { + t.Fatal("not SIGKILL") + } + save(name, map[string]any{"pid": cmd.Process.Pid, "exit_code": cmd.ProcessState.ExitCode(), "signal": "SIGKILL"}) + } + beforeIndex := recoveryIndexReadback(t, fx) + save("index-before.json", beforeIndex) + env["KG_TEST_BARRIER_POINTS"] = "after:index" + env["WORKER_ID"] = "r9-publish" + publish := start("worker", "publish", env) + wait := func(queue, point string) string { + for i := 0; i < 600; i++ { + if point != "" { + if _, e := os.Stat(filepath.Join(root, "barriers", point+".hit")); e == nil { + return "hit" + } + } + var state, message string + must(gov.QueryRow(ctx, "SELECT state,COALESCE(last_error,'') FROM jobs WHERE id=$1", queue).Scan(&state, &message)) + if state == "completed" || state == "failed" { + save("queue-"+queue+"-terminal.json", map[string]any{"state": state, "error": message}) + return state + } + time.Sleep(100 * time.Millisecond) + } + checkpoint("timeout") + t.Fatal("formal process timeout", queue, point) + return "timeout" + } + queueID := original.QueueJobID + if queueID == "" { + must(gov.QueryRow(ctx, "SELECT queue_job_id FROM library_jobs WHERE id=$1", original.ID).Scan(&queueID)) + } + publishResult := wait(queueID, "after-index") + if got := publishResult; got != "hit" && !(os.Getenv("KG_R9_FAULT") == "apply-clean" && got == "failed") { + checkpoint("publish-failed") + t.Fatal("publish failed", got) + } + checkpoint("published-partial") + partialPG := universeDump(t, fx.pool) + partialIndex := recoveryIndexReadback(t, fx) + partialObjects := inventory() + if publishResult == "hit" { + if reflect.DeepEqual(partialIndex, beforeIndex) || partialIndex["chunk-src"] == nil || partialIndex["chunk-target"] != nil { + t.Fatal("publish kill did not follow real index replacement") + } + } + if publishResult == "hit" { + var owner string + must(gov.QueryRow(ctx, "SELECT lease_owner FROM jobs WHERE id=$1", queueID).Scan(&owner)) + kill(publish, "publish-kill.json") + must(store.FailTerminal(ctx, queueID, owner, "isolated operator requested recovery after SIGKILL", "r9_recover_requested", time.Now().UTC())) + } else { + must(publish.Process.Signal(syscall.SIGTERM)) + must(publish.Wait()) + if _, e := os.Stat(filepath.Join(root, "es-response-dropped")); e != nil { + t.Fatal("publish did not hit real ES commit fault") + } + } + time.Sleep(5 * time.Second) + var backup, plan, source string + must(gov.QueryRow(ctx, "SELECT snapshot_id,evidence->>'writeset_digest',evidence->>'writeset_target_snapshot' FROM library_versions WHERE kind='production_prebackup' AND source_job_id=$1", original.ID).Scan(&backup, &plan, &source)) + fields := map[string]string{"scope": "internal", "window_job_id": original.ID, "source_snapshot_id": source, "target_id": env["R9_TARGET_ID"], "original_operation_id": original.OperationID, "backup_snapshot_id": backup, "plan_digest": plan} + scenario := os.Getenv("KG_R9_SCENARIO") + if scenario == "wrong-job" { + must(store.CancelLibraryJob(ctx, original.ID, "negative fixture: operator parked original publication", time.Now().UTC())) + } + if scenario != "" { + key := map[string]string{"wrong-source": "source_snapshot_id", "wrong-target": "target_id", "wrong-job": "window_job_id", "wrong-plan": "plan_digest", "wrong-operation": "original_operation_id"}[scenario] + if key != "" { + fields[key] = "wrong-identity" + } else if scenario != "arbitrary-queue" { + t.Fatal("unknown scenario", scenario) + } + } + recoverID := governance.LibraryRecoveryQueueID(fields["window_job_id"]) + if scenario == "arbitrary-queue" { + recoverID = "unrelated-recovery-queue" + } + payload, e := json.Marshal(fields) + must(e) + request := jobs.EnqueueRequest{ID: recoverID, Type: "library.recover", Payload: payload, AvailableAt: time.Now().UTC(), MaxAttempts: 1, IdempotencyKey: "library.recover:" + fields["window_job_id"]} + queued, e := store.Enqueue(ctx, request, time.Now().UTC()) + must(e) + save("recovery-request.json", queued) + env["KG_TEST_BARRIER_POINTS"] = "restore:index" + env["WORKER_ID"] = "r9-recover-1" + worker := start("worker", "recovery-1", env) + if scenario != "" { + if got := wait(recoverID, ""); got != "failed" { + t.Fatal("invalid recovery accepted", scenario, got) + } + must(worker.Process.Signal(syscall.SIGTERM)) + must(worker.Wait()) + checkpoint("rejected") + if !reflect.DeepEqual(partialPG, universeDump(t, fx.pool)) || !reflect.DeepEqual(partialIndex, recoveryIndexReadback(t, fx)) || !reflect.DeepEqual(partialObjects.Versions, inventory().Versions) { + t.Fatal("rejected request changed business stores") + } + save("recovery-result.json", map[string]any{"scenario": scenario, "rejected": true, "business_stores_unchanged": true}) + return + } + if os.Getenv("KG_R9_FAULT") == "apply-clean" || os.Getenv("KG_R9_FAULT") == "restore-clean" { + if got := wait(recoverID, ""); got != "failed" { + t.Fatal("unattributable clean commit did not remain held", got) + } + must(worker.Process.Signal(syscall.SIGTERM)) + must(worker.Wait()) + checkpoint("clean-unknown-held") + if _, e := os.Stat(filepath.Join(root, "es-response-dropped")); e != nil { + t.Fatal("fault not exercised") + } + heldPG, heldIndex, heldObjects := universeDump(t, fx.pool), recoveryIndexReadback(t, fx), inventory() + wireBefore, e := os.ReadFile(filepath.Join(root, "es-wire.json")) + must(e) + time.Sleep(5 * time.Second) + retried, e := store.RetryLibraryRecovery(ctx, recoverID, original.ID, time.Now().UTC()) + must(e) + if !retried { + t.Fatal("retry unavailable") + } + env["WORKER_ID"] = "r9-clean-held-replay" + worker = start("worker", "clean-held-replay", env) + if got := wait(recoverID, ""); got != "failed" { + t.Fatal("clean unknown replay accepted", got) + } + must(worker.Process.Signal(syscall.SIGTERM)) + must(worker.Wait()) + wireAfter, e := os.ReadFile(filepath.Join(root, "es-wire.json")) + must(e) + if !reflect.DeepEqual(heldPG, universeDump(t, fx.pool)) || !reflect.DeepEqual(heldIndex, recoveryIndexReadback(t, fx)) || !reflect.DeepEqual(heldObjects.Versions, inventory().Versions) || string(wireBefore) != string(wireAfter) { + t.Fatal("held replay rewrote business state or resent ES mutation") + } + var journal map[string]any + readJSON("maintenance/"+original.ID+".json", &journal) + if journal["state"] != "held" { + t.Fatal("unknown not held", journal["state"]) + } + save("recovery-result.json", map[string]any{"fault": os.Getenv("KG_R9_FAULT"), "state": "held", "no_repeated_ES_mutations": true, "replay_stores_unchanged": true}) + return + } + if os.Getenv("KG_R9_FAULT") == "restore-write" { + if got := wait(recoverID, ""); got != "failed" { + t.Fatal("restore response fault not observed", got) + } + checkpoint("unknown-restore-red") + must(worker.Process.Signal(syscall.SIGTERM)) + must(worker.Wait()) + if _, e := os.Stat(filepath.Join(root, "es-response-dropped")); e != nil { + t.Fatal("no real ES response was dropped") + } + time.Sleep(5 * time.Second) + retried, e := store.RetryLibraryRecovery(ctx, recoverID, original.ID, time.Now().UTC()) + must(e) + if !retried { + t.Fatal("recovery retry not queued") + } + env["WORKER_ID"] = "r9-recover-after-unknown" + worker = start("worker", "recovery-after-unknown", env) + } + if got := wait(recoverID, "restore-index"); got != "hit" { + checkpoint("recovery-failed") + t.Fatal("recovery did not reach real restored-index boundary", got) + } + checkpoint("recovery-interrupted") + indexAtKill := recoveryIndexReadback(t, fx) + save("index-at-recovery-kill.json", indexAtKill) + kill(worker, "recovery-kill.json") + time.Sleep(5 * time.Second) + env["WORKER_ID"] = "r9-recover-2" + worker = start("worker", "recovery-2", env) + if got := wait(recoverID, ""); got != "completed" { + checkpoint("recovery-failed") + t.Fatal("recovery takeover failed", got) + } + checkpoint("recovery-complete") + if os.Getenv("KG_R9_FAULT") == "restore-write" { + var wire []map[string]any + readJSON("es-wire.json", &wire) + markedWrites := 0 + droppedWrites := 0 + for _, event := range wire { + if event["method"] == "PUT" && strings.Contains(event["request"].(string), indexRestoreClaimPrefix) { + markedWrites++ + if event["dropped"] == true { + droppedWrites++ + } + } + } + if markedWrites != 1 || droppedWrites != 1 { + t.Fatal("restore marker was resent or fault not exercised", markedWrites, droppedWrites) + } + } + var before map[string][]string + readJSON("pg-before.json", &before) + after := universeDump(t, fx.pool) + if !reflect.DeepEqual(before, after) { + t.Fatal("full PG before-image not restored") + } + finalIndex := recoveryIndexReadback(t, fx) + save("index-final.json", finalIndex) + if len(finalIndex) != len(beforeIndex) { + t.Fatal("index universe changed") + } + for id, old := range beforeIndex { + got, ok := finalIndex[id] + if !ok || !reflect.DeepEqual(old["_source"], got["_source"]) { + t.Fatal("original index source not restored", id) + } + if got["_seq_no"] == nil || got["_primary_term"] == nil { + t.Fatal("missing CAS") + } + if id == "chunk-target" && reflect.DeepEqual(old["_seq_no"], got["_seq_no"]) { + t.Fatal("restoration did not create a new CAS generation") + } + if id != "chunk-target" && !reflect.DeepEqual(old, got) { + t.Fatal("out-of-scope index CAS changed", id) + } + } + if !reflect.DeepEqual(indexAtKill, finalIndex) { + t.Fatal("replayed restoration repeated index mutations") + } + var objectsBefore s3.ListObjectVersionsOutput + readJSON("objects-before.json", &objectsBefore) + finalObjects := inventory() + if !reflect.DeepEqual(objectsBefore.Versions, finalObjects.Versions) { + t.Fatal("original exact object versions not restored") + } + var operations, events, receipts, deliveries int + must(gov.QueryRow(ctx, "SELECT count(*) FROM library_operations WHERE kind='recover'").Scan(&operations)) + must(gov.QueryRow(ctx, "SELECT count(*) FROM library_versions WHERE kind='recovery_verified'").Scan(&events)) + must(gov.QueryRow(ctx, "SELECT count(*) FROM kg_object_gateway_receipts").Scan(&receipts)) + must(gov.QueryRow(ctx, "SELECT count(*) FROM kg_object_gateway_deliveries").Scan(&deliveries)) + expectedDeliveries := 3 + if os.Getenv("KG_R9_FAULT") == "restore-write" { + expectedDeliveries++ + } + if operations != 1 || events != 1 || receipts != 2 || deliveries != expectedDeliveries { + t.Fatal("duplicate or missing durable identities", operations, events, receipts, deliveries) + } + replay, e := store.Enqueue(ctx, request, time.Now().UTC()) + must(e) + if replay.ID != recoverID || replay.State != jobs.StateCompleted { + t.Fatal("recovery replay not idempotent") + } + time.Sleep(400 * time.Millisecond) + if !reflect.DeepEqual(after, universeDump(t, fx.pool)) || !reflect.DeepEqual(finalIndex, recoveryIndexReadback(t, fx)) || !reflect.DeepEqual(finalObjects.Versions, inventory().Versions) { + t.Fatal("completed request replay mutated data") + } + must(worker.Process.Signal(syscall.SIGTERM)) + must(worker.Wait()) + save("recovery-result.json", map[string]any{"queue_job": recoverID, "window_job": original.ID, "original_operation": original.OperationID, "state": "completed", "recovery_sigkills": 1, "recover_operations": operations, "recovery_events": events, "deliveries": deliveries, "receipts": receipts, "full_before_image_verified": true, "index_replay_CAS_unchanged": true, "worker_exit": worker.ProcessState.ExitCode()}) + for _, v := range finalObjects.Versions { + _, e = fx.objects.s3.client.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(fx.bucket), Key: v.Key, VersionId: v.VersionId}) + must(e) + } + if len(inventory().Versions) != 0 { + t.Fatal("cleanup not empty") + } + _, e = fx.objects.s3.client.DeleteBucket(ctx, &s3.DeleteBucketInput{Bucket: aws.String(fx.bucket)}) + must(e) + save("object-cleanup.json", map[string]any{"bucket": fx.bucket, "versions": 0, "delete_markers": 0}) + t.Log(fmt.Sprintf("recovery new request=%s original=%s full before-image restored", recoverID, original.ID)) +} diff --git a/internal/releaseadapter/v071/formal_worker_integration_test.go b/internal/releaseadapter/v071/formal_worker_integration_test.go new file mode 100644 index 0000000..5ea9ba0 --- /dev/null +++ b/internal/releaseadapter/v071/formal_worker_integration_test.go @@ -0,0 +1,431 @@ +package v071 + +import ( + "bytes" + "context" + "crypto/ed25519" + "crypto/rand" + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "net/http" + "os" + "os/exec" + "path/filepath" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/s3" + "io" + "syscall" + "testing" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + "knowledge-governance/internal/appconfig" + "knowledge-governance/internal/governance" + "knowledge-governance/internal/librarysnapshot" + "knowledge-governance/internal/objectgateway" + postgresstore "knowledge-governance/internal/platform/postgres" +) + +// The harness only seeds and observes. All release writes run in cmd/worker +// executables, through the real Docker maintenance coordinator and gateway. +func TestFormalWorkerDoubleInterruption(t *testing.T) { runFormalWorkerScenario(t, false) } + +func TestFormalWorkerRecoveryIntent(t *testing.T) { runFormalWorkerScenario(t, true) } + +func runFormalWorkerScenario(t *testing.T, recoverIntent bool) { + root := os.Getenv("KG_R8_RUN") + if root == "" { + t.Skip("requires dedicated r8 real-process isolated deployment") + } + ctx := context.Background() + save := func(name string, value any) { + t.Helper() + raw, e := json.MarshalIndent(value, "", " ") + if e != nil { + t.Fatal(e) + } + if e = os.WriteFile(filepath.Join(root, name), raw, 0600); e != nil { + t.Fatal(e) + } + } + must := func(e error) { + t.Helper() + if e != nil { + t.Fatal(e) + } + } + archiveRoot := filepath.Join(root, "archive") + must(os.MkdirAll(archiveRoot, 0700)) + must(os.MkdirAll(filepath.Join(root, "maintenance"), 0700)) + fx := openWriteSetFixtureWith(t, writeSetFixtureOptions{reset: true, archiveRoot: archiveRoot, embeddingDimension: 1024}) + seedTargetData(t, fx) + if recoverIntent { + fx.indexDoc(t, "chunk-other", 10001, wsOtherKB, "doc-other", "other KB unchanged") + fx.indexDoc(t, "chunk-foreign", 20000, "kb-foreign", "doc-foreign", "other tenant unchanged") + } + objectInventory := func() *s3.ListObjectVersionsOutput { + t.Helper() + v, e := fx.objects.s3.client.ListObjectVersions(ctx, &s3.ListObjectVersionsInput{Bucket: aws.String(fx.bucket)}) + must(e) + if aws.ToBool(v.IsTruncated) || len(v.DeleteMarkers) != 0 { + t.Fatal("incomplete inventory or unexpected delete markers") + } + return v + } + originalObjects := objectInventory() + save("objects-before.json", originalObjects) + + // These tables are the real stack's metadata contract, absent in the narrower + // adapter fixture. No business data/schema outside this new test DB is touched. + _, e := fx.pool.Exec(ctx, `ALTER TABLE knowledge_bases ADD COLUMN embedding_model_id text, ADD COLUMN vector_store_id text; + CREATE TABLE models(id text PRIMARY KEY,name text,parameters jsonb,deleted_at timestamptz); + CREATE TABLE vector_stores(id text PRIMARY KEY,engine_type text,index_config jsonb,deleted_at timestamptz); + INSERT INTO models VALUES('r8-model','text-embedding-v4','{"embedding_parameters":{"dimension":1024}}',NULL); + INSERT INTO vector_stores VALUES('r8-vector','elasticsearch_v8','{}',NULL); + UPDATE knowledge_bases SET embedding_model_id='r8-model',vector_store_id='r8-vector';`) + must(e) + before := universeDump(t, fx.pool) + save("pg-before.json", before) + target := fx.target(t) + mapping, e := target.Search().MappingSHA256(ctx) + must(e) + // Seal a fresh, internally consistent fixture contract; historical seals stay unchanged. + source := sealSourceSnapshot(t, fx, nil) + archive, e := librarysnapshot.Open(archiveRoot, 256<<20) + must(e) + manifest, e := archive.Load(source) + must(e) + manifest.Compatibility.EmbeddingDimension = 1024 + manifest.Compatibility.IndexMappingSHA256 = mapping + snapshot, e := archive.Seal(manifest) + must(e) + archive.Close() + govDSN := os.Getenv("KG_R8_GOVERNANCE_DSN") + gov, e := pgxpool.New(ctx, govDSN) + must(e) + t.Cleanup(gov.Close) + must(postgresstore.ApplyMigrations(ctx, gov)) + _, e = gov.Exec(ctx, objectgateway.Schema) + must(e) + reader := gatewayReadOnlyGovernance(t, ctx, gov, govDSN) + project := os.Getenv("KG_R8_PROJECT") + workerElastic := fx.searchBase + if recoverIntent && os.Getenv("KG_R9_FAULT") != "" { + workerElastic = formalElasticFaultProxy(t, root, fx.searchBase, os.Getenv("KG_R9_FAULT")) + } + env := map[string]string{ + "KG_LIBRARY_TEST_ISOLATED": "1", "DATABASE_URL": govDSN, "LIBRARY_WORKER_ROLE": "release-executor", "WORKER_POLL_INTERVAL": "100ms", "WORKER_LEASE_DURATION": "4s", + "PRODUCTION_RELEASE_REQUESTS_ENABLED": "true", "PRODUCTION_BACKUP_RESTORE_VERIFIED": "true", + "LIBRARY_ARCHIVE_ROOT": archiveRoot, "LIBRARY_CAPACITY_BUDGET_BYTES": "1073741824", + "LIBRARY_PRODUCTION_DATABASE_URL": os.Getenv("KG_LIBRARY_TEST_DATABASE_URL"), "LIBRARY_PRODUCTION_ELASTIC_URL": workerElastic, "LIBRARY_PRODUCTION_INDEX": fx.index, + "LIBRARY_PRODUCTION_TENANT_ID": "10001", "LIBRARY_PRODUCTION_KB_INTERNAL": wsTargetKB, + "LIBRARY_PRODUCTION_S3_PROVIDER": "minio", "LIBRARY_PRODUCTION_S3_ENDPOINT": os.Getenv("KG_LIBRARY_TEST_S3_ENDPOINT"), "LIBRARY_PRODUCTION_S3_BUCKET": fx.bucket, + "LIBRARY_PRODUCTION_S3_ACCESS_KEY": os.Getenv("KG_R8_READER_KEY"), "LIBRARY_PRODUCTION_S3_SECRET_KEY": os.Getenv("KG_R8_READER_SECRET"), + "LIBRARY_TARGET_INSTANCE": project, "LIBRARY_TARGET_PROJECT": project, "LIBRARY_TARGET_WRITERS": "writer", + "LIBRARY_TARGET_NON_WRITERS": "ingress=entry gate,redis=queue,minio=object backend", + "LIBRARY_TARGET_INGRESS_URL": os.Getenv("KG_R8_INGRESS"), "LIBRARY_TARGET_INGRESS_SERVICE": "ingress", "LIBRARY_TARGET_INGRESS_DRAIN_FILE": filepath.Join(root, "gate/drain.json"), + "LIBRARY_TARGET_REDIS_ADDR": os.Getenv("KG_R8_REDIS_ADDR"), "LIBRARY_TARGET_REDIS_PASSWORD": os.Getenv("KG_R8_REDIS_PASSWORD"), "LIBRARY_TARGET_REDIS_DB": "0", + "LIBRARY_TARGET_JOURNAL_ROOT": filepath.Join(root, "maintenance"), "LIBRARY_EMBEDDING_DIMENSION": "1024", + "KG_TEST_BARRIER_DIR": filepath.Join(root, "barriers"), "KG_TEST_BARRIER_POINTS": "after:database,after:resources", "KG_TEST_BARRIER_TIMEOUT": "180s", + } + env["PRODUCTION_RELEASE_AUTHORIZER_REF"] = project + env["PRODUCTION_RELEASE_AUTH_TOKEN_FILE"] = filepath.Join(root, "authorization-token") + must(os.WriteFile(env["PRODUCTION_RELEASE_AUTH_TOKEN_FILE"], []byte(objectgateway.Digest([]byte(root+"approval"))), 0600)) + cfg, e := appconfig.Load(func(k string) string { return env[k] }) + must(e) + dataToken := objectgateway.Digest([]byte(root + "data")) + controlToken := objectgateway.Digest([]byte(root + "control")) + env["LIBRARY_OBJECT_GATEWAY_URL"] = "http://" + os.Getenv("KG_R8_GATEWAY_ADDR") + env["LIBRARY_OBJECT_GATEWAY_TOKEN"] = dataToken + // Independently prove worker's object identity cannot PUT, before any job exists. + readStore, e := NewS3ObjectStore(S3ObjectStoreConfig{Provider: "minio", Endpoint: env["LIBRARY_PRODUCTION_S3_ENDPOINT"], Bucket: fx.bucket, AccessKeyID: env["LIBRARY_PRODUCTION_S3_ACCESS_KEY"], SecretAccessKey: env["LIBRARY_PRODUCTION_S3_SECRET_KEY"], Region: "us-east-1", ForcePathStyle: true}) + must(e) + allowedRead, e := readStore.Open(ctx, "minio", wsLocator("backend-target", "minio", fx.bucket, 10001, "res-target")) + must(e) + allowedBody, e := io.ReadAll(allowedRead) + allowedRead.Close() + must(e) + if !bytes.Equal(allowedBody, []byte("12345678")) { + t.Fatal("readonly identity could not read original bytes") + } + denied := readStore.Put(ctx, "minio", wsLocator("backend-target", "minio", fx.bucket, 10001, "r8-denied"), bytes.NewReader([]byte("denied")), 6) + if denied == nil { + t.Fatal("worker readonly identity unexpectedly wrote object") + } + save("denial.json", map[string]any{"readonly_put_denied": true}) + scope := objectgateway.Digest([]byte("minio\x00" + env["LIBRARY_PRODUCTION_S3_ENDPOINT"] + "\x00" + fx.bucket)) + pub, priv, e := ed25519.GenerateKey(rand.Reader) + must(e) + digestFile := func(name string) string { + raw, e := os.ReadFile(filepath.Join(root, name)) + must(e) + return objectgateway.Digest(raw) + } + save("writer-inventory.json", map[string]any{"project": project, "worker_object_identity": "readonly", "gateway_only_writer": true, "bucket": fx.bucket, "index": fx.index, "target": cfg.LibraryTargetIdentity()}) + save("policy.json", map[string]any{"worker": "readonly MinIO policy", "isolated_minio": os.Getenv("KG_R8_MINIO"), "scope": scope}) + payload, e := json.Marshal(objectgateway.Attestation{Protocol: objectgateway.Protocol, Scope: scope, GatewayID: project, IssuedAt: time.Now().Add(-time.Second), ExpiresAt: time.Now().Add(50 * time.Minute), WriterInventory: digestFile("writer-inventory.json"), PolicyEvidence: digestFile("policy.json"), DenialEvidence: digestFile("denial.json"), DrainEvidence: digestFile("initial-drain.json")}) + must(e) + signedRaw, e := json.Marshal(objectgateway.SignedAttestation{Payload: payload, Signature: ed25519.Sign(priv, payload)}) + must(e) + must(os.WriteFile(filepath.Join(root, "audit.json"), signedRaw, 0600)) + genv := map[string]string{"OBJECT_GATEWAY_LISTEN": os.Getenv("KG_R8_GATEWAY_ADDR"), "OBJECT_GATEWAY_DATABASE_URL": govDSN, "OBJECT_GATEWAY_GOVERNANCE_DATABASE_URL": reader.Config().ConnString(), "OBJECT_GATEWAY_ARCHIVE_ROOT": archiveRoot, "OBJECT_GATEWAY_TARGET_ID": cfg.LibraryTargetIdentity(), "OBJECT_GATEWAY_PROVIDER": "minio", "OBJECT_GATEWAY_ENDPOINT": env["LIBRARY_PRODUCTION_S3_ENDPOINT"], "OBJECT_GATEWAY_BUCKET": fx.bucket, "OBJECT_GATEWAY_REGION": "us-east-1", "OBJECT_GATEWAY_ACCESS_KEY": os.Getenv("KG_LIBRARY_TEST_S3_ACCESS_KEY"), "OBJECT_GATEWAY_SECRET_KEY": os.Getenv("KG_LIBRARY_TEST_S3_SECRET_KEY"), "OBJECT_GATEWAY_DATA_TOKEN": dataToken, "OBJECT_GATEWAY_CONTROL_TOKEN": controlToken, "OBJECT_GATEWAY_ID": project, "OBJECT_GATEWAY_AUDIT_FILE": filepath.Join(root, "audit.json"), "OBJECT_GATEWAY_AUDIT_PUBLIC_KEY": base64.StdEncoding.EncodeToString(pub)} + processes := []map[string]any{} + start := func(binary, label string, values map[string]string) *exec.Cmd { + t.Helper() + bin := "r8-bin" + if recoverIntent { + bin = "r9-bin" + } + cmd := exec.Command(filepath.Join(filepath.Dir(root), bin, binary)) + cmd.Env = []string{"PATH=" + os.Getenv("PATH"), "HOME=" + os.Getenv("HOME")} + for k, v := range values { + cmd.Env = append(cmd.Env, k+"="+v) + } + f, e := os.OpenFile(filepath.Join(root, label+".log"), os.O_CREATE|os.O_WRONLY|os.O_EXCL, 0600) + must(e) + cmd.Stdout = f + cmd.Stderr = f + must(cmd.Start()) + processes = append(processes, map[string]any{"label": label, "pid": cmd.Process.Pid, "binary": binary}) + save("processes.json", processes) + t.Cleanup(func() { _ = cmd.Process.Kill(); _ = cmd.Wait(); f.Close() }) + return cmd + } + start("object-gateway", "gateway", genv) + client, e := objectgateway.NewClient(env["LIBRARY_OBJECT_GATEWAY_URL"], dataToken, scope) + must(e) + ready := false + for i := 0; i < 100; i++ { + if client.ReadyForAcquisition(ctx) == nil { + ready = true + break + } + time.Sleep(100 * time.Millisecond) + } + if !ready { + t.Fatal("gateway not ready; inspect gateway.log") + } + store := postgresstore.NewStore(gov).WithLibraryTarget(cfg.LibraryTargetIdentity()) + now := time.Now().UTC() + digest, e := governance.LibraryRequestDigest("internal", governance.LibraryJobSync, map[string]any{"target_snapshot_id": snapshot}) + must(e) + must(store.CreateLibraryAuthorization(ctx, governance.LibraryReleaseAuthorization{ID: project + "-auth", Scope: "internal", SnapshotID: snapshot, ParamsDigest: digest, ExpiresAt: now.Add(time.Hour), CreatedAt: now})) + op, _, e := store.EnsureLibraryOperation(ctx, governance.LibraryOperation{ID: project + "-operation", Scope: "internal", Kind: governance.LibraryJobSync, TargetSnapshotID: snapshot, RequestDigest: digest, OperationKey: project, CreatedAt: now}) + must(e) + job, _, e := store.CreateLibraryDispatch(ctx, governance.LibraryJob{ID: project + "-job", OperationID: op.ID, Scope: "internal", Kind: governance.LibraryJobSync, TargetSnapshotID: snapshot, IdempotencyKey: project, RequestDigest: digest}, governance.SyncStages(), false, now) + must(e) + save("identity.json", map[string]any{"job": job.ID, "operation": job.OperationID, "snapshot": snapshot, "bucket": fx.bucket, "index": fx.index, "target": cfg.LibraryTargetIdentity()}) + checkpoint := func(label string) { + t.Helper() + for _, table := range []string{"jobs", "library_jobs", "library_attempts", "library_operations", "library_versions", "kg_object_gateway_deliveries", "kg_object_gateway_intents", "kg_object_gateway_receipts"} { + var raw []byte + e := gov.QueryRow(ctx, "SELECT COALESCE(jsonb_agg(to_jsonb(t)),'[]') FROM "+table+" t").Scan(&raw) + must(e) + must(os.WriteFile(filepath.Join(root, label+"-"+table+".json"), raw, 0600)) + } + save(label+"-pg.json", universeDump(t, fx.pool)) + save(label+"-objects.json", objectInventory()) + } + if recoverIntent { + env["R9_TARGET_ID"] = cfg.LibraryTargetIdentity() + runRecoveryIntentProcess(t, root, fx, gov, store, job, env, start, checkpoint, save) + return + } + for n, point := range []string{"after-database", "after-resources", "finished"} { + env["WORKER_ID"] = fmt.Sprintf("%s-worker-%d", project, n+1) + cmd := start("worker", fmt.Sprintf("worker-%d", n+1), env) + hit := false + for i := 0; i < 1200; i++ { + current, e := store.LibraryJob(ctx, job.ID) + must(e) + if point == "finished" && current.State == governance.LibraryJobSucceeded { + hit = true + break + } + if point != "finished" { + if _, e = os.Stat(filepath.Join(root, "barriers", point+".hit")); e == nil { + hit = true + break + } + } + if current.State == governance.LibraryJobFailed { + checkpoint(fmt.Sprintf("failed-%d", n+1)) + t.Fatalf("formal worker %d failed: %s", n+1, current.Error) + } + time.Sleep(100 * time.Millisecond) + } + if !hit { + checkpoint(fmt.Sprintf("timeout-%d", n+1)) + t.Fatalf("formal worker %d did not reach %s", n+1, point) + } + checkpoint(fmt.Sprintf("stage-%d", n+1)) + if point != "finished" { + must(cmd.Process.Kill()) + err := cmd.Wait() + status := cmd.ProcessState.Sys().(syscall.WaitStatus) + if !status.Signaled() || status.Signal() != syscall.SIGKILL { + t.Fatalf("expected SIGKILL: %v", err) + } + save(fmt.Sprintf("kill-%d.json", n+1), map[string]any{"pid": cmd.Process.Pid, "signal": "SIGKILL", "exit_code": cmd.ProcessState.ExitCode(), "point": point}) + time.Sleep(5 * time.Second) + } else { + must(cmd.Process.Signal(syscall.SIGTERM)) + must(cmd.Wait()) + save("worker-final-exit.json", map[string]any{"pid": cmd.Process.Pid, "exit_code": cmd.ProcessState.ExitCode()}) + } + } + // Independent final checks; exact rows outside the owned target must survive. + after := universeDump(t, fx.pool) + save("pg-final.json", after) + var docs, attempts, deliveries, receipts int + must(fx.pool.QueryRow(ctx, "SELECT count(*) FROM knowledges WHERE tenant_id=10001 AND knowledge_base_id=$1", wsTargetKB).Scan(&docs)) + if docs != 1 { + t.Fatalf("target documents=%d", docs) + } + must(gov.QueryRow(ctx, "SELECT count(*) FROM library_attempts WHERE job_id=$1", job.ID).Scan(&attempts)) + if attempts != 3 { + t.Fatalf("attempts=%d", attempts) + } + must(gov.QueryRow(ctx, "SELECT count(*) FROM kg_object_gateway_deliveries").Scan(&deliveries)) + must(gov.QueryRow(ctx, "SELECT count(*) FROM kg_object_gateway_receipts").Scan(&receipts)) + response, e := http.Get(fx.searchBase + "/" + fx.index + "/_search?size=100") + must(e) + defer response.Body.Close() + var search any + must(json.NewDecoder(response.Body).Decode(&search)) + save("index-final.json", search) + if deliveries != 3 || receipts != 1 { + t.Fatalf("delivery/receipt count mismatch: %d/%d", deliveries, receipts) + } + var receiptRaw []byte + must(gov.QueryRow(ctx, "SELECT receipt FROM kg_object_gateway_receipts").Scan(&receiptRaw)) + var receipt objectgateway.Receipt + must(json.Unmarshal(receiptRaw, &receipt)) + if receipt.Request.Grant.Epoch != 2 || receipt.Request.Key != "10001/res-src/a.png" { + t.Fatal("original send identity changed", receipt.Request) + } + versions, e := (&objectgateway.S3Backend{Client: fx.objects.s3.client, Bucket: fx.bucket, MaxBytes: 1 << 20}).List(ctx, receipt.Request.Key) + must(e) + if len(versions) != 1 || versions[0] != receipt.Version { + t.Fatal("duplicate or changed object version", versions) + } + save("object-final.json", versions) + finalObjects := objectInventory() + save("objects-final.json", finalObjects) + if len(finalObjects.Versions) != len(originalObjects.Versions)+1 { + t.Fatal("unexpected object version growth") + } + for _, beforeVersion := range originalObjects.Versions { + found := false + for _, v := range finalObjects.Versions { + if aws.ToString(v.Key) == aws.ToString(beforeVersion.Key) && aws.ToString(v.VersionId) == aws.ToString(beforeVersion.VersionId) && aws.ToString(v.ETag) == aws.ToString(beforeVersion.ETag) { + found = true + } + } + if !found { + t.Fatal("out-of-plan original version changed", aws.ToString(beforeVersion.Key)) + } + } + a, e := os.ReadFile(filepath.Join(root, "stage-2-kg_object_gateway_receipts.json")) + must(e) + z, e := os.ReadFile(filepath.Join(root, "stage-3-kg_object_gateway_receipts.json")) + must(e) + if !bytes.Equal(a, z) { + t.Fatal("receipt changed across replay") + } + // Original rows of other KBs, other tenants and orphan/shared resources are byte-identical. + for table, rows := range before { + for _, row := range rows { + var item map[string]any + must(json.Unmarshal([]byte(row), &item)) + id, _ := item["id"].(string) + keep := id == "doc-other" || id == "chunk-other" || id == "res-other" || id == "bind-other" || id == "res-orphan" || id == "res-shared" || id == "bind-shared-other" || id == "doc-foreign" || id == "chunk-foreign" || id == "res-foreign" || id == "bind-foreign" + if keep { + found := false + for _, got := range after[table] { + if got == row { + found = true + } + } + if !found { + t.Fatalf("out-of-scope row changed: %s/%s", table, id) + } + } + } + } + for _, table := range []string{"knowledges", "chunks", "resources", "resource_bindings", "wiki_pages"} { + var duplicate int + must(fx.pool.QueryRow(ctx, "SELECT count(*) FROM (SELECT id FROM "+table+" GROUP BY id HAVING count(*)>1) x").Scan(&duplicate)) + if duplicate != 0 { + t.Fatal("duplicate PG identities", table) + } + } + searchMap := search.(map[string]any) + hits := searchMap["hits"].(map[string]any)["hits"].([]any) + if len(hits) != 1 { + t.Fatalf("index documents=%d", len(hits)) + } + hit := hits[0].(map[string]any) + doc := hit["_source"].(map[string]any) + if hit["_id"] != "chunk-src" || doc["knowledge_id"] != "doc-src" || doc["knowledge_base_id"] != wsTargetKB || doc["tenant_id"] != float64(wsTargetTenant) { + t.Fatal("index identity mismatch", hit) + } + var prebackups, effective, plans int + must(gov.QueryRow(ctx, "SELECT count(*) FROM library_versions WHERE kind='production_prebackup'").Scan(&prebackups)) + must(gov.QueryRow(ctx, "SELECT count(*) FROM kg_object_gateway_plans").Scan(&plans)) + must(gov.QueryRow(ctx, "SELECT count(*) FROM library_versions WHERE source_job_id=$1 AND kind='production_effective' AND superseded_at IS NULL", job.ID).Scan(&effective)) + if prebackups != 1 || plans != 1 || effective != 1 { + t.Fatalf("immutable anchors/prebackup/effective %d/%d/%d", plans, prebackups, effective) + } + // Compare delivery plans and exact attempt ownership without changing historic identity. + rows, e := gov.Query(ctx, "SELECT claim,grant_body FROM kg_object_gateway_deliveries ORDER BY attempt_epoch") + must(e) + defer rows.Close() + i := 0 + for rows.Next() { + var cRaw, gRaw []byte + must(rows.Scan(&cRaw, &gRaw)) + var c objectgateway.Claim + var g objectgateway.Grant + must(json.Unmarshal(cRaw, &c)) + must(json.Unmarshal(gRaw, &g)) + i++ + if c.JobID != job.ID || c.OperationID != op.ID || c.AttemptEpoch != int64(i) || g.Epoch != int64(i) || c.PlanDigest != receipt.Request.Grant.Plan { + t.Fatal("delivery replaced original plan/operation") + } + } + must(rows.Err()) + // Latest read must return the original committed bytes, not merely a matching count. + got, e := fx.objects.s3.client.GetObject(ctx, &s3.GetObjectInput{Bucket: aws.String(fx.bucket), Key: aws.String(receipt.Request.Key)}) + must(e) + body, e := io.ReadAll(got.Body) + got.Body.Close() + must(e) + if !bytes.Equal(body, []byte("12345678")) { + t.Fatal("latest body mismatch") + } + + save("result.json", map[string]any{"formal_worker_sigkills": 2, "attempts": attempts, "deliveries": deliveries, "receipts": receipts, "job": job.ID, "state": "succeeded", "snapshot": snapshot}) + + // Exact version cleanup only after all assertions; failures preserve the bucket. + for _, v := range finalObjects.Versions { + _, e = fx.objects.s3.client.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(fx.bucket), Key: v.Key, VersionId: v.VersionId}) + must(e) + } + empty := objectInventory() + if len(empty.Versions) != 0 { + t.Fatal("cleanup left object versions") + } + _, e = fx.objects.s3.client.DeleteBucket(ctx, &s3.DeleteBucketInput{Bucket: aws.String(fx.bucket)}) + must(e) + _, e = fx.objects.s3.client.HeadBucket(ctx, &s3.HeadBucketInput{Bucket: aws.String(fx.bucket)}) + var status interface{ HTTPStatusCode() int } + if !errors.As(e, &status) || status.HTTPStatusCode() != 404 { + t.Fatal("bucket absence not independently confirmed", e) + } + save("object-cleanup.json", map[string]any{"bucket": fx.bucket, "versions": 0, "delete_markers": 0, "bucket_absent": true}) + t.Logf("formal worker twice SIGKILL succeeded: job=%s attempts=%d deliveries=%d receipts=%d", job.ID, attempts, deliveries, receipts) +} diff --git a/internal/releaseadapter/v071/library_contract_durability_test.go b/internal/releaseadapter/v071/library_contract_durability_test.go new file mode 100644 index 0000000..512f187 --- /dev/null +++ b/internal/releaseadapter/v071/library_contract_durability_test.go @@ -0,0 +1,80 @@ +package v071 + +import ( + "encoding/json" + "os" + "sync" + "testing" + "time" + + "knowledge-governance/internal/libraryrelease" + "knowledge-governance/internal/librarysnapshot" +) + +func TestContractIndexPreservesLargeInteger(t *testing.T) { + a, err := canonicalJSON(json.RawMessage(`{"n":9007199254740993}`)) + if err != nil { + t.Fatal(err) + } + if string(a) != `{"n":9007199254740993}` { + t.Fatalf("integer rounded: %s", a) + } +} + +func TestContractOrphanQueryFailureIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + fx.indexDoc(t, "chunk-src", wsTargetTenant, wsTargetKB, "doc-src", "来源正文 resource://"+wsHandleSource) + archive, err := librarysnapshot.Open(fx.archiveRoot, 256*1024*1024) + if err != nil { + t.Fatal(err) + } + defer archive.Close() + manifest, err := archive.Load(snapshot) + if err != nil { + t.Fatal(err) + } + if _, err := fx.pool.Exec(fx.ctx, `ALTER TABLE knowledges RENAME TO unavailable_knowledges`); err != nil { + t.Fatal(err) + } + if err := target.verifyIndexDigest(fx.ctx, archive, manifest); err == nil { + t.Fatal("database oracle error accepted as no orphans") + } +} + +func TestContractImmutableWriteSetConcurrent(t *testing.T) { + root := t.TempDir() + set := libraryrelease.WriteSet{Version: libraryrelease.WriteSetVersion, JobID: "job", Target: "internal", TenantID: 1, KnowledgeBaseID: "kb", + BackupSnapshotID: "backup", TargetSnapshotID: "snapshot", CreatedAt: time.Now().UTC(), Universe: map[string]libraryrelease.TableFingerprint{"chunks": {Count: 0, Digest: "empty"}}} + if err := set.Seal(); err != nil { + t.Fatal(err) + } + var wg sync.WaitGroup + errs := make(chan error, 32) + for i := 0; i < 32; i++ { + wg.Add(1) + go func() { defer wg.Done(); copy := set; _, err := PersistWriteSet(root, ©); errs <- err }() + } + wg.Wait() + close(errs) + for err := range errs { + if err != nil { + t.Errorf("immutable concurrent commit: %v", err) + } + } + loaded, err := LoadWriteSet(root, set.Digest) + if err != nil { + t.Fatal(err) + } + if loaded.Digest != set.Digest { + t.Fatal("digest changed") + } + entries, err := os.ReadDir(root + "/writesets") + if err != nil { + t.Fatal(err) + } + if len(entries) != 1 { + t.Fatalf("temporary files leaked: %d", len(entries)) + } +} diff --git a/internal/releaseadapter/v071/library_contract_external_test.go b/internal/releaseadapter/v071/library_contract_external_test.go new file mode 100644 index 0000000..3333cbc --- /dev/null +++ b/internal/releaseadapter/v071/library_contract_external_test.go @@ -0,0 +1,43 @@ +package v071 + +import ( + "knowledge-governance/internal/libraryrelease" + "testing" +) + +func TestContractIndexConflictBeforeAnyWriteIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + fx.indexDoc(t, "chunk-src", wsTargetTenant, wsOtherKB, "doc-other", "protected foreign vector") + before := universeDump(t, fx.pool) + puts := fx.objects.puts.Load() + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if outcome.State != "failed" || outcome.FailedAt != "" { + t.Fatalf("index collision must fail preflight: %+v", outcome) + } + if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { + t.Fatalf("preflight changed PG: %s", diff) + } + if fx.objects.puts.Load() != puts { + t.Fatal("index conflict detected after object write") + } +} + +func TestContractSharedBackupResourceCannotChangeIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + before := universeDump(t, fx.pool) + snapshot := sealSourceSnapshotScope(t, fx, wsSourceTenant, wsSourceKB, func(parts map[string][]map[string]any) { + parts["resources"] = append(parts["resources"], map[string]any{"id": "res-shared", "handle": "gggggggggggggggggggggg", "tenant_id": wsSourceTenant, "storage_backend_id": "backend-source", "provider": "oss", "physical_path": wsLocator("backend-source", "oss", "source-bucket", wsSourceTenant, "res-shared"), "size": int64(8)}) + }, map[string]string{"res-shared": "12345678"}) + target := fx.target(t) + outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if outcome.State != "failed" || outcome.FailedAt != "" { + t.Fatalf("shared resource difference must fail preflight: %+v", outcome) + } + if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { + t.Fatalf("shared resource overwritten: %s", diff) + } +} diff --git a/internal/releaseadapter/v071/library_contract_plan_integration_test.go b/internal/releaseadapter/v071/library_contract_plan_integration_test.go new file mode 100644 index 0000000..0149fe4 --- /dev/null +++ b/internal/releaseadapter/v071/library_contract_plan_integration_test.go @@ -0,0 +1,171 @@ +package v071 + +import ( + "encoding/json" + "testing" + + "knowledge-governance/internal/libraryrelease" + "knowledge-governance/internal/librarysnapshot" +) + +func TestContractLocalNumbersAndReplayIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + for _, sql := range []string{ + `ALTER TABLE chunks ADD COLUMN seq_id bigserial UNIQUE`, + `ALTER TABLE knowledge_tags ADD COLUMN seq_id bigserial UNIQUE`, + `CREATE SEQUENCE wiki_log_entries_id_seq; ALTER TABLE wiki_log_entries ALTER COLUMN id SET DEFAULT nextval('wiki_log_entries_id_seq'); ALTER SEQUENCE wiki_log_entries_id_seq OWNED BY wiki_log_entries.id; ALTER TABLE wiki_log_entries ADD PRIMARY KEY(id)`, + `INSERT INTO knowledge_tags(id,tenant_id,knowledge_base_id) VALUES('other-tag',10001,'kb-other')`, + `INSERT INTO wiki_log_entries(tenant_id,knowledge_base_id) VALUES(10001,'kb-other')`, + } { + if _, err := fx.pool.Exec(fx.ctx, sql); err != nil { + t.Fatal(err) + } + } + before := universeDump(t, fx.pool) + snapshot := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) { + parts["chunks"][0]["seq_id"] = 1 + parts["knowledge_tags"] = []map[string]any{{"id": "tag-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "seq_id": 1}} + parts["wiki_log_entries"] = []map[string]any{{"id": 1, "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB}, {"id": 2, "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB}} + }) + target := fx.target(t) + outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if outcome.State != "succeeded" { + t.Fatalf("typed local numbers must publish: %+v", outcome) + } + published := universeDump(t, fx.pool) + if err := target.Apply(fx.ctx, libraryrelease.StageIndex, outcome.Backup.SnapshotID); err == nil { + t.Fatal("frozen plan accepted another snapshot in index Apply") + } + for _, name := range []string{"wrong-source-tenant", "wrong-source-kb", "missing-mapping", "missing-wiki-row", "legacy-plan-with-local-ids", "missing-object", "wrong-object-bytes"} { + t.Run(name, func(t *testing.T) { + raw, _ := json.Marshal(outcome.Backup.WriteSet) + var invalid libraryrelease.WriteSet + if err := json.Unmarshal(raw, &invalid); err != nil { + t.Fatal(err) + } + switch name { + case "missing-object": + invalid.Objects = nil + case "wrong-object-bytes": + invalid.Objects[0].Bytes++ + case "wrong-source-tenant": + invalid.SourceTenantID++ + case "wrong-source-kb": + invalid.SourceKnowledgeBaseID = "different-source" + case "missing-mapping": + invalid.LocalIDs = nil + case "missing-wiki-row": + for i, row := range invalid.Rows { + if row.Table == "wiki_log_entries" { + invalid.Rows = append(invalid.Rows[:i], invalid.Rows[i+1:]...) + break + } + } + case "legacy-plan-with-local-ids": + invalid.ContractVersion = 0 + invalid.LocalIDs = nil + invalid.SourceTenantID = 0 + invalid.SourceKnowledgeBaseID = "" + } + if err := invalid.Seal(); err != nil { + t.Fatal(err) + } + if err := fx.target(t).AdoptWriteSet(invalid); err == nil { + t.Fatal("accepted incomplete/source-mismatched persisted plan") + } + }) + } + // Recreate the adapter, consume only the exact persisted plan, and replay. + next := fx.target(t) + if err := next.AdoptWriteSet(*outcome.Backup.WriteSet); err != nil { + t.Fatal(err) + } + for _, stage := range libraryrelease.Stages() { + if err := next.Apply(fx.ctx, stage, snapshot); err != nil { + t.Fatal(err) + } + } + if diff := diffUniverse(published, universeDump(t, fx.pool)); diff != "" { + t.Fatalf("replay reassigned local values: %s", diff) + } + if err := next.Verify(fx.ctx, libraryrelease.Expectation{SnapshotID: snapshot}); err != nil { + t.Fatal(err) + } + if err := next.Restore(fx.ctx, outcome.Backup); err != nil { + t.Fatal(err) + } + if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { + t.Fatalf("rollback lost local values: %s", diff) + } +} + +func TestContractBackupIncludesDeletedRowsIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + for _, sql := range []string{ + `INSERT INTO knowledges(id,tenant_id,knowledge_base_id,deleted_at) VALUES('deleted-doc',10001,'kb-target',now())`, + `INSERT INTO chunks(id,tenant_id,knowledge_base_id,knowledge_id,deleted_at) VALUES('deleted-chunk',10001,'kb-target','deleted-doc',now())`, + `INSERT INTO knowledge_tags(id,tenant_id,knowledge_base_id,deleted_at) VALUES('deleted-tag',10001,'kb-target',now())`, + `INSERT INTO knowledge_tag_relations(knowledge_id,tag_id) VALUES('deleted-doc','deleted-tag')`, + `INSERT INTO wiki_pages(id,tenant_id,knowledge_base_id,slug,deleted_at) VALUES('deleted-page',10001,'kb-target','deleted',now())`, + } { + if _, err := fx.pool.Exec(fx.ctx, sql); err != nil { + t.Fatal(err) + } + } + target := fx.target(t) + current, err := target.Current(fx.ctx) + if err != nil { + t.Fatal(err) + } + backup, err := fx.backups(t, target).Prepare(fx.ctx, "", current) + if err != nil { + t.Fatal(err) + } + archive, err := librarysnapshot.Open(fx.archiveRoot, 256*1024*1024) + if err != nil { + t.Fatal(err) + } + defer archive.Close() + manifest, err := archive.Load(backup.SnapshotID) + if err != nil { + t.Fatal(err) + } + counts := map[string]int64{} + for _, part := range manifest.Parts { + if part.Kind == "database" || part.Kind == "wiki" { + counts[part.Name] = part.Count + } + } + for _, table := range []string{"knowledges", "chunks", "knowledge_tags", "knowledge_tag_relations", "wiki_pages"} { + if counts[table] != current.Counts[table] { + t.Fatalf("before-image omits actual delete rows in %s: backup=%d affected=%d", table, counts[table], current.Counts[table]) + } + } + // Keep this check independent of the normalization used by the importer. + for _, part := range manifest.Parts { + if part.Name != "knowledges" { + continue + } + reader, err := archive.OpenPart(part) + if err != nil { + t.Fatal(err) + } + var rows []map[string]json.RawMessage + err = json.NewDecoder(reader).Decode(&rows) + reader.Close() + if err != nil { + t.Fatal(err) + } + found := false + for _, row := range rows { + if string(row["id"]) == `"deleted-doc"` && string(row["deleted_at"]) != "null" { + found = true + } + } + if !found { + t.Fatal("deleted before-image absent") + } + } +} diff --git a/internal/releaseadapter/v071/library_evidence_directory_test.go b/internal/releaseadapter/v071/library_evidence_directory_test.go new file mode 100644 index 0000000..a31d8c0 --- /dev/null +++ b/internal/releaseadapter/v071/library_evidence_directory_test.go @@ -0,0 +1,47 @@ +package v071 + +import ( + "errors" + "os" + "path/filepath" + "testing" +) + +func TestContractEvidenceRejectsAncestorSymlinkBeforeWrite(t *testing.T) { + root := t.TempDir() + outside := t.TempDir() + if err := os.Symlink(outside, filepath.Join(root, "effects")); err != nil { + t.Fatal(err) + } + if err := persistImmutableJSON(filepath.Join(root, "effects", "job", "index", "id", "intent.json"), []byte(`{"intent":true}`)); err == nil { + t.Fatal("ancestor symlink accepted") + } + entries, err := os.ReadDir(outside) + if err != nil { + t.Fatal(err) + } + if len(entries) != 0 { + t.Fatal("refusal wrote through ancestor symlink") + } +} + +func TestContractEvidenceSyncsEveryAncestorAndPropagatesFailure(t *testing.T) { + root := t.TempDir() + leaf := filepath.Join(root, "effects", "plan", "index", "id") + synced := map[string]bool{} + if err := ensureEvidenceDirectory(leaf, func(path string) error { synced[path] = true; return syncEvidenceDirectory(path) }); err != nil { + t.Fatal(err) + } + for path := filepath.Dir(leaf); ; path = filepath.Dir(path) { + if !synced[path] { + t.Fatalf("unsynced directory entry parent: %s", path) + } + if filepath.Dir(path) == path { + break + } + } + failure := errors.New("injected directory fsync error") + if err := ensureEvidenceDirectory(leaf, func(string) error { return failure }); !errors.Is(err, failure) { + t.Fatalf("fsync error not propagated: %v", err) + } +} diff --git a/internal/releaseadapter/v071/library_export_test.go b/internal/releaseadapter/v071/library_export_test.go index 4b8a012..31c0e66 100644 --- a/internal/releaseadapter/v071/library_export_test.go +++ b/internal/releaseadapter/v071/library_export_test.go @@ -120,6 +120,17 @@ type libraryFixtureRow struct { func (r libraryFixtureRow) Scan(dest ...any) error { switch { + case strings.Contains(r.sql, "library-relational-closure"), strings.Contains(r.sql, "library-resource-owner-closure"): + *dest[0].(*bool) = false + case strings.Contains(r.sql, "jsonb_agg(to_jsonb(q))"): + *dest[0].(*[]byte) = []byte(`[]`) + if strings.Contains(r.sql, "relrowsecurity") { + rows := []map[string]any{} + for _, table := range productionLibraryTables { + rows = append(rows, map[string]any{"table_name": table, "kind": "r"}) + } + *dest[0].(*[]byte), _ = json.Marshal(rows) + } case strings.Contains(r.sql, "library-source-settlement"): *dest[0].(*int64) = r.d.unsettled *dest[1].(*int64) = r.d.pending + r.d.sourcePending diff --git a/internal/releaseadapter/v071/library_identity_contract_test.go b/internal/releaseadapter/v071/library_identity_contract_test.go new file mode 100644 index 0000000..ea2588e --- /dev/null +++ b/internal/releaseadapter/v071/library_identity_contract_test.go @@ -0,0 +1,108 @@ +package v071 + +import ( + "bytes" + "encoding/json" + "os" + "testing" + + "knowledge-governance/internal/librarysnapshot" +) + +func TestContractNumericIdentityIsNotLost(t *testing.T) { + row := map[string]json.RawMessage{"id": json.RawMessage(`9007199254740993`)} + if got := archiveRowIdentity("wiki_log_entries", row); got != "9007199254740993" { + t.Fatalf("bigint identity lost: %q", got) + } +} + +func TestContractUnknownNonemptyIdentityRejected(t *testing.T) { + for _, tc := range []struct{ name, table, body string }{ + {"missing", "chunks", `[{}]`}, + {"numeric_string", "wiki_log_entries", `[{"id":"18"}]`}, + {"fraction", "wiki_log_entries", `[{"id":18.5}]`}, + {"unknown_table", "unreviewed", `[{"id":"uuid"}]`}, + {"duplicate", "chunks", `[{"id":"same"},{"id":"same"}]`}, + } { + t.Run(tc.name, func(t *testing.T) { + root := t.TempDir() + if err := os.Chmod(root, 0700); err != nil { + t.Fatal(err) + } + archive, err := librarysnapshot.Open(root, 1024*1024) + if err != nil { + t.Fatal(err) + } + defer archive.Close() + part, err := archive.Put(bytes.NewBufferString(tc.body)) + if err != nil { + t.Fatal(err) + } + part.Name = tc.table + if ids, err := archivedRowIdentities(archive, part); err == nil { + t.Fatalf("unsafe identity accepted: %v", ids) + } + }) + } +} + +func TestContractContentPreservesIntegersAndExpiry(t *testing.T) { + for _, pair := range [][2]string{ + {`{"metadata":{"n":9007199254740992}}`, `{"metadata":{"n":9007199254740993}}`}, + {`{"expires_at":"2026-01-01T00:00:00Z"}`, `{"expires_at":"2027-01-01T00:00:00Z"}`}, + } { + var a, b map[string]json.RawMessage + if err := json.Unmarshal([]byte(pair[0]), &a); err != nil { + t.Fatal(err) + } + if err := json.Unmarshal([]byte(pair[1]), &b); err != nil { + t.Fatal(err) + } + x, err := canonicalRowDigest(a) + if err != nil { + t.Fatal(err) + } + y, err := canonicalRowDigest(b) + if err != nil { + t.Fatal(err) + } + if x == y { + t.Fatalf("distinct content collapsed: %s vs %s", pair[0], pair[1]) + } + } +} + +func TestContractExactTupleAndSameTenantIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + if _, err := fx.pool.Exec(fx.ctx, `INSERT INTO knowledge_tags(id,tenant_id,knowledge_base_id) VALUES('tag-target',10001,'kb-target'); INSERT INTO knowledge_tag_relations(knowledge_id,tag_id) VALUES('doc-target','tag-target')`); err != nil { + t.Fatal(err) + } + target := fx.target(t) + owners, err := target.existingRowOwners(fx.ctx, "knowledge_tag_relations", []string{"doc-target:tag-target", "doc-target:absent"}) + if err != nil { + t.Fatal(err) + } + if len(owners) != 1 || owners["doc-target:tag-target"] != "10001/kb-target" { + t.Fatalf("tuple existence wrong: %v", owners) + } + snapshot := sealSourceSnapshotScope(t, fx, wsTargetTenant, wsSourceKB, nil, nil) + archive, err := librarysnapshot.Open(fx.archiveRoot, 256*1024*1024) + if err != nil { + t.Fatal(err) + } + defer archive.Close() + manifest, err := archive.Load(snapshot) + if err != nil { + t.Fatal(err) + } + if _, err := fx.pool.Exec(fx.ctx, `INSERT INTO knowledges(id,tenant_id,knowledge_base_id) VALUES('doc-src',10001,'kb-target')`); err != nil { + t.Fatal(err) + } + if err := target.bindSnapshotScope(manifestScope{tenantID: wsTargetTenant, knowledgeBaseID: wsSourceKB}); err != nil { + t.Fatal(err) + } + if err := target.assertNoSourceScopeRows(fx.ctx, archive, manifest); err != nil { + t.Fatalf("correct same-tenant target mistaken for source residue: %v", err) + } +} diff --git a/internal/releaseadapter/v071/library_index_claim_test.go b/internal/releaseadapter/v071/library_index_claim_test.go new file mode 100644 index 0000000..81ff5af --- /dev/null +++ b/internal/releaseadapter/v071/library_index_claim_test.go @@ -0,0 +1,128 @@ +package v071 + +import ( + "encoding/json" + "net/http" + "testing" + + "knowledge-governance/internal/libraryrelease" +) + +func TestContractIndexUnknownEvidenceBoundariesIsolated(t *testing.T) { + for _, scenario := range []string{"wrong-marker", "changed-content", "changed-generation", "unrecorded-finalize"} { + t.Run(scenario, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + current, err := target.Current(fx.ctx) + if err != nil { + t.Fatal(err) + } + backup, err := fx.backups(t, target).Prepare(fx.ctx, snapshot, current) + if err != nil { + t.Fatal(err) + } + backup.WriteSet = planLedgerWithUniverse(t, target, snapshot, backup.SnapshotID, backup.Universe) + var change libraryrelease.IndexWrite + for _, c := range backup.WriteSet.Index { + if len(c.Before) == 0 && len(c.After) > 0 { + change = c + break + } + } + if change.ID == "" { + t.Fatal("fixture has no new ID") + } + if err = target.saveIndexEffect(change, "apply-intent", nil); err != nil { + t.Fatal(err) + } + body, err := target.indexClaimBody(change) + if err != nil { + t.Fatal(err) + } + receipt, err := target.mutatePlannedIndex(fx.ctx, change, body, nil, nil, true) + if err != nil { + t.Fatal(err) + } + receipt.Marked = true + switch scenario { + case "wrong-marker", "changed-content": + var data map[string]json.RawMessage + if err = json.Unmarshal(body, &data); err != nil { + t.Fatal(err) + } + if scenario == "wrong-marker" { + data["content"] = json.RawMessage(`"foreign-owner-marker"`) + } else { + data["knowledge_id"] = json.RawMessage(`"different-knowledge"`) + } + body, err = json.Marshal(data) + if err != nil { + t.Fatal(err) + } + case "changed-generation", "unrecorded-finalize": + if err = target.saveIndexEffect(change, "claimed", &receipt); err != nil { + t.Fatal(err) + } + if scenario == "unrecorded-finalize" { + if err = target.saveIndexEffect(change, "finalize-intent", &receipt); err != nil { + t.Fatal(err) + } + body = change.After + } + } + if _, err = target.mutatePlannedIndex(fx.ctx, change, body, receipt.SeqNo, receipt.PrimaryTerm, false); err != nil { + t.Fatal(err) + } + before, err := target.observePlannedIndex(fx.ctx, change) + if err != nil { + t.Fatal(err) + } + next := fx.target(t) + if err = next.Restore(fx.ctx, backup); err == nil { + t.Fatal("unattributable write was compensated") + } + after, err := next.observePlannedIndex(fx.ctx, change) + if err != nil || !sameIndexGeneration(after, before.SeqNo, before.PrimaryTerm) || !indexBytesEqual(after, mustCanonicalIndex(t, before.Source)) { + t.Fatal("refused recovery changed foreign content", err) + } + }) + } +} +func mustCanonicalIndex(t *testing.T, raw json.RawMessage) json.RawMessage { + t.Helper() + body, err := canonicalJSON(raw) + if err != nil { + t.Fatal(err) + } + return body +} + +func TestContractIndexClaimDoesNotAlterMappingIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + before, err := target.Search().MappingSHA256(fx.ctx) + if err != nil { + t.Fatal(err) + } + result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if result.State != "succeeded" { + t.Fatalf("apply: %+v", result) + } + after, err := target.Search().MappingSHA256(fx.ctx) + if err != nil || before != after { + t.Fatal("operation provenance mutated business mapping", err) + } + for _, change := range result.Backup.WriteSet.Index { + observed, err := target.observePlannedIndex(fx.ctx, change) + if err != nil || !indexBytesEqual(observed, change.After) { + t.Fatal("transient marker survived successful release", err) + } + } +} + +// Compile-time guard: test transport continues to implement the real interface. +var _ http.RoundTripper = (*indexLostResponseTransport)(nil) diff --git a/internal/releaseadapter/v071/library_index_delete_reconcile_test.go b/internal/releaseadapter/v071/library_index_delete_reconcile_test.go new file mode 100644 index 0000000..a421398 --- /dev/null +++ b/internal/releaseadapter/v071/library_index_delete_reconcile_test.go @@ -0,0 +1,108 @@ +package v071 + +import ( + "errors" + "net/http" + "net/url" + "strings" + "testing" + + "knowledge-governance/internal/libraryrelease" +) + +type indexDeleteLostResponse struct { + inner http.RoundTripper + id string + dropped bool + sends int +} + +func (f *indexDeleteLostResponse) RoundTrip(r *http.Request) (*http.Response, error) { + if r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/_doc/"+url.PathEscape(f.id)) { + f.sends++ + } + resp, e := f.inner.RoundTrip(r) + if e == nil && !f.dropped && r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/_doc/"+url.PathEscape(f.id)) && resp.StatusCode == 200 { + f.dropped = true + resp.Body.Close() + return nil, errors.New("injected response loss after exact CAS delete") + } + return resp, e +} +func TestContractIndexDeleteCompensationLostResponseIsolated(t *testing.T) { + runIndexDeleteReconcile(t, false) +} +func TestContractIndexDeleteRecreatedGenerationRefusedIsolated(t *testing.T) { + runIndexDeleteReconcile(t, true) +} +func runIndexDeleteReconcile(t *testing.T, recreate bool) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + before := universeDump(t, fx.pool) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if outcome.State != "succeeded" { + t.Fatalf("fixture release failed: %+v", outcome) + } + id := "" + var created libraryrelease.IndexWrite + for _, c := range outcome.Backup.WriteSet.Index { + if len(c.Before) == 0 && len(c.After) > 0 { + id = c.ID + created = c + break + } + } + if id == "" { + t.Fatal("valid newly-created index fixture missing") + } + client := *target.search.client + transport := client.Transport + if transport == nil { + transport = http.DefaultTransport + } + fault := &indexDeleteLostResponse{inner: transport, id: id} + client.Transport = fault + target.search.client = &client + if e := target.Restore(fx.ctx, outcome.Backup); e == nil || !fault.dropped { + t.Fatal("real CAS delete response loss not exercised", e) + } + next := fx.target(t) + next.search.client = &client + if recreate { + replacement, e := next.mutatePlannedIndex(fx.ctx, created, created.After, nil, nil, true) + if e != nil { + t.Fatal(e) + } + if e = next.Restore(fx.ctx, outcome.Backup); e == nil { + t.Fatal("recreated generation accepted as absent") + } + observed, e := next.observePlannedIndex(fx.ctx, created) + if e != nil || !sameIndexGeneration(observed, replacement.SeqNo, replacement.PrimaryTerm) || !indexBytesEqual(observed, created.After) { + t.Fatal("foreign successor changed", e) + } + if fault.sends != 1 { + t.Fatal("delete reissued against successor") + } + return + } + if e := next.Restore(fx.ctx, outcome.Backup); e != nil { + t.Fatal("known-generation delete absence did not reconcile", e) + } + repeated := fx.target(t) + repeated.search.client = &client + if e := repeated.Restore(fx.ctx, outcome.Backup); e != nil { + t.Fatal("repeated exact restoration", e) + } + if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { + t.Fatal(diff) + } + if e := next.Verify(fx.ctx, libraryrelease.Expectation{SnapshotID: outcome.Backup.SnapshotID}); e != nil { + t.Fatal(e) + } + if fault.sends != 1 { + t.Fatal("exact CAS delete blindly replayed", fault.sends) + } + t.Log("real ES CAS deletion committed with response lost; fresh target restored exact backup without reissuing delete") +} diff --git a/internal/releaseadapter/v071/library_index_effects_test.go b/internal/releaseadapter/v071/library_index_effects_test.go new file mode 100644 index 0000000..d149277 --- /dev/null +++ b/internal/releaseadapter/v071/library_index_effects_test.go @@ -0,0 +1,102 @@ +package v071 + +import ( + "errors" + "io" + "knowledge-governance/internal/libraryrelease" + "net/http" + "path/filepath" + "strings" + "testing" +) + +type indexLostResponseTransport struct { + inner http.RoundTripper + dropped bool +} + +func (t *indexLostResponseTransport) RoundTrip(r *http.Request) (*http.Response, error) { + resp, err := t.inner.RoundTrip(r) + if err == nil && !t.dropped && r.Method == http.MethodPut && strings.Contains(r.URL.Path, "/_create/") && resp.StatusCode < 300 { + t.dropped = true + _, _ = io.Copy(io.Discard, resp.Body) + resp.Body.Close() + return nil, errors.New("injected lost response after real ES commit") + } + return resp, err +} + +func TestContractIndexLostResponseNeverDeletesUnknownIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + client := *target.search.client + transport := client.Transport + if transport == nil { + transport = http.DefaultTransport + } + fault := &indexLostResponseTransport{inner: transport} + client.Transport = fault + target.search.client = &client + current, err := target.Current(fx.ctx) + if err != nil { + t.Fatal(err) + } + backup, err := fx.backups(t, target).Prepare(fx.ctx, snapshot, current) + if err != nil { + t.Fatal(err) + } + backup.WriteSet = planLedgerWithUniverse(t, target, snapshot, backup.SnapshotID, backup.Universe) + var unknown *libraryrelease.IndexWrite + for i, c := range target.activePlan.Index { + if len(c.Before) == 0 && len(c.After) > 0 { + unknown = &target.activePlan.Index[i] + break + } + } + if unknown == nil { + t.Fatal("fixture lacks a new ID") + } + if err = target.saveIndexEffect(*unknown, "apply-intent", nil); err != nil { + t.Fatal(err) + } + // A legacy/unattributable successful write: identical content has NO marker. + if _, err = target.mutatePlannedIndex(fx.ctx, *unknown, unknown.After, nil, nil, true); err == nil || !fault.dropped { + t.Fatal("response-loss fixture not exercised") + } + + observed, err := target.observePlannedIndex(fx.ctx, *unknown) + if err != nil || !indexBytesEqual(observed, unknown.After) { + t.Fatalf("unknown create was deleted or bytes lost: %v", err) + } + next := fx.target(t) + if err = next.AdoptWriteSet(*backup.WriteSet); err != nil { + t.Fatal(err) + } + if err = next.Restore(fx.ctx, backup); err == nil { + t.Fatal("fresh adapter treated unknown as failed create") + } + observed, err = next.observePlannedIndex(fx.ctx, *unknown) + if err != nil || !indexBytesEqual(observed, unknown.After) { + t.Fatalf("fresh adapter deleted unknown effect: %v", err) + } +} + +func TestContractIndexWritesHaveDurableReceiptsIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), contractFailWikiTarget{target}, fx.backups(t, target), nil) + if outcome.State != "rolled_back" { + t.Fatalf("rollback: %+v", outcome) + } + receipts, err := filepath.Glob(filepath.Join(fx.archiveRoot, "effects", "*", "index", "*", "applied.json")) + if err != nil { + t.Fatal(err) + } + if len(receipts) == 0 { + t.Fatal("index side effects completed without durable per-ID receipts") + } +} diff --git a/internal/releaseadapter/v071/library_index_restart_test.go b/internal/releaseadapter/v071/library_index_restart_test.go new file mode 100644 index 0000000..d379ddb --- /dev/null +++ b/internal/releaseadapter/v071/library_index_restart_test.go @@ -0,0 +1,109 @@ +package v071 + +import ( + "encoding/json" + "net/http" + "os" + "os/exec" + "path/filepath" + "testing" + + "knowledge-governance/internal/libraryrelease" +) + +func TestIndexRecoveryHelper(t *testing.T) { + if os.Getenv("KG_INDEX_RECOVERY_CHILD") != "1" { + t.Skip("isolated subprocess only") + } + fx := openWriteSetFixtureWith(t, writeSetFixtureOptions{archiveRoot: os.Getenv("KG_INDEX_RECOVERY_ARCHIVE"), index: os.Getenv("KG_INDEX_RECOVERY_INDEX")}) + raw, err := os.ReadFile(os.Getenv("KG_INDEX_RECOVERY_BACKUP")) + if err != nil { + t.Fatal(err) + } + var backup libraryrelease.BackupRef + if err = json.Unmarshal(raw, &backup); err != nil { + t.Fatal(err) + } + ledger, err := LoadWriteSet(fx.archiveRoot, backup.WriteSet.Digest) + if err != nil { + t.Fatal(err) + } + backup.WriteSet = ledger + target := fx.target(t) + if err = target.Restore(fx.ctx, backup); err != nil { + t.Fatal(err) + } + // A second restart/recovery must not need the now-deleted transient marker. + next := fx.target(t) + if err = next.Restore(fx.ctx, backup); err != nil { + t.Fatal("replayed restoration", err) + } + if err = next.Verify(fx.ctx, libraryrelease.Expectation{SnapshotID: backup.SnapshotID}); err != nil { + t.Fatal(err) + } +} + +func TestContractIndexLostResponseRestartCompensatesIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + before := universeDump(t, fx.pool) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + current, err := target.Current(fx.ctx) + if err != nil { + t.Fatal(err) + } + backup, err := fx.backups(t, target).Prepare(fx.ctx, snapshot, current) + if err != nil { + t.Fatal(err) + } + backup.WriteSet = planLedgerWithUniverse(t, target, snapshot, backup.SnapshotID, backup.Universe) + client := *target.search.client + transport := client.Transport + if transport == nil { + transport = http.DefaultTransport + } + fault := &indexLostResponseTransport{inner: transport} + client.Transport = fault + target.search.client = &client + for _, stage := range []libraryrelease.Stage{libraryrelease.StageDatabase, libraryrelease.StageResources} { + if err = target.Apply(fx.ctx, stage, snapshot); err != nil { + t.Fatal(err) + } + } + if err = target.Apply(fx.ctx, libraryrelease.StageIndex, snapshot); err == nil || !fault.dropped { + t.Fatal("real ES commit/response loss not exercised", err) + } + // Persist only the same backup/plan identity needed by a new executable. + raw, err := json.Marshal(backup) + if err != nil { + t.Fatal(err) + } + state := filepath.Join(t.TempDir(), "backup.json") + if err = persistImmutableJSON(state, raw); err != nil { + t.Fatal(err) + } + command := exec.Command(os.Args[0], "-test.run=^TestIndexRecoveryHelper$", "-test.v") + command.Env = append(os.Environ(), "KG_INDEX_RECOVERY_CHILD=1", "KG_INDEX_RECOVERY_ARCHIVE="+fx.archiveRoot, "KG_INDEX_RECOVERY_INDEX="+fx.index, "KG_INDEX_RECOVERY_BACKUP="+state) + output, err := command.CombinedOutput() + if err != nil { + t.Fatalf("fresh process compensation failed: %v\n%s", err, output) + } + t.Log(string(output)) + if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { + t.Fatal(diff) + } + paths, err := filepath.Glob(filepath.Join(fx.archiveRoot, "effects", backup.WriteSet.Digest, "index", "*", "claimed.json")) + if err != nil || len(paths) == 0 { + t.Fatal("reconciled receipt not durable", err) + } + for _, path := range paths { + info, err := os.Stat(path) + if err != nil || info.Mode().Perm()&0222 != 0 { + t.Fatal("receipt not immutable", err) + } + } + if err = target.Verify(fx.ctx, libraryrelease.Expectation{SnapshotID: backup.SnapshotID}); err != nil { + t.Fatal(err) + } +} diff --git a/internal/releaseadapter/v071/library_memory_object_contract_test.go b/internal/releaseadapter/v071/library_memory_object_contract_test.go new file mode 100644 index 0000000..e6ef326 --- /dev/null +++ b/internal/releaseadapter/v071/library_memory_object_contract_test.go @@ -0,0 +1,59 @@ +package v071 + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "fmt" + "io" +) + +// In-memory protocol model only; not evidence of any provider's atomicity. +func (s *memoryObjectStore) ConditionalCapability(context.Context) error { return nil } +func (s *memoryObjectStore) ObserveObject(_ context.Context, provider, path string) (objectObservation, error) { + key := objectKey(provider, path) + body, exists := s.objects[key] + if !exists { + return objectObservation{}, nil + } + sum := sha256.Sum256(body) + o := s.observations[key] + o.Exists = true + o.Bytes = int64(len(body)) + o.SHA256 = hex.EncodeToString(sum[:]) + o.ETag = o.SHA256 + if o.VersionID == "" { + o.VersionID = "seed" + } + return o, nil +} +func (s *memoryObjectStore) CreateObject(ctx context.Context, provider, path string, body io.Reader, size int64, owner string) error { + if s.failPut { + return errObjectWriteRejected + } + key := objectKey(provider, path) + if _, exists := s.objects[key]; exists { + return errObjectWriteRejected + } + if err := s.Put(ctx, provider, path, body, size); err != nil { + return err + } + if s.observations == nil { + s.observations = map[string]objectObservation{} + } + s.observations[key] = objectObservation{Owner: owner, VersionID: fmt.Sprint(len(s.puts))} + return nil +} +func (s *memoryObjectStore) RemoveObject(ctx context.Context, provider, path string, want objectObservation) error { + got, err := s.ObserveObject(ctx, provider, path) + if err != nil { + return err + } + if got != want || !got.Exists { + return errors.New("memory exact version mismatch") + } + delete(s.objects, objectKey(provider, path)) + delete(s.observations, objectKey(provider, path)) + return nil +} diff --git a/internal/releaseadapter/v071/library_natural_keys_test.go b/internal/releaseadapter/v071/library_natural_keys_test.go new file mode 100644 index 0000000..8d66f38 --- /dev/null +++ b/internal/releaseadapter/v071/library_natural_keys_test.go @@ -0,0 +1,31 @@ +package v071 + +import ( + "knowledge-governance/internal/libraryrelease" + "testing" +) + +func TestContractNaturalResourceConflictPreflightIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + if _, err := fx.pool.Exec(fx.ctx, `CREATE UNIQUE INDEX resources_handle_contract ON resources(handle)`); err != nil { + t.Fatal(err) + } + before := universeDump(t, fx.pool) + puts := fx.objects.puts.Load() + snapshot := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) { + parts["resources"][0]["handle"] = wsHandleOther + parts["chunks"][0]["content"] = "resource://" + wsHandleOther + }) + target := fx.target(t) + result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if result.State != "failed" || result.FailedAt != "" { + t.Fatalf("natural key collision reached writes: %+v", result) + } + if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { + t.Fatalf("conflict changed PG: %s", diff) + } + if fx.objects.puts.Load() != puts { + t.Fatal("conflict wrote objects") + } +} diff --git a/internal/releaseadapter/v071/library_object_effects_test.go b/internal/releaseadapter/v071/library_object_effects_test.go new file mode 100644 index 0000000..e6d9cd7 --- /dev/null +++ b/internal/releaseadapter/v071/library_object_effects_test.go @@ -0,0 +1,61 @@ +package v071 + +import ( + "context" + "errors" + "io" + "testing" + + "knowledge-governance/internal/libraryrelease" +) + +type contractFailWikiTarget struct{ *ProductionLibraryTarget } + +func (s *flakyStore) ConditionalCapability(ctx context.Context) error { + return s.s3.ConditionalCapability(ctx) +} +func (s *flakyStore) ObserveObject(ctx context.Context, provider, path string) (objectObservation, error) { + return s.s3.ObserveObject(ctx, provider, path) +} +func (s *flakyStore) RemoveObject(ctx context.Context, provider, path string, expected objectObservation) error { + return s.s3.RemoveObject(ctx, provider, path, expected) +} +func (s *flakyStore) CreateObject(ctx context.Context, provider, path string, reader io.Reader, size int64, owner string) error { + if s.failPut.Load() { + return errObjectWriteRejected + } + s.puts.Add(1) + return s.s3.CreateObject(ctx, provider, path, reader, size, owner) +} + +func (t contractFailWikiTarget) Apply(ctx context.Context, stage libraryrelease.Stage, snapshot string) error { + if stage == libraryrelease.StageWiki { + return errors.New("injected Wiki failure after object upload") + } + return t.ProductionLibraryTarget.Apply(ctx, stage, snapshot) +} + +func TestContractObjectCreatedThenFailureMustDisappearIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + before := universeDump(t, fx.pool) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), contractFailWikiTarget{target}, fx.backups(t, target), nil) + if outcome.State != "rolled_back" { + t.Fatalf("rollback: %+v", outcome) + } + if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { + t.Fatal(diff) + } + path := wsLocator("backend-target", "minio", wsBucket, wsTargetTenant, "res-src") + if _, _, err := fx.objects.s3.Stat(fx.ctx, "minio", path); err == nil { + t.Fatal("PG rollback passed but exact created object remains") + } + for _, id := range []string{"res-target", "res-other", "res-shared", "res-orphan"} { + path := wsLocator("backend-target", "minio", wsBucket, wsTargetTenant, id) + if n, _, err := fx.objects.s3.Stat(fx.ctx, "minio", path); err != nil || n != 8 { + t.Fatalf("pre-existing object changed: %s", id) + } + } +} diff --git a/internal/releaseadapter/v071/library_object_reconcile_test.go b/internal/releaseadapter/v071/library_object_reconcile_test.go new file mode 100644 index 0000000..cf846da --- /dev/null +++ b/internal/releaseadapter/v071/library_object_reconcile_test.go @@ -0,0 +1,130 @@ +package v071 + +import ( + "bytes" + "context" + "errors" + "io" + "strings" + "testing" + + "knowledge-governance/internal/libraryrelease" +) + +func TestContractObjectConditionalPrimitivesIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + path := wsLocator("backend-target", "minio", wsBucket, wsTargetTenant, "res-orphan") + before, err := fx.objects.s3.ObserveObject(fx.ctx, "minio", path) + if err != nil { + t.Fatal(err) + } + if err := fx.objects.s3.CreateObject(fx.ctx, "minio", path, bytes.NewReader([]byte("evil")), 4, strings.Repeat("a", 64)); err == nil { + t.Fatal("conditional create overwrote an existing object") + } + wrong := before + wrong.ETag = `"wrong-etag"` + if err := fx.objects.s3.RemoveObject(fx.ctx, "minio", path, wrong); err == nil { + t.Fatal("conditional delete accepted wrong ETag") + } + after, err := fx.objects.s3.ObserveObject(fx.ctx, "minio", path) + if err != nil || before != after { + t.Fatalf("conditional primitives changed existing object: %v", err) + } + unsupported := *fx.objects.s3 + unsupported.provider = "oss" + if err := unsupported.ConditionalCapability(fx.ctx); err == nil { + t.Fatal("untested provider declared conditional compatibility") + } +} + +type contractAmbiguousStore struct { + *flakyStore + beforeSend bool + rejectDelete bool + calls int +} + +func (s *contractAmbiguousStore) CreateObject(ctx context.Context, provider, path string, body io.Reader, n int64, owner string) error { + s.calls++ + if !s.beforeSend { + if err := s.flakyStore.CreateObject(ctx, provider, path, body, n, owner); err != nil { + return err + } + } + return errors.New("injected response loss") +} +func (s *contractAmbiguousStore) RemoveObject(ctx context.Context, provider, path string, expected objectObservation) error { + if s.rejectDelete { + return errors.New("injected delete transport failure") + } + return s.flakyStore.RemoveObject(ctx, provider, path, expected) +} + +func TestContractObjectUnknownReconciliationIsolated(t *testing.T) { + for _, beforeSend := range []bool{false, true} { + name := "applied-response-lost" + if beforeSend { + name = "absent-unknown-held" + } + t.Run(name, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + ambiguous := &contractAmbiguousStore{flakyStore: fx.objects, beforeSend: beforeSend} + target.config.Objects = ambiguous + outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + expected := "succeeded" + if beforeSend { + expected = "rollback_failed" + } + if outcome.State != expected || ambiguous.calls != 1 { + t.Fatalf("unknown outcome incorrectly handled: %+v calls=%d", outcome, ambiguous.calls) + } + next := fx.target(t) + next.config.Objects = ambiguous + if err := next.AdoptWriteSet(*outcome.Backup.WriteSet); err != nil { + t.Fatal(err) + } + if beforeSend { + if err := next.Restore(fx.ctx, outcome.Backup); err == nil { + t.Fatal("absent ambiguous write accepted as restored") + } + } else { + if err := next.Apply(fx.ctx, libraryrelease.StageResources, snapshot); err != nil { + t.Fatal(err) + } + if err := next.Restore(fx.ctx, outcome.Backup); err != nil { + t.Fatal(err) + } + } + if ambiguous.calls != 1 { + t.Fatal("ambiguous create was blindly retried after restart") + } + }) + } +} + +func TestContractObjectCleanupFailureReplayIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + before := universeDump(t, fx.pool) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + target.config.Objects = &contractAmbiguousStore{flakyStore: fx.objects, rejectDelete: true} + result := libraryrelease.Run(fx.ctx, requestFor(snapshot), contractFailWikiTarget{target}, fx.backups(t, target), nil) + if result.State != "rollback_failed" { + t.Fatalf("failed cleanup declared restored: %+v", result) + } + next := fx.target(t) + if err := next.Restore(fx.ctx, result.Backup); err != nil { + t.Fatal(err) + } + if err := next.Verify(fx.ctx, libraryrelease.Expectation{SnapshotID: result.Backup.SnapshotID}); err != nil { + t.Fatal(err) + } + if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { + t.Fatal(diff) + } +} diff --git a/internal/releaseadapter/v071/library_object_version_fixture_test.go b/internal/releaseadapter/v071/library_object_version_fixture_test.go new file mode 100644 index 0000000..800a1ae --- /dev/null +++ b/internal/releaseadapter/v071/library_object_version_fixture_test.go @@ -0,0 +1,23 @@ +package v071 + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/s3" + "github.com/aws/aws-sdk-go-v2/service/s3/types" + "strings" + "testing" +) + +func enableIsolatedObjectVersions(t *testing.T, ctx context.Context, store *S3ObjectStore) { + t.Helper() + if !strings.HasPrefix(store.bucket, "kg-library-test-") { + t.Fatal("versioning setup restricted to disposable fixture bucket") + } + if _, err := store.client.PutBucketVersioning(ctx, &s3.PutBucketVersioningInput{Bucket: aws.String(store.bucket), VersioningConfiguration: &types.VersioningConfiguration{Status: types.BucketVersioningStatusEnabled}}); err != nil { + t.Fatal(err) + } + if err := store.ConditionalCapability(ctx); err != nil { + t.Fatal(err) + } +} diff --git a/internal/releaseadapter/v071/library_production_target_integration_test.go b/internal/releaseadapter/v071/library_production_target_integration_test.go index 4d47bfd..271bc2e 100644 --- a/internal/releaseadapter/v071/library_production_target_integration_test.go +++ b/internal/releaseadapter/v071/library_production_target_integration_test.go @@ -23,7 +23,8 @@ import ( "knowledge-governance/internal/librarysnapshot" ) -// 隔离集成验证:真实 PostgreSQL + 真实 Elasticsearch,不放桩。 +// 隔离集成验证:真实 PostgreSQL + Elasticsearch,Wiki与Verify不打桩。 +// fixtureObjectStore是静态对象模型;真实对象版本由MinIO隔离套件另验。 // 需要显式一次性隔离库与随机索引(与既有捕获集成测试同一套环境变量), // 默认 CI 不连接这些服务,因此在 test-scope.json 里声明为可选未运行。 func TestLibraryProductionTargetIsolated(t *testing.T) { @@ -108,30 +109,36 @@ func TestLibraryProductionTargetIsolated(t *testing.T) { t.Fatalf("target: %v", err) } defer target.Close() - // 写集合在生产路径上是"写第一笔之前"算好的;这个用例直接调 Apply,所以在这里算, - // 整实例证据就是此刻(任何写入之前)的目标状态。 - // 夹具里那条软删除文档不在本快照里(快照只含 doc-safe/chunk-safe/wiki-safe), - // 恢复按目标范围回放会正确地把它清掉;为了让"整实例证据"与恢复结果可比,先删掉它。 - // 同时把夹具行的内容对齐到本快照(快照是可读的完整版本形态):整实例内容证据 - // 才可能与"恢复完成后的目标"逐字节一致。 - for _, statement := range []string{ - `DELETE FROM knowledges WHERE id='deleted-doc'`, - `UPDATE knowledges SET file_path='' WHERE id='doc-safe'`, - `UPDATE wiki_pages SET content='wiki', status=NULL WHERE id='wiki-safe'`, - // 快照里这些表是空的:目标范围先与它对齐,否则"整实例内容证据"比的是 - // 快照里不存在的行,恢复(正确地)删掉它们后反而被判不一致。 - `DELETE FROM resource_bindings`, - `DELETE FROM resources`, - `DELETE FROM wiki_page_issues`, - `DELETE FROM wiki_log_entries`, - `DELETE FROM knowledge_tags`, - `DELETE FROM knowledge_tag_relations`, - } { - if _, err := pool.Exec(ctx, statement); err != nil { + // Capture the actual target, not the source snapshot disguised as a backup. + call("PUT", "/"+index+"/_doc/chunk-safe?refresh=true", + `{"tenant_id":10000,"knowledge_base_id":"kb-safe","knowledge_id":"doc-safe","chunk_id":"chunk-safe","source_id":"chunk-safe","content":"chunk","embedding":[0.1,0.2]}`, 201) + mapping, err := target.Search().MappingSHA256(ctx) + if err != nil { + t.Fatal(err) + } + backups, err := NewProductionBackupStore(ProductionBackupConfig{ + Pool: target.Pool(), Search: target.Search(), Objects: fixtureObjectStore{}, ArchiveRoot: archiveRoot, + Scope: "internal", Identity: target.Identity(), MaxDocuments: 100, + Compatibility: librarysnapshot.Compatibility{WeKnoraVersion: "v0.7.1", SchemaVersion: 74, + RetrieverEngine: "elasticsearch_v8", EmbeddingModel: "text-embedding-v4", EmbeddingDimension: 1024, IndexMappingSHA256: mapping}, + }) + if err != nil { + t.Fatal(err) + } + prepare := func(snapshot string) libraryrelease.BackupRef { + t.Helper() + current, err := target.Current(ctx) + if err != nil { t.Fatal(err) } + backup, err := backups.Prepare(ctx, snapshot, current) + if err != nil { + t.Fatal(err) + } + backup.WriteSet = planLedgerWithUniverse(t, target, snapshot, backup.SnapshotID, backup.Universe) + return backup } - initialLedger := planLedgerFor(t, target, first, first) + prepare(first) for _, stage := range []libraryrelease.Stage{libraryrelease.StageDatabase, libraryrelease.StageWiki, libraryrelease.StageIndex} { if err := target.Apply(ctx, stage, first); err != nil { @@ -149,6 +156,8 @@ func TestLibraryProductionTargetIsolated(t *testing.T) { t.Fatalf("chunks after first sync = %d, want 1", chunks) } + // A new intent needs its own frozen plan and real before-image. + secondBackup := prepare(second) // 第二个快照没有 chunk:撤销必须真的从生产消失,而不是"只增不减"。 for _, stage := range []libraryrelease.Stage{libraryrelease.StageDatabase, libraryrelease.StageWiki, libraryrelease.StageIndex} { if err := target.Apply(ctx, stage, second); err != nil { @@ -174,42 +183,15 @@ func TestLibraryProductionTargetIsolated(t *testing.T) { } // 恢复:把第一个快照再应用一次,撤销的内容回来。 // 恢复必须带着写集合记录(生产路径在写第一笔之前就算好并落盘)。 - if err := target.Restore(ctx, libraryrelease.BackupRef{ID: "backup", SnapshotID: first, WriteSet: initialLedger}); err != nil { + if err := target.Restore(ctx, secondBackup); err != nil { t.Fatalf("restore: %v", err) } if err := target.Verify(ctx, libraryrelease.Expectation{SnapshotID: first}); err != nil { t.Fatalf("verify after restore: %v", err) } - // 独立预备份:从真实生产当前状态导出成归档版本,再用它做恢复演练。 - mapping, err := target.Search().MappingSHA256(ctx) - if err != nil { - t.Fatalf("mapping: %v", err) - } - // 预备份与发布快照放在同一个归档根(生产上就是 LIBRARY_ARCHIVE_ROOT): - // 恢复时按快照 ID 回放,不依赖"备份路径"这种第二套寻址。 - backupRoot := archiveRoot - backups, err := NewProductionBackupStore(ProductionBackupConfig{ - Pool: target.Pool(), Search: target.Search(), Objects: fixtureObjectStore{}, ArchiveRoot: backupRoot, - Scope: "internal", Identity: target.Identity(), MaxDocuments: 100, - Compatibility: librarysnapshot.Compatibility{WeKnoraVersion: "v0.7.1", SchemaVersion: 74, - RetrieverEngine: "elasticsearch_v8", EmbeddingModel: "text-embedding-v4", - EmbeddingDimension: 1024, IndexMappingSHA256: mapping}, - }) - if err != nil { - t.Fatalf("backup store: %v", err) - } - current, err := target.Current(ctx) - if err != nil { - t.Fatalf("current: %v", err) - } - backup, err := backups.Prepare(ctx, first, current) - if err != nil { - t.Fatalf("prepare backup: %v", err) - } - if backup.SnapshotID == "" || backup.Bytes <= 0 { - t.Fatalf("backup must carry a snapshot and bytes: %+v", backup) - } + // Freeze repair evidence before fault injection, never from damaged state. + backup := prepare(first) // 故障注入:直接破坏生产状态,校验必须失败,恢复后必须通过。 if _, err := pool.Exec(ctx, `DELETE FROM chunks WHERE id='chunk-safe'`); err != nil { @@ -218,9 +200,7 @@ func TestLibraryProductionTargetIsolated(t *testing.T) { if err := target.Verify(ctx, libraryrelease.Expectation{SnapshotID: first}); err == nil { t.Fatal("verify must detect a missing chunk row") } - // 这次恢复要用"预备份时刻"的整实例证据(Prepare 已经返回它),不是当前状态: - // 目标刚被故意破坏过,按现状算出来的证据会与恢复结果对不上。 - backup.WriteSet = planLedgerWithUniverse(t, target, backup.SnapshotID, backup.SnapshotID, backup.Universe) + if err := target.Restore(ctx, backup); err != nil { t.Fatalf("restore from backup: %v", err) } @@ -342,6 +322,13 @@ func TestLibraryReleaseRunIsolated(t *testing.T) { type fixtureObjectStore struct{} +// Static read-only object model, not evidence of any provider's versioning. +// These tests never mutate objects; the real-MinIO suites exercise that path. +func (fixtureObjectStore) ObserveObject(context.Context, string, string) (objectObservation, error) { + sum := sha256.Sum256([]byte("12345678")) + return objectObservation{Exists: true, VersionID: "fixture-static-v1", SHA256: hex.EncodeToString(sum[:]), Bytes: 8}, nil +} + // Open 返回与夹具资源行 size=8 一致的字节,供预备份读取对象。 func (fixtureObjectStore) Open(context.Context, string, string) (io.ReadCloser, error) { return io.NopCloser(strings.NewReader("12345678")), nil @@ -425,9 +412,10 @@ func sealTargetFixture(t *testing.T, archive *librarysnapshot.Archive, scope str // memoryObjectStore 是"真实字节"的资源存储替身:Put/Open/Stat/Copy 都按摘要核对, // 可以强制写入失败,用来复现"资源阶段失败"这一半写场景。 type memoryObjectStore struct { - objects map[string][]byte - failPut bool - puts []string + objects map[string][]byte + failPut bool + puts []string + observations map[string]objectObservation } func newMemoryObjectStore(objects map[string][]byte) *memoryObjectStore { @@ -652,6 +640,7 @@ func TestLibraryCrossScopeSyncRollbackLeavesNoResidueIsolated(t *testing.T) { // 2) 同样的跨范围同步,资源能写 → 行必须落在目标范围,资源定位符指向目标存储。 store.failPut = false + request.JobID = "job-cross-scope-next-intent" succeed := libraryrelease.Run(ctx, request, target, backups, nil) if succeed.State != "succeeded" { t.Fatalf("second run outcome = %+v", succeed) diff --git a/internal/releaseadapter/v071/library_resource_fk_test.go b/internal/releaseadapter/v071/library_resource_fk_test.go new file mode 100644 index 0000000..7d9a708 --- /dev/null +++ b/internal/releaseadapter/v071/library_resource_fk_test.go @@ -0,0 +1,65 @@ +package v071 + +import ( + "knowledge-governance/internal/libraryrelease" + "testing" +) + +func TestContractResourceGrantHoldsRestoreBeforeObjectDeleteIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + if _, err := fx.pool.Exec(fx.ctx, `CREATE TABLE resource_access_grants(id text PRIMARY KEY,resource_id text NOT NULL REFERENCES resources(id) ON DELETE CASCADE)`); err != nil { + t.Fatal(err) + } + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if outcome.State != "succeeded" { + t.Fatalf("publication: %+v", outcome) + } + if _, err := fx.pool.Exec(fx.ctx, `INSERT INTO resource_access_grants VALUES('after-publication','res-src')`); err != nil { + t.Fatal(err) + } + before := universeDump(t, fx.pool) + exactBefore := r10State(t, fx) + if err := target.Restore(fx.ctx, outcome.Backup); err == nil { + t.Fatal("external grant allowed destructive restore") + } + if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { + t.Fatalf("grant-protected restore changed PG: %s", diff) + } + r10Unchanged(t, fx, exactBefore) + var grantCount int + if err := fx.pool.QueryRow(fx.ctx, `SELECT count(*) FROM resource_access_grants WHERE id='after-publication'`).Scan(&grantCount); err != nil || grantCount != 1 { + t.Fatal("grant changed across held restore", err) + } + r10Save(t, "grant-readback", grantCount) + for _, object := range outcome.Backup.WriteSet.Objects { + if object.ResourceID == "res-src" { + got, err := fx.objects.s3.ObserveObject(fx.ctx, object.Provider, object.Locator) + if err != nil || !got.Exists || got.SHA256 != object.SHA256 { + t.Fatalf("grant-protected object lost: %v", err) + } + } + } +} + +func TestContractResourceGrantBlocksCreatedResourceCleanupIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + if _, err := fx.pool.Exec(fx.ctx, `CREATE TABLE resource_access_grants(id text PRIMARY KEY,resource_id text NOT NULL REFERENCES resources(id) ON DELETE CASCADE); INSERT INTO resources(id,tenant_id,handle) VALUES('protected-created',10001,'GrantProtectedResource'); INSERT INTO resource_access_grants VALUES('foreign-grant','protected-created')`); err != nil { + t.Fatal(err) + } + set := libraryrelease.WriteSet{Rows: []libraryrelease.WriteSetRow{{Table: "resources", ID: "protected-created"}}} + target := fx.target(t) + if err := target.clearJobCreatedRows(fx.ctx, set, map[string]map[string]bool{}); err == nil { + t.Error("cleanup cascaded external grant instead of holding recovery") + } + var grants, resources int + if err := fx.pool.QueryRow(fx.ctx, `SELECT (SELECT count(*) FROM resource_access_grants WHERE id='foreign-grant'),(SELECT count(*) FROM resources WHERE id='protected-created')`).Scan(&grants, &resources); err != nil { + t.Fatal(err) + } + if grants != 1 || resources != 1 { + t.Fatalf("external FK protection lost: grants=%d resources=%d", grants, resources) + } +} diff --git a/internal/releaseadapter/v071/library_reuse_integration_test.go b/internal/releaseadapter/v071/library_reuse_integration_test.go index 7f81cf3..989629c 100644 --- a/internal/releaseadapter/v071/library_reuse_integration_test.go +++ b/internal/releaseadapter/v071/library_reuse_integration_test.go @@ -238,7 +238,7 @@ func TestLibraryReuseRequiresSameSourceScopeIsolated(t *testing.T) { } } -// 部分写失败:database/resources 已提交、wiki 因重复 slug 失败 → 回滚只清"本次真新建", +// 显式注入晚期 Wiki 故障:database/resources 已提交,回滚只清"本次真新建", // 复用资源与历史孤儿原内容完整保留(xmin 也不变)。 func TestLibraryHalfWriteRollbackKeepsReusedResourcesIsolated(t *testing.T) { fx := openWriteSetFixture(t) @@ -259,14 +259,10 @@ func TestLibraryHalfWriteRollbackKeepsReusedResourcesIsolated(t *testing.T) { parts["resource_bindings"] = append(parts["resource_bindings"], map[string]any{"id": "bind-src-2", "resource_id": "res-new", "tenant_id": wsSourceTenant, "owner_type": "chunk", "owner_id": "chunk-src-2", "relation": "attachment"}) - // 同一作用域两页同 slug:wiki 的唯一索引让 wiki 阶段失败(真实半写现场)。 - parts["wiki_pages"] = []map[string]any{ - {"id": "wiki-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "slug": "index", "content": "来源 wiki"}, - {"id": "wiki-src-2", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "slug": "index", "content": "重复 slug"}, - } + }, map[string]string{"res-new": resNewBody}) - outcome := libraryrelease.Run(fx.ctx, requestForWithPrior(next, "job-sync-half-write", priors), target, backups, nil) + outcome := libraryrelease.Run(fx.ctx, requestForWithPrior(next, "job-sync-half-write", priors), contractFailWikiTarget{target}, backups, nil) if outcome.State != "rolled_back" { t.Fatalf("wiki 半写必须回滚:%+v", outcome) } diff --git a/internal/releaseadapter/v071/library_schema_contract_test.go b/internal/releaseadapter/v071/library_schema_contract_test.go new file mode 100644 index 0000000..56f091c --- /dev/null +++ b/internal/releaseadapter/v071/library_schema_contract_test.go @@ -0,0 +1,32 @@ +package v071 + +import ( + "knowledge-governance/internal/libraryrelease" + "testing" +) + +func TestContractUnknownSchemaEffectsRefusedIsolated(t *testing.T) { + for _, kind := range []string{"trigger", "incoming-cascade"} { + t.Run(kind, func(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + sql := `CREATE FUNCTION unexpected_hook() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$; CREATE TRIGGER unexpected_write BEFORE INSERT ON chunks FOR EACH ROW EXECUTE FUNCTION unexpected_hook()` + if kind == "incoming-cascade" { + sql = `CREATE TABLE unrelated_audit(id text, knowledge_id text REFERENCES knowledges(id) ON DELETE CASCADE); INSERT INTO unrelated_audit VALUES('protected','doc-target')` + } + if _, err := fx.pool.Exec(fx.ctx, sql); err != nil { + t.Fatal(err) + } + before := universeDump(t, fx.pool) + snapshot := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + result := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if result.State != "failed" || result.FailedAt != "" { + t.Fatalf("unreviewed schema must refuse before writes: %+v", result) + } + if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { + t.Fatalf("schema refusal changed rows: %s", diff) + } + }) + } +} diff --git a/internal/releaseadapter/v071/library_schema_sequence_test.go b/internal/releaseadapter/v071/library_schema_sequence_test.go new file mode 100644 index 0000000..18f095e --- /dev/null +++ b/internal/releaseadapter/v071/library_schema_sequence_test.go @@ -0,0 +1,28 @@ +package v071 + +import ( + "knowledge-governance/internal/libraryrelease" + "testing" +) + +// Real v0.7.1 chunks/tag sequences are referenced by defaults but not OWNED BY. +// pg_get_serial_sequence alone silently loses their policy from the schema seal. +func TestContractUnownedSequencePolicyIsFrozenIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + if _, err := fx.pool.Exec(fx.ctx, `CREATE SEQUENCE chunks_seq_id_seq; ALTER TABLE chunks ADD COLUMN seq_id bigint NOT NULL DEFAULT nextval('chunks_seq_id_seq')`); err != nil { + t.Fatal(err) + } + snapshot := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) { parts["chunks"][0]["seq_id"] = 1 }) + target := fx.target(t) + outcome := libraryrelease.Run(fx.ctx, requestFor(snapshot), target, fx.backups(t, target), nil) + if outcome.State != "succeeded" { + t.Fatalf("valid unowned sequence could not publish: %+v", outcome) + } + if _, err := fx.pool.Exec(fx.ctx, `ALTER SEQUENCE chunks_seq_id_seq INCREMENT BY 2`); err != nil { + t.Fatal(err) + } + if err := target.verifyPlanSchema(fx.ctx); err == nil { + t.Fatal("unowned local sequence policy drift escaped frozen schema") + } +} diff --git a/internal/releaseadapter/v071/library_writeset_integration_test.go b/internal/releaseadapter/v071/library_writeset_integration_test.go index 15ef1e2..5ec4849 100644 --- a/internal/releaseadapter/v071/library_writeset_integration_test.go +++ b/internal/releaseadapter/v071/library_writeset_integration_test.go @@ -12,6 +12,7 @@ import ( "net/http" "os" "sort" + "strconv" "strings" "sync/atomic" "testing" @@ -33,14 +34,15 @@ import ( // bucket 上才能证明"恢复后仍是同一份内容"。桩只用于单元级。 type writeSetFixture struct { - ctx context.Context - pool *pgxpool.Pool - client *http.Client - searchBase string - index string - archiveRoot string - objects *flakyStore - bucket string + embeddingDimension int + ctx context.Context + pool *pgxpool.Pool + client *http.Client + searchBase string + index string + archiveRoot string + objects *flakyStore + bucket string } const ( @@ -50,7 +52,6 @@ const ( wsSourceTenant = 10002 wsSourceKB = "kb-source" wsForeignTnt = 20000 - wsBucket = "kg-wire-test-bucket" wsHandleTarget = "aaaaaaaaaaaaaaaaaaaaaa" wsHandleShared = "bbbbbbbbbbbbbbbbbbbbbb" @@ -60,6 +61,14 @@ const ( wsHandleForeign = "ffffffffffffffffffffff" ) +// A per-run bucket isolates object writes even when the S3 service is shared. +var wsBucket = func() string { + if bucket := os.Getenv("KG_LIBRARY_TEST_S3_BUCKET"); strings.HasPrefix(bucket, "kg-library-test-") { + return bucket + } + return "kg-wire-test-bucket" +}() + func wsLocator(backend, provider, bucket string, tenant uint64, id string) string { return fmt.Sprintf("storage://%s/%s://%s/%d/%s/a.png", backend, provider, bucket, tenant, id) } @@ -104,12 +113,16 @@ func openWriteSetFixture(t *testing.T) *writeSetFixture { // writeSetFixtureOptions 让"被杀掉的子进程"复用父进程已经建好的现场: // 不重建 schema、不新建索引,也不换归档根(写集合与预备份都落在那一个根下)。 type writeSetFixtureOptions struct { - reset bool - archiveRoot string - index string + embeddingDimension int + reset bool + archiveRoot string + index string } func openWriteSetFixtureWith(t *testing.T, options writeSetFixtureOptions) *writeSetFixture { + if options.embeddingDimension == 0 { + options.embeddingDimension = 2 + } t.Helper() dsn := os.Getenv("KG_LIBRARY_TEST_DATABASE_URL") base := os.Getenv("KG_LIBRARY_TEST_ELASTIC_URL") @@ -120,6 +133,17 @@ func openWriteSetFixtureWith(t *testing.T, options writeSetFixtureOptions) *writ t.Skip("requires isolated PG, ES and object storage opt-in") } cfg, err := pgxpool.ParseConfig(dsn) + if options.reset { + previousBucket := wsBucket + var namespace [8]byte + if _, err := rand.Read(namespace[:]); err != nil { + t.Fatal(err) + } + wsBucket = "kg-library-test-" + hex.EncodeToString(namespace[:]) + t.Cleanup(func() { wsBucket = previousBucket }) + t.Setenv("KG_LIBRARY_TEST_S3_BUCKET", wsBucket) + t.Logf("isolated object namespace=%s", wsBucket) + } if err != nil || !strings.HasPrefix(cfg.ConnConfig.Database, "kg_library_test_") { t.Fatal("isolated database required") } @@ -166,6 +190,11 @@ func openWriteSetFixtureWith(t *testing.T, options writeSetFixtureOptions) *writ t.Fatal(err) } index := "kg_library_test_" + hex.EncodeToString(token) + if options.index != "" { + index = options.index + } + // Register each disposable namespace before its first ES/object mutation. + r10Save(t, "namespace", map[string]string{"bucket": wsBucket, "index": index}) client := &http.Client{Timeout: 20 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }} @@ -185,11 +214,8 @@ func openWriteSetFixtureWith(t *testing.T, options writeSetFixtureOptions) *writ t.Fatalf("fixture %s %s => %d, want %d", method, path, response.StatusCode, want) } } - if options.index != "" { - index = options.index - } if options.reset { - call("PUT", "/"+index, `{"mappings":{"properties":{"tenant_id":{"type":"long"},"knowledge_base_id":{"type":"keyword"},"knowledge_id":{"type":"keyword"},"chunk_id":{"type":"keyword"},"content":{"type":"text"},"embedding":{"type":"dense_vector","dims":2}}}}`, 200) + call("PUT", "/"+index, `{"mappings":{"properties":{"tenant_id":{"type":"long"},"knowledge_base_id":{"type":"keyword"},"knowledge_id":{"type":"keyword"},"chunk_id":{"type":"keyword"},"content":{"type":"text"},"embedding":{"type":"dense_vector","dims":`+strconv.Itoa(options.embeddingDimension)+`}}}}`, 200) } if options.reset { t.Cleanup(func() { @@ -214,7 +240,10 @@ func openWriteSetFixtureWith(t *testing.T, options writeSetFixtureOptions) *writ if err := store.EnsureBucket(ctx); err != nil { t.Fatalf("ensure bucket: %v", err) } - return &writeSetFixture{ctx: ctx, pool: pool, client: client, searchBase: base, index: index, + if options.reset { + enableIsolatedObjectVersions(t, ctx, store) + } + return &writeSetFixture{embeddingDimension: options.embeddingDimension, ctx: ctx, pool: pool, client: client, searchBase: base, index: index, archiveRoot: root, objects: &flakyStore{s3: store}, bucket: wsBucket} } @@ -271,10 +300,21 @@ func seedTargetData(t *testing.T, fx *writeSetFixture) { fx.indexDoc(t, "chunk-target", wsTargetTenant, wsTargetKB, "doc-target", "图:"+wsHandleTarget) } +func (fx *writeSetFixture) embeddingJSON() []byte { + n := fx.embeddingDimension + if n == 0 { + n = 2 + } + v := make([]float64, n) + v[0] = 0.1 + v[1] = 0.2 + b, _ := json.Marshal(v) + return b +} func (fx *writeSetFixture) indexDoc(t *testing.T, id string, tenant uint64, kb, knowledge, content string) { t.Helper() - body := fmt.Sprintf(`{"tenant_id":%d,"knowledge_base_id":%q,"knowledge_id":%q,"chunk_id":%q,"source_id":%q,"content":%q,"embedding":[0.1,0.2]}`, - tenant, kb, knowledge, id, id, content) + body := fmt.Sprintf(`{"tenant_id":%d,"knowledge_base_id":%q,"knowledge_id":%q,"chunk_id":%q,"source_id":%q,"content":%q,"embedding":%s}`, + tenant, kb, knowledge, id, id, content, fx.embeddingJSON()) request, err := http.NewRequestWithContext(fx.ctx, "PUT", fmt.Sprintf("%s/%s/_doc/%s?refresh=true", fx.searchBase, fx.index, id), strings.NewReader(body)) if err != nil { @@ -380,7 +420,7 @@ func sealSourceSnapshotScope(t *testing.T, fx *writeSetFixture, sourceTenant uin content, _ := chunk["content"].(string) indexRows = append(indexRows, map[string]any{"id": id, "source": map[string]any{ "tenant_id": sourceTenant, "knowledge_base_id": sourceKB, "knowledge_id": knowledge, - "chunk_id": id, "source_id": id, "content": content, "embedding": []float64{0.1, 0.2}}}) + "chunk_id": id, "source_id": id, "content": content, "embedding": json.RawMessage(fx.embeddingJSON())}}) } indexPart, err := archive.Put(bytes.NewReader(encode(indexRows))) if err != nil { @@ -627,12 +667,11 @@ func TestLibraryPreflightRejectsCrossScopeIDConflictIsolated(t *testing.T) { // 场景:wiki 阶段半写失败(resources 已成功上传、database 已提交)→ 回滚必须把 // 本次新增的资源也清掉,目标原有数据逐行不变。 -func TestLibraryWikiStageHalfWriteRollbackIsolated(t *testing.T) { +func TestLibraryDuplicateSlugRejectedBeforeWriteIsolated(t *testing.T) { fx := openWriteSetFixture(t) seedTargetData(t, fx) before := universeDump(t, fx.pool) - // 同一个作用域里两页同 slug:真实 schema 的唯一索引会让 wiki 阶段写失败, - // 而 database/resources 阶段已经成功提交(半写现场)。 + // 重复 slug 保留为写前拒绝负例;晚期故障由独立用例注入。 snapshotID := sealSourceSnapshot(t, fx, func(parts map[string][]map[string]any) { parts["wiki_pages"] = []map[string]any{ {"id": "wiki-src", "tenant_id": wsSourceTenant, "knowledge_base_id": wsSourceKB, "slug": "index", "content": "来源 wiki"}, @@ -642,24 +681,40 @@ func TestLibraryWikiStageHalfWriteRollbackIsolated(t *testing.T) { target := fx.target(t) backups := fx.backups(t, target) outcome := libraryrelease.Run(fx.ctx, requestFor(snapshotID), target, backups, nil) - if outcome.State != "rolled_back" { + if outcome.State != "failed" || !strings.Contains(outcome.Error, "source duplicates natural key") { t.Fatalf("outcome = %+v", outcome) } - if outcome.FailedAt != libraryrelease.StageWiki { + if outcome.FailedAt != "" { t.Fatalf("failed_at = %s, want wiki", outcome.FailedAt) } if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { t.Fatalf("wiki 阶段半写回滚后目标数据被改动:%s", diff) } - // 回滚只回滚行,不删对象:这个定位符必须仍然**读得到**,而且 Stat 要吃真实 - // 定位符(storage:///:///),不是裸 key—— - // 曾经这里写成"读不到也当通过",把 Stat 与 Open/Put 的定位符不一致盖住了。 - if size, _, err := fx.objects.s3.Stat(fx.ctx, "minio", wsLocator("backend-target", "minio", wsBucket, wsTargetTenant, "res-src")); err != nil { - t.Fatalf("回滚后对象字节必须仍在桶里(只回滚行):%v", err) - } else if size <= 0 { - t.Fatalf("回滚后对象字节大小异常:%d", size) + if fx.objects.puts.Load() != 0 { + t.Fatal("duplicate slug reached object write") + } +} + +func TestLibraryWikiStageHalfWriteRollbackIsolated(t *testing.T) { + fx := openWriteSetFixture(t) + seedTargetData(t, fx) + before := universeDump(t, fx.pool) + snapshotID := sealSourceSnapshot(t, fx, nil) + target := fx.target(t) + outcome := libraryrelease.Run(fx.ctx, requestFor(snapshotID), contractFailWikiTarget{target}, fx.backups(t, target), nil) + if outcome.State != "rolled_back" || outcome.FailedAt != libraryrelease.StageWiki { + t.Fatalf("late failure: %+v", outcome) + } + if fx.objects.puts.Load() == 0 { + t.Fatal("late failure never reached real object write") + } + if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" { + t.Fatal(diff) + } + observed, err := fx.objects.ObserveObject(fx.ctx, "minio", wsLocator("backend-target", "minio", wsBucket, wsTargetTenant, "res-src")) + if err != nil || observed.Exists { + t.Fatalf("created object residue: %+v %v", observed, err) } - t.Logf("wiki half-write rolled back: %s", outcome.Rollback) } // 场景:写集合记录被删除/篡改 → 恢复必须失败并保持维护,不能"看不见记录就当没写过"。 diff --git a/internal/releaseadapter/v071/library_writeset_kill_test.go b/internal/releaseadapter/v071/library_writeset_kill_test.go index 64688e1..ca9f620 100644 --- a/internal/releaseadapter/v071/library_writeset_kill_test.go +++ b/internal/releaseadapter/v071/library_writeset_kill_test.go @@ -90,7 +90,22 @@ type killOnPutStore struct { inner *S3ObjectStore } -func (s *killOnPutStore) Put(_ context.Context, _, _ string, _ io.Reader, _ int64) error { +func (s *killOnPutStore) Put(ctx context.Context, provider, path string, body io.Reader, size int64) error { + return s.inner.Put(ctx, provider, path, body, size) +} +func (s *killOnPutStore) ConditionalCapability(ctx context.Context) error { + return s.inner.ConditionalCapability(ctx) +} +func (s *killOnPutStore) ObserveObject(ctx context.Context, provider, path string) (objectObservation, error) { + return s.inner.ObserveObject(ctx, provider, path) +} +func (s *killOnPutStore) RemoveObject(ctx context.Context, provider, path string, expected objectObservation) error { + return s.inner.RemoveObject(ctx, provider, path, expected) +} +func (s *killOnPutStore) CreateObject(ctx context.Context, provider, path string, body io.Reader, size int64, owner string) error { + if err := s.inner.CreateObject(ctx, provider, path, body, size, owner); err != nil { + return err + } if err := syscall.Kill(os.Getpid(), syscall.SIGKILL); err != nil { return err } diff --git a/internal/releaseadapter/v071/object_import_test.go b/internal/releaseadapter/v071/object_import_test.go index 8564dd0..6d6232f 100644 --- a/internal/releaseadapter/v071/object_import_test.go +++ b/internal/releaseadapter/v071/object_import_test.go @@ -1,11 +1,9 @@ package v071 import ( - "bytes" "context" "errors" "io" - "reflect" "testing" ) @@ -30,7 +28,7 @@ func TestProviderPathFromLocatorUnwrapsNestedSchemes(t *testing.T) { } } -func TestObjectImporterStagesThenPromotesWithoutDelete(t *testing.T) { +func TestObjectImporterRetiredWithoutStorageCalls(t *testing.T) { data := []byte("hello") snapshot := ObjectSnapshot{Objects: []AssetObject{{ResourceID: "res-1", Handle: "ABCDEFGHIJKLMNOPQRSTUV", Provider: "minio", PhysicalPath: "storage://source-backend/10000/knowledge/source.txt", Size: 5, SHA256: "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", Data: data}}, TotalBytes: 5} snapshot.SHA256 = objectSnapshotDigest(snapshot.Objects) @@ -39,22 +37,14 @@ func TestObjectImporterStagesThenPromotesWithoutDelete(t *testing.T) { if err != nil { t.Fatal(err) } - stage, err := importer.Stage(context.Background(), "release-v1", snapshot) - if err != nil { - t.Fatal(err) + if _, err := importer.Stage(context.Background(), "release-v1", snapshot); err == nil { + t.Fatal("legacy staging must be disabled") } - if len(stage.Objects) != 1 || stage.Objects[0].FinalPath != "10000/knowledge/source.txt" { - t.Fatalf("stage=%#v", stage) + if err := importer.Promote(context.Background(), ObjectStage{ReleaseRevision: "release-v1", Provider: "oss"}); err == nil { + t.Fatal("legacy promotion must be disabled") } - if err := importer.Promote(context.Background(), stage); err != nil { - t.Fatal(err) - } - wantCalls := []string{"put|oss|.governance-release-stage/release-v1/10000/knowledge/source.txt", "stat|oss|.governance-release-stage/release-v1/10000/knowledge/source.txt", "copy|oss|.governance-release-stage/release-v1/10000/knowledge/source.txt|10000/knowledge/source.txt", "stat|oss|10000/knowledge/source.txt"} - if !reflect.DeepEqual(store.calls, wantCalls) { - t.Fatalf("calls=%v want=%v", store.calls, wantCalls) - } - if !bytes.Equal(store.objects["oss|10000/knowledge/source.txt"], data) { - t.Fatal("final bytes differ") + if len(store.calls) != 0 || len(store.objects) != 0 { + t.Fatal("disabled importer touched storage") } } diff --git a/internal/releaseadapter/v071/oss_version_list_test.go b/internal/releaseadapter/v071/oss_version_list_test.go new file mode 100644 index 0000000..76c6c37 --- /dev/null +++ b/internal/releaseadapter/v071/oss_version_list_test.go @@ -0,0 +1,68 @@ +package v071 + +import ( + "context" + "fmt" + "net/http" + "net/http/httptest" + "net/url" + "strings" + "testing" +) + +func TestContractOSSVersionListQueryIsReadOnly(t *testing.T) { + calls := 0 + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + calls++ + if r.Method != "GET" || r.URL.Query().Get("prefix") != "kg-library-test-r4/key" { + t.Error("unscoped or non-read request") + } + fmt.Fprint(w, `isolated-bucketkg-library-test-r4/keyfalse`) + })) + defer server.Close() + s, err := newOSSVersionStore(S3ObjectStoreConfig{Provider: "oss", Endpoint: "https://oss.example.test", Bucket: "isolated-bucket", AccessKeyID: "fixture-access", SecretAccessKey: "fixture-secret", HTTPClient: &http.Client{Transport: ossRouteTransport{strings.TrimPrefix(server.URL, "http://"), http.DefaultTransport}}}) + if err != nil { + t.Fatal(err) + } + resp, err := s.request(context.Background(), "GET", "", url.Values{"versions": {""}, "prefix": {"kg-library-test-r4/key"}, "max-keys": {"100"}}, nil, nil) + if err != nil { + t.Fatal(err) + } + resp.Body.Close() + if calls != 1 { + t.Fatal("listing not issued") + } +} + +func TestContractOSSExactVersionListingRejectsIncomplete(t *testing.T) { + for _, body := range []string{ + `isolated-bucketkey`, + `wrong-bucketkeyfalse`, + `isolated-bucketkeytrue`, + `isolated-bucketkeyfalseotherv1`, + } { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, body) })) + s, err := newOSSVersionStore(S3ObjectStoreConfig{Provider: "oss", Endpoint: "https://oss.example.test", Bucket: "isolated-bucket", AccessKeyID: "fixture-access", SecretAccessKey: "fixture-secret", HTTPClient: &http.Client{Transport: ossRouteTransport{strings.TrimPrefix(server.URL, "http://"), http.DefaultTransport}}}) + if err != nil { + t.Fatal(err) + } + if _, err = s.listExactVersions(context.Background(), "key"); err == nil { + t.Error("incomplete listing accepted") + } + server.Close() + } +} + +func TestContractOSSVersionAppendDoesNotAdvertiseConditionalCreate(t *testing.T) { + s, err := newOSSVersionStore(S3ObjectStoreConfig{Provider: "oss", Endpoint: "https://oss.example.test", Bucket: "isolated-bucket", AccessKeyID: "fixture-access", SecretAccessKey: "fixture-secret"}) + if err != nil { + t.Fatal(err) + } + if _, ok := any(s).(conditionalObjectStore); ok { + t.Fatal("append-only version API claims conditional create") + } + old := &S3ObjectStore{provider: "oss"} + if old.ConditionalCapability(context.Background()) == nil { + t.Fatal("OSS conditional write gate weakened") + } +} diff --git a/internal/releaseadapter/v071/oss_version_store_integration_test.go b/internal/releaseadapter/v071/oss_version_store_integration_test.go new file mode 100644 index 0000000..551b13c --- /dev/null +++ b/internal/releaseadapter/v071/oss_version_store_integration_test.go @@ -0,0 +1,185 @@ +package v071 + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + "time" +) + +type ossLiveVersionPlan struct { + Owner string `json:"owner"` + Body string `json:"body"` +} +type ossLivePlan struct { + Bucket string `json:"bucket"` + Endpoint string `json:"endpoint"` + Key string `json:"key"` + Versions []ossLiveVersionPlan `json:"versions"` +} + +// A persisted exact-key plan is mandatory. Repeating a failed invocation cannot +// create a new key or silently repeat an ambiguous PUT. Recovery only reconciles +// and cleans versions justified by the existing intent, never appends versions. +func TestContractOSSExactVersionsRealOptIn(t *testing.T) { + if os.Getenv("KG_OSS_VERSION_TEST_ALLOW") != "1" { + t.Skip("real OSS writes require explicitly approved isolated prefix") + } + root := os.Getenv("KG_OSS_VERSION_TEST_EVIDENCE") + prefix := os.Getenv("KG_OSS_VERSION_TEST_PREFIX") + info, err := os.Lstat(root) + if prefix != "kg-library-test-r4/" || !filepath.IsAbs(root) || err != nil || !info.IsDir() || info.Mode().Perm()&0077 != 0 { + t.Fatal("approved prefix and private persistent directory required") + } + var plan ossLivePlan + raw, err := os.ReadFile(filepath.Join(root, "run-plan.json")) + if err != nil || json.Unmarshal(raw, &plan) != nil { + t.Fatal("persisted exact-key plan required") + } + suffix := strings.TrimPrefix(plan.Key, prefix) + nonce, err := hex.DecodeString(suffix) + if err != nil || len(nonce) != 16 || prefix+suffix != plan.Key || plan.Bucket != "dobot-weknora-test" || plan.Endpoint != "https://oss-cn-shenzhen.aliyuncs.com" || len(plan.Versions) != 2 { + t.Fatal("plan outside exact authorization") + } + for _, v := range plan.Versions { + owner, e := hex.DecodeString(v.Owner) + if e != nil || len(owner) != 32 || v.Body == "" { + t.Fatal("invalid test version plan") + } + } + if plan.Versions[0].Owner == plan.Versions[1].Owner || plan.Versions[0].Body == plan.Versions[1].Body { + t.Fatal("test versions must differ") + } + s, err := newOSSVersionStore(S3ObjectStoreConfig{Provider: "oss", Endpoint: plan.Endpoint, Bucket: plan.Bucket, AccessKeyID: os.Getenv("KG_OSS_VERSION_TEST_ACCESS_KEY"), SecretAccessKey: os.Getenv("KG_OSS_VERSION_TEST_SECRET_KEY")}) + if err != nil { + t.Fatal(err) + } + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) + defer cancel() + save := func(name string, value any) { + t.Helper() + raw, e := json.MarshalIndent(value, "", " ") + if e != nil { + t.Fatal(e) + } + if e = persistImmutableJSON(filepath.Join(root, name+".json"), raw); e != nil { + t.Fatal(e) + } + } + cleanup := func() { + t.Helper() + listed, e := s.listExactVersions(ctx, plan.Key) + if e != nil { + t.Fatal("reconciliation listing", e) + } + save("cleanup-lists/"+time.Now().UTC().Format("20060102T150405.000000000"), listed) + if len(listed.DeleteMarkers) != 0 { + t.Fatal("unexpected delete markers; no blind cleanup") + } + for _, v := range listed.Versions { + observed, e := s.observeVersion(ctx, plan.Key, v.VersionID) + if e != nil { + t.Fatal(e) + } + matched := false + for i, want := range plan.Versions { + sum := sha256.Sum256([]byte(want.Body)) + intent, e := os.ReadFile(filepath.Join(root, string(rune('a'+i))+"-intent.json")) + var recorded ossLiveVersionPlan + if e == nil && json.Unmarshal(intent, &recorded) == nil && recorded == want && observed.Exists && observed.Owner == want.Owner && observed.Bytes == int64(len(want.Body)) && observed.SHA256 == hex.EncodeToString(sum[:]) { + matched = true + } + } + if !matched { + t.Fatal("listed version lacks exact durable intent proof") + } + save("delete-intent-"+hex.EncodeToString([]byte(v.VersionID)), observed) + if e = s.removeVersion(ctx, plan.Key, observed); e != nil { + t.Fatal(e) + } + absent, e := s.observeVersion(ctx, plan.Key, v.VersionID) + if e != nil || absent.Exists { + t.Fatal("deleted version still present", e) + } + save("deleted-"+hex.EncodeToString([]byte(v.VersionID)), map[string]any{"version_id": v.VersionID, "absent": true}) + } + after, e := s.listExactVersions(ctx, plan.Key) + if e != nil { + t.Fatal(e) + } + if len(after.Versions) != 0 || len(after.DeleteMarkers) != 0 { + t.Fatal("exact-key version/delete-marker residue") + } + current, e := s.observeVersion(ctx, plan.Key, "") + if e != nil || current.Exists { + t.Fatal("latest object residue", e) + } + save("cleanup", map[string]any{"key": plan.Key, "listing": after, "latest_absent": true}) + } + if os.Getenv("KG_OSS_VERSION_TEST_RECOVER") == "1" { + cleanup() + return + } + if _, e := os.Stat(filepath.Join(root, "a-intent.json")); !os.IsNotExist(e) { + t.Fatal("prior write attempt exists; reconcile exact key, do not re-run PUT") + } + initial, err := s.listExactVersions(ctx, plan.Key) + if err != nil { + t.Fatal(err) + } + if len(initial.Versions) != 0 || len(initial.DeleteMarkers) != 0 { + t.Fatal("planned random key has pre-existing versions") + } + save("baseline", initial) + observations := []objectObservation{} + for i, want := range plan.Versions { + name := string(rune('a' + i)) + save(name+"-intent", want) + observed, e := s.appendVersion(ctx, plan.Key, []byte(want.Body), want.Owner) + if e != nil { + t.Fatal("append unresolved; use exact-key recovery, no blind PUT retry", e) + } + save(name+"-receipt", observed) + observations = append(observations, observed) + } + if observations[0].VersionID == observations[1].VersionID { + t.Fatal("version identities not distinct") + } + // Re-read BOTH immutable versions after the second PUT, not just latest. + for i, want := range observations { + got, e := s.observeVersion(ctx, plan.Key, want.VersionID) + if e != nil || got != want { + t.Fatal("exact-version readback differs", e) + } + save(string(rune('a'+i))+"-readback", got) + } + listed, err := s.listExactVersions(ctx, plan.Key) + if err != nil || len(listed.Versions) != 2 || len(listed.DeleteMarkers) != 0 { + t.Fatal("unexpected pre-cleanup versions", err) + } + save("two-versions", listed) + // Prove deleting the older exact version leaves the newer version unchanged. + save("old-delete-intent", observations[0]) + if err = s.removeVersion(ctx, plan.Key, observations[0]); err != nil { + t.Fatal(err) + } + current, err := s.observeVersion(ctx, plan.Key, "") + if err != nil || current != observations[1] { + t.Fatal("old-version delete changed latest", err) + } + save("newer-preserved", current) + if err = s.removeVersion(ctx, plan.Key, observations[0]); err != nil { + t.Fatal("exact delete replay", err) + } + old, err := s.observeVersion(ctx, plan.Key, observations[0].VersionID) + if err != nil || old.Exists { + t.Fatal("old version residue", err) + } + save("old-deleted", map[string]any{"version_id": observations[0].VersionID, "absent": true}) + cleanup() +} diff --git a/internal/releaseadapter/v071/oss_version_store_test.go b/internal/releaseadapter/v071/oss_version_store_test.go new file mode 100644 index 0000000..6c4da7d --- /dev/null +++ b/internal/releaseadapter/v071/oss_version_store_test.go @@ -0,0 +1,168 @@ +package v071 + +import ( + "context" + "crypto/hmac" + "crypto/sha1" + "encoding/base64" + "fmt" + "io" + "net/http" + "net/http/httptest" + "sort" + "strings" + "testing" +) + +type ossRouteTransport struct { + server string + inner http.RoundTripper +} + +func (t ossRouteTransport) RoundTrip(r *http.Request) (*http.Response, error) { + clone := r.Clone(r.Context()) + u := *r.URL + clone.URL = &u + clone.URL.Scheme = "http" + clone.URL.Host = t.server + clone.Host = r.URL.Host + return t.inner.RoundTrip(clone) +} +func TestContractOSSNativeExactVersionProtocol(t *testing.T) { + // Loopback HTTP protocol fixture, not a real OSS service. + type version struct{ body, owner string } + versions := map[string]version{} + latest := "" + puts := 0 + deletes := 0 + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Host != "isolated-bucket.oss.example.test" { + t.Errorf("not virtual host: %s", r.Host) + } + canonical := "" + keys := []string{} + for k := range r.Header { + if strings.HasPrefix(strings.ToLower(k), "x-oss-") { + keys = append(keys, strings.ToLower(k)) + } + } + sort.Strings(keys) + for _, k := range keys { + canonical += k + ":" + r.Header.Get(k) + "\n" + } + resource := "/isolated-bucket" + r.URL.Path + if r.URL.Query().Has("versioning") { + resource += "?versioning" + } else if v := r.URL.Query().Get("versionId"); v != "" { + resource += "?versionId=" + v + } + mac := hmac.New(sha1.New, []byte("fixture-secret")) + fmt.Fprint(mac, r.Method+"\n\n"+r.Header.Get("Content-Type")+"\n"+r.Header.Get("Date")+"\n"+canonical+resource) + if r.Header.Get("Authorization") != "OSS fixture-access:"+base64.StdEncoding.EncodeToString(mac.Sum(nil)) { + t.Error("invalid native signature") + w.WriteHeader(403) + return + } + if r.URL.Query().Has("versioning") { + if r.Method != "GET" { + t.Fatal("bucket setting write") + } + fmt.Fprint(w, "Enabled") + return + } + v := r.URL.Query().Get("versionId") + if v == "" { + v = latest + } + switch r.Method { + case "PUT": + puts++ + data, _ := io.ReadAll(r.Body) + v = fmt.Sprint(puts) + versions[v] = version{string(data), r.Header.Get("x-oss-meta-kg-release-owner")} + latest = v + w.Header().Set("x-oss-version-id", v) + w.WriteHeader(200) + case "GET": + item, ok := versions[v] + if !ok { + w.WriteHeader(404) + fmt.Fprint(w, "NoSuchVersion") + return + } + w.Header().Set("x-oss-version-id", v) + w.Header().Set("ETag", "etag-"+v) + w.Header().Set("x-oss-meta-kg-release-owner", item.owner) + w.Header().Set("Content-Length", fmt.Sprint(len(item.body))) + fmt.Fprint(w, item.body) + case "DELETE": + if !r.URL.Query().Has("versionId") { + t.Error("blind delete") + w.WriteHeader(400) + return + } + deletes++ + delete(versions, v) + w.WriteHeader(204) + default: + w.WriteHeader(405) + } + })) + defer server.Close() + client := &http.Client{Transport: ossRouteTransport{strings.TrimPrefix(server.URL, "http://"), http.DefaultTransport}} + s, err := newOSSVersionStore(S3ObjectStoreConfig{Provider: "oss", Endpoint: "https://oss.example.test", Bucket: "isolated-bucket", AccessKeyID: "fixture-access", SecretAccessKey: "fixture-secret", HTTPClient: client}) + if err != nil { + t.Fatal(err) + } + ctx := context.Background() + own, err := s.appendVersion(ctx, "kg-test/a b+中文", []byte("original"), strings.Repeat("a", 64)) + if err != nil { + t.Fatal(err) + } + foreign, err := s.appendVersion(ctx, "kg-test/a b+中文", []byte("later foreign bytes"), strings.Repeat("b", 64)) + if err != nil { + t.Fatal(err) + } + wrong := own + wrong.Owner = strings.Repeat("c", 64) + if s.removeVersion(ctx, "kg-test/a b+中文", wrong) == nil || deletes != 0 { + t.Fatal("wrong owner deleted version") + } + if err = s.removeVersion(ctx, "kg-test/a b+中文", own); err != nil { + t.Fatal(err) + } + current, err := s.observeVersion(ctx, "kg-test/a b+中文", "") + if err != nil || current != foreign { + t.Fatal("later version changed", err) + } + if err = s.removeVersion(ctx, "kg-test/a b+中文", own); err != nil || deletes != 1 { + t.Fatal("delete replay not idempotent", err) + } + if puts != 2 { + t.Fatalf("unexpected puts %d", puts) + } +} + +// A proxy/bucket 404 is not proof that an exact object version was deleted. +func TestContractOSSNonObject404IsNotAbsence(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(404) + fmt.Fprint(w, "NoSuchBucket") + })) + defer server.Close() + s, err := newOSSVersionStore(S3ObjectStoreConfig{Provider: "oss", Endpoint: "https://oss.example.test", Bucket: "isolated-bucket", AccessKeyID: "fixture-access", SecretAccessKey: "fixture-secret", HTTPClient: &http.Client{Transport: ossRouteTransport{strings.TrimPrefix(server.URL, "http://"), http.DefaultTransport}}}) + if err != nil { + t.Fatal(err) + } + if _, err = s.observeVersion(context.Background(), "key", "version"); err == nil { + t.Fatal("bucket/proxy 404 incorrectly proves object absence") + } +} + +func TestContractOSSRejectsPathStyleAndMissingCredentials(t *testing.T) { + for _, c := range []S3ObjectStoreConfig{{Provider: "oss", Endpoint: "http://oss.example.test", Bucket: "bucket", AccessKeyID: "test", SecretAccessKey: "test"}, {Provider: "oss", Endpoint: "https://oss.example.test", Bucket: "bucket", AccessKeyID: "test", SecretAccessKey: "test", ForcePathStyle: true}} { + if _, err := newOSSVersionStore(c); err == nil { + t.Fatal("unsafe configuration accepted") + } + } +} diff --git a/internal/releaseadapter/v071/testdata/catalog-v071-r11.json b/internal/releaseadapter/v071/testdata/catalog-v071-r11.json new file mode 100644 index 0000000..0ccfcb2 --- /dev/null +++ b/internal/releaseadapter/v071/testdata/catalog-v071-r11.json @@ -0,0 +1,2004 @@ +{ + "columns": [ + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "id", + "default_expr": "uuid_generate_v4()" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "tenant_id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "knowledge_base_id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "knowledge_id", + "default_expr": "" + }, + { + "type": "text", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "content", + "default_expr": "" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "chunk_index", + "default_expr": "" + }, + { + "type": "boolean", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "is_enabled", + "default_expr": "true" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "start_at", + "default_expr": "" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "end_at", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "pre_chunk_id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "next_chunk_id", + "default_expr": "" + }, + { + "type": "character varying(20)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "chunk_type", + "default_expr": "'text'::character varying" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "parent_chunk_id", + "default_expr": "" + }, + { + "type": "text", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "image_info", + "default_expr": "" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "relation_chunks", + "default_expr": "" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "indirect_relation_chunks", + "default_expr": "" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "created_at", + "default_expr": "CURRENT_TIMESTAMP" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "updated_at", + "default_expr": "CURRENT_TIMESTAMP" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "deleted_at", + "default_expr": "" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "metadata", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "tag_id", + "default_expr": "" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "status", + "default_expr": "0" + }, + { + "type": "character varying(64)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "content_hash", + "default_expr": "" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "flags", + "default_expr": "1" + }, + { + "type": "bigint", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "chunks", + "column_name": "seq_id", + "default_expr": "nextval('chunks_seq_id_seq'::regclass)" + }, + { + "type": "text", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "chunks", + "column_name": "video_info", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledge_tag_relations", + "column_name": "knowledge_id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledge_tag_relations", + "column_name": "tag_id", + "default_expr": "" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledge_tag_relations", + "column_name": "created_at", + "default_expr": "now()" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledge_tags", + "column_name": "id", + "default_expr": "" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledge_tags", + "column_name": "tenant_id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledge_tags", + "column_name": "knowledge_base_id", + "default_expr": "" + }, + { + "type": "character varying(128)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledge_tags", + "column_name": "name", + "default_expr": "" + }, + { + "type": "character varying(32)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledge_tags", + "column_name": "color", + "default_expr": "" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledge_tags", + "column_name": "sort_order", + "default_expr": "0" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledge_tags", + "column_name": "created_at", + "default_expr": "CURRENT_TIMESTAMP" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledge_tags", + "column_name": "updated_at", + "default_expr": "CURRENT_TIMESTAMP" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledge_tags", + "column_name": "deleted_at", + "default_expr": "" + }, + { + "type": "bigint", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledge_tags", + "column_name": "seq_id", + "default_expr": "nextval('knowledge_tags_seq_id_seq'::regclass)" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledges", + "column_name": "id", + "default_expr": "uuid_generate_v4()" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledges", + "column_name": "tenant_id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledges", + "column_name": "knowledge_base_id", + "default_expr": "" + }, + { + "type": "character varying(50)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledges", + "column_name": "type", + "default_expr": "" + }, + { + "type": "character varying(255)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledges", + "column_name": "title", + "default_expr": "" + }, + { + "type": "text", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "description", + "default_expr": "" + }, + { + "type": "character varying(2048)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledges", + "column_name": "source", + "default_expr": "" + }, + { + "type": "character varying(50)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledges", + "column_name": "parse_status", + "default_expr": "'unprocessed'::character varying" + }, + { + "type": "character varying(50)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledges", + "column_name": "enable_status", + "default_expr": "'enabled'::character varying" + }, + { + "type": "character varying(64)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "embedding_model_id", + "default_expr": "" + }, + { + "type": "character varying(255)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "file_name", + "default_expr": "" + }, + { + "type": "character varying(50)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "file_type", + "default_expr": "" + }, + { + "type": "bigint", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "file_size", + "default_expr": "" + }, + { + "type": "text", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "file_path", + "default_expr": "" + }, + { + "type": "character varying(64)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "file_hash", + "default_expr": "" + }, + { + "type": "bigint", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledges", + "column_name": "storage_size", + "default_expr": "0" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "metadata", + "default_expr": "" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "created_at", + "default_expr": "CURRENT_TIMESTAMP" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "updated_at", + "default_expr": "CURRENT_TIMESTAMP" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "processed_at", + "default_expr": "" + }, + { + "type": "text", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "error_message", + "default_expr": "" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "deleted_at", + "default_expr": "" + }, + { + "type": "character varying(32)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "summary_status", + "default_expr": "'none'::character varying" + }, + { + "type": "json", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "knowledges", + "column_name": "last_faq_import_result", + "default_expr": "" + }, + { + "type": "character varying(50)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledges", + "column_name": "channel", + "default_expr": "'web'::character varying" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "knowledges", + "column_name": "pending_subtasks_count", + "default_expr": "0" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resource_bindings", + "column_name": "id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resource_bindings", + "column_name": "resource_id", + "default_expr": "" + }, + { + "type": "bigint", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resource_bindings", + "column_name": "tenant_id", + "default_expr": "" + }, + { + "type": "character varying(32)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resource_bindings", + "column_name": "owner_type", + "default_expr": "" + }, + { + "type": "character varying(64)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resource_bindings", + "column_name": "owner_id", + "default_expr": "" + }, + { + "type": "character varying(32)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resource_bindings", + "column_name": "relation", + "default_expr": "'attachment'::character varying" + }, + { + "type": "timestamp without time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "resource_bindings", + "column_name": "created_at", + "default_expr": "CURRENT_TIMESTAMP" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "id", + "default_expr": "" + }, + { + "type": "character varying(22)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "handle", + "default_expr": "" + }, + { + "type": "bigint", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "tenant_id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "resources", + "column_name": "storage_backend_id", + "default_expr": "" + }, + { + "type": "character varying(32)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "provider", + "default_expr": "" + }, + { + "type": "text", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "physical_path", + "default_expr": "" + }, + { + "type": "character varying(64)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "location_hash", + "default_expr": "" + }, + { + "type": "character varying(32)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "kind", + "default_expr": "'file'::character varying" + }, + { + "type": "character varying(255)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "mime_type", + "default_expr": "''::character varying" + }, + { + "type": "character varying(1024)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "original_name", + "default_expr": "''::character varying" + }, + { + "type": "bigint", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "size", + "default_expr": "0" + }, + { + "type": "character varying(64)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "content_hash", + "default_expr": "''::character varying" + }, + { + "type": "character varying(16)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "lifecycle", + "default_expr": "'persistent'::character varying" + }, + { + "type": "timestamp without time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "resources", + "column_name": "expires_at", + "default_expr": "" + }, + { + "type": "character varying(16)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "resources", + "column_name": "state", + "default_expr": "'active'::character varying" + }, + { + "type": "timestamp without time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "resources", + "column_name": "created_at", + "default_expr": "CURRENT_TIMESTAMP" + }, + { + "type": "timestamp without time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "resources", + "column_name": "updated_at", + "default_expr": "CURRENT_TIMESTAMP" + }, + { + "type": "timestamp without time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "resources", + "column_name": "deleted_at", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_folders", + "column_name": "id", + "default_expr": "" + }, + { + "type": "bigint", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_folders", + "column_name": "tenant_id", + "default_expr": "0" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_folders", + "column_name": "knowledge_base_id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_folders", + "column_name": "parent_id", + "default_expr": "''::character varying" + }, + { + "type": "character varying(255)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_folders", + "column_name": "name", + "default_expr": "" + }, + { + "type": "character varying(1024)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_folders", + "column_name": "path", + "default_expr": "''::character varying" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_folders", + "column_name": "depth", + "default_expr": "0" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_folders", + "column_name": "sort_order", + "default_expr": "0" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_folders", + "column_name": "created_at", + "default_expr": "now()" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_folders", + "column_name": "updated_at", + "default_expr": "now()" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_folders", + "column_name": "deleted_at", + "default_expr": "" + }, + { + "type": "bigint", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_log_entries", + "column_name": "id", + "default_expr": "nextval('wiki_log_entries_id_seq'::regclass)" + }, + { + "type": "bigint", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_log_entries", + "column_name": "tenant_id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_log_entries", + "column_name": "knowledge_base_id", + "default_expr": "" + }, + { + "type": "character varying(32)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_log_entries", + "column_name": "action", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_log_entries", + "column_name": "knowledge_id", + "default_expr": "''::character varying" + }, + { + "type": "text", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_log_entries", + "column_name": "doc_title", + "default_expr": "''::text" + }, + { + "type": "text", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_log_entries", + "column_name": "summary", + "default_expr": "''::text" + }, + { + "type": "jsonb", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_log_entries", + "column_name": "pages_affected", + "default_expr": "'[]'::jsonb" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_log_entries", + "column_name": "created_at", + "default_expr": "now()" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "id", + "default_expr": "" + }, + { + "type": "bigint", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "tenant_id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "knowledge_base_id", + "default_expr": "" + }, + { + "type": "character varying(255)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "slug", + "default_expr": "" + }, + { + "type": "character varying(50)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "issue_type", + "default_expr": "" + }, + { + "type": "text", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "description", + "default_expr": "" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "suspected_knowledge_ids", + "default_expr": "" + }, + { + "type": "character varying(20)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "status", + "default_expr": "'pending'::character varying" + }, + { + "type": "character varying(100)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "reported_by", + "default_expr": "" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "created_at", + "default_expr": "CURRENT_TIMESTAMP" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "updated_at", + "default_expr": "CURRENT_TIMESTAMP" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_page_issues", + "column_name": "deleted_at", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "id", + "default_expr": "" + }, + { + "type": "bigint", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "tenant_id", + "default_expr": "" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "knowledge_base_id", + "default_expr": "" + }, + { + "type": "character varying(255)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "slug", + "default_expr": "" + }, + { + "type": "character varying(512)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "title", + "default_expr": "''::character varying" + }, + { + "type": "character varying(32)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "page_type", + "default_expr": "'summary'::character varying" + }, + { + "type": "character varying(32)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "status", + "default_expr": "'published'::character varying" + }, + { + "type": "text", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "content", + "default_expr": "''::text" + }, + { + "type": "text", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "summary", + "default_expr": "''::text" + }, + { + "type": "character varying(255)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "parent_slug", + "default_expr": "''::character varying" + }, + { + "type": "character varying(36)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "folder_id", + "default_expr": "''::character varying" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_pages", + "column_name": "category_path", + "default_expr": "'[]'::jsonb" + }, + { + "type": "character varying(1024)", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "wiki_path", + "default_expr": "''::character varying" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "depth", + "default_expr": "0" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "sort_order", + "default_expr": "0" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_pages", + "column_name": "source_refs", + "default_expr": "'[]'::jsonb" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_pages", + "column_name": "chunk_refs", + "default_expr": "'[]'::jsonb" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_pages", + "column_name": "in_links", + "default_expr": "'[]'::jsonb" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_pages", + "column_name": "out_links", + "default_expr": "'[]'::jsonb" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_pages", + "column_name": "page_metadata", + "default_expr": "'{}'::jsonb" + }, + { + "type": "jsonb", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_pages", + "column_name": "aliases", + "default_expr": "'[]'::jsonb" + }, + { + "type": "integer", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "version", + "default_expr": "1" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "created_at", + "default_expr": "now()" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": true, + "generated": "", + "table_name": "wiki_pages", + "column_name": "updated_at", + "default_expr": "now()" + }, + { + "type": "timestamp with time zone", + "identity": "", + "not_null": false, + "generated": "", + "table_name": "wiki_pages", + "column_name": "deleted_at", + "default_expr": "" + } + ], + "indexes": [ + { + "name": "chunks_pkey", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX chunks_pkey ON public.chunks USING btree (id)", + "table_name": "chunks", + "unique_index": true + }, + { + "name": "idx_chunks_chunk_type", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_chunks_chunk_type ON public.chunks USING btree (chunk_type)", + "table_name": "chunks", + "unique_index": false + }, + { + "name": "idx_chunks_content_hash", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_chunks_content_hash ON public.chunks USING btree (content_hash)", + "table_name": "chunks", + "unique_index": false + }, + { + "name": "idx_chunks_kb_tenant", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_chunks_kb_tenant ON public.chunks USING btree (knowledge_base_id, tenant_id)", + "table_name": "chunks", + "unique_index": false + }, + { + "name": "idx_chunks_knowledge_enabled", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_chunks_knowledge_enabled ON public.chunks USING btree (knowledge_id, is_enabled, deleted_at)", + "table_name": "chunks", + "unique_index": false + }, + { + "name": "idx_chunks_parent_id", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_chunks_parent_id ON public.chunks USING btree (parent_chunk_id)", + "table_name": "chunks", + "unique_index": false + }, + { + "name": "idx_chunks_seq_id", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX idx_chunks_seq_id ON public.chunks USING btree (seq_id)", + "table_name": "chunks", + "unique_index": true + }, + { + "name": "idx_chunks_tag", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_chunks_tag ON public.chunks USING btree (tag_id)", + "table_name": "chunks", + "unique_index": false + }, + { + "name": "idx_chunks_tenant_kg", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_chunks_tenant_kg ON public.chunks USING btree (tenant_id, knowledge_id)", + "table_name": "chunks", + "unique_index": false + }, + { + "name": "idx_ktr_knowledge", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_ktr_knowledge ON public.knowledge_tag_relations USING btree (knowledge_id)", + "table_name": "knowledge_tag_relations", + "unique_index": false + }, + { + "name": "idx_ktr_tag", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_ktr_tag ON public.knowledge_tag_relations USING btree (tag_id)", + "table_name": "knowledge_tag_relations", + "unique_index": false + }, + { + "name": "knowledge_tag_relations_pkey", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX knowledge_tag_relations_pkey ON public.knowledge_tag_relations USING btree (knowledge_id, tag_id)", + "table_name": "knowledge_tag_relations", + "unique_index": true + }, + { + "name": "idx_knowledge_tags_kb", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_knowledge_tags_kb ON public.knowledge_tags USING btree (tenant_id, knowledge_base_id)", + "table_name": "knowledge_tags", + "unique_index": false + }, + { + "name": "idx_knowledge_tags_kb_name", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX idx_knowledge_tags_kb_name ON public.knowledge_tags USING btree (tenant_id, knowledge_base_id, name)", + "table_name": "knowledge_tags", + "unique_index": true + }, + { + "name": "idx_knowledge_tags_seq_id", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX idx_knowledge_tags_seq_id ON public.knowledge_tags USING btree (seq_id)", + "table_name": "knowledge_tags", + "unique_index": true + }, + { + "name": "knowledge_tags_pkey", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX knowledge_tags_pkey ON public.knowledge_tags USING btree (id)", + "table_name": "knowledge_tags", + "unique_index": true + }, + { + "name": "idx_knowledges_base_id", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_knowledges_base_id ON public.knowledges USING btree (knowledge_base_id)", + "table_name": "knowledges", + "unique_index": false + }, + { + "name": "idx_knowledges_enable_status", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_knowledges_enable_status ON public.knowledges USING btree (enable_status)", + "table_name": "knowledges", + "unique_index": false + }, + { + "name": "idx_knowledges_parse_status", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_knowledges_parse_status ON public.knowledges USING btree (parse_status)", + "table_name": "knowledges", + "unique_index": false + }, + { + "name": "idx_knowledges_summary_status", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_knowledges_summary_status ON public.knowledges USING btree (summary_status)", + "table_name": "knowledges", + "unique_index": false + }, + { + "name": "idx_knowledges_tenant_id", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_knowledges_tenant_id ON public.knowledges USING btree (tenant_id)", + "table_name": "knowledges", + "unique_index": false + }, + { + "name": "knowledges_pkey", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX knowledges_pkey ON public.knowledges USING btree (id)", + "table_name": "knowledges", + "unique_index": true + }, + { + "name": "idx_resource_bindings_owner", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_resource_bindings_owner ON public.resource_bindings USING btree (tenant_id, owner_type, owner_id)", + "table_name": "resource_bindings", + "unique_index": false + }, + { + "name": "idx_resource_bindings_unique", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX idx_resource_bindings_unique ON public.resource_bindings USING btree (resource_id, owner_type, owner_id, relation)", + "table_name": "resource_bindings", + "unique_index": true + }, + { + "name": "resource_bindings_pkey", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX resource_bindings_pkey ON public.resource_bindings USING btree (id)", + "table_name": "resource_bindings", + "unique_index": true + }, + { + "name": "idx_resources_backend", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_resources_backend ON public.resources USING btree (storage_backend_id)", + "table_name": "resources", + "unique_index": false + }, + { + "name": "idx_resources_tenant", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_resources_tenant ON public.resources USING btree (tenant_id)", + "table_name": "resources", + "unique_index": false + }, + { + "name": "idx_resources_tenant_location", + "valid": true, + "predicate": "(deleted_at IS NULL)", + "definition": "CREATE UNIQUE INDEX idx_resources_tenant_location ON public.resources USING btree (tenant_id, location_hash) WHERE (deleted_at IS NULL)", + "table_name": "resources", + "unique_index": true + }, + { + "name": "resources_handle_key", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX resources_handle_key ON public.resources USING btree (handle)", + "table_name": "resources", + "unique_index": true + }, + { + "name": "resources_pkey", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX resources_pkey ON public.resources USING btree (id)", + "table_name": "resources", + "unique_index": true + }, + { + "name": "idx_wiki_folders_deleted_at", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_folders_deleted_at ON public.wiki_folders USING btree (deleted_at)", + "table_name": "wiki_folders", + "unique_index": false + }, + { + "name": "idx_wiki_folders_parent", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_folders_parent ON public.wiki_folders USING btree (knowledge_base_id, parent_id)", + "table_name": "wiki_folders", + "unique_index": false + }, + { + "name": "idx_wiki_folders_parent_name", + "valid": true, + "predicate": "(deleted_at IS NULL)", + "definition": "CREATE UNIQUE INDEX idx_wiki_folders_parent_name ON public.wiki_folders USING btree (knowledge_base_id, parent_id, name) WHERE (deleted_at IS NULL)", + "table_name": "wiki_folders", + "unique_index": true + }, + { + "name": "wiki_folders_pkey", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX wiki_folders_pkey ON public.wiki_folders USING btree (id)", + "table_name": "wiki_folders", + "unique_index": true + }, + { + "name": "idx_wiki_log_entries_kb_id_desc", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_log_entries_kb_id_desc ON public.wiki_log_entries USING btree (knowledge_base_id, id DESC)", + "table_name": "wiki_log_entries", + "unique_index": false + }, + { + "name": "idx_wiki_log_entries_tenant_id", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_log_entries_tenant_id ON public.wiki_log_entries USING btree (tenant_id)", + "table_name": "wiki_log_entries", + "unique_index": false + }, + { + "name": "wiki_log_entries_pkey", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX wiki_log_entries_pkey ON public.wiki_log_entries USING btree (id)", + "table_name": "wiki_log_entries", + "unique_index": true + }, + { + "name": "idx_wiki_page_issues_knowledge_base_id", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_page_issues_knowledge_base_id ON public.wiki_page_issues USING btree (knowledge_base_id)", + "table_name": "wiki_page_issues", + "unique_index": false + }, + { + "name": "idx_wiki_page_issues_slug", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_page_issues_slug ON public.wiki_page_issues USING btree (slug)", + "table_name": "wiki_page_issues", + "unique_index": false + }, + { + "name": "idx_wiki_page_issues_status", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_page_issues_status ON public.wiki_page_issues USING btree (status)", + "table_name": "wiki_page_issues", + "unique_index": false + }, + { + "name": "idx_wiki_page_issues_tenant_id", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_page_issues_tenant_id ON public.wiki_page_issues USING btree (tenant_id)", + "table_name": "wiki_page_issues", + "unique_index": false + }, + { + "name": "wiki_page_issues_pkey", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX wiki_page_issues_pkey ON public.wiki_page_issues USING btree (id)", + "table_name": "wiki_page_issues", + "unique_index": true + }, + { + "name": "idx_wiki_pages_deleted_at", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_deleted_at ON public.wiki_pages USING btree (deleted_at)", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "idx_wiki_pages_folder", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_folder ON public.wiki_pages USING btree (knowledge_base_id, folder_id)", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "idx_wiki_pages_folder_id", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_folder_id ON public.wiki_pages USING btree (folder_id)", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "idx_wiki_pages_fulltext", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_fulltext ON public.wiki_pages USING gin (to_tsvector('simple'::regconfig, (((COALESCE(title, ''::character varying))::text || ' '::text) || COALESCE(content, ''::text))))", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "idx_wiki_pages_kb_id", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_kb_id ON public.wiki_pages USING btree (knowledge_base_id)", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "idx_wiki_pages_kb_slug", + "valid": true, + "predicate": "(deleted_at IS NULL)", + "definition": "CREATE UNIQUE INDEX idx_wiki_pages_kb_slug ON public.wiki_pages USING btree (knowledge_base_id, slug) WHERE (deleted_at IS NULL)", + "table_name": "wiki_pages", + "unique_index": true + }, + { + "name": "idx_wiki_pages_page_type", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_page_type ON public.wiki_pages USING btree (knowledge_base_id, page_type)", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "idx_wiki_pages_parent_slug", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_parent_slug ON public.wiki_pages USING btree (knowledge_base_id, parent_slug)", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "idx_wiki_pages_source_refs", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_source_refs ON public.wiki_pages USING gin (source_refs jsonb_path_ops)", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "idx_wiki_pages_source_refs_text", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_source_refs_text ON public.wiki_pages USING gin (to_tsvector('simple'::regconfig, (source_refs)::text))", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "idx_wiki_pages_tenant_id", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_tenant_id ON public.wiki_pages USING btree (tenant_id)", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "idx_wiki_pages_title_trgm", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_title_trgm ON public.wiki_pages USING gin (lower((title)::text) gin_trgm_ops)", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "idx_wiki_pages_tree", + "valid": true, + "predicate": "", + "definition": "CREATE INDEX idx_wiki_pages_tree ON public.wiki_pages USING btree (knowledge_base_id, page_type, wiki_path, sort_order, title)", + "table_name": "wiki_pages", + "unique_index": false + }, + { + "name": "wiki_pages_pkey", + "valid": true, + "predicate": "", + "definition": "CREATE UNIQUE INDEX wiki_pages_pkey ON public.wiki_pages USING btree (id)", + "table_name": "wiki_pages", + "unique_index": true + } + ], + "triggers": [], + "relations": [ + { + "kind": "r", + "inherits": false, + "partition": false, + "table_name": "chunks", + "row_security": false + }, + { + "kind": "r", + "inherits": false, + "partition": false, + "table_name": "knowledge_tag_relations", + "row_security": false + }, + { + "kind": "r", + "inherits": false, + "partition": false, + "table_name": "knowledge_tags", + "row_security": false + }, + { + "kind": "r", + "inherits": false, + "partition": false, + "table_name": "knowledges", + "row_security": false + }, + { + "kind": "r", + "inherits": false, + "partition": false, + "table_name": "resource_bindings", + "row_security": false + }, + { + "kind": "r", + "inherits": false, + "partition": false, + "table_name": "resources", + "row_security": false + }, + { + "kind": "r", + "inherits": false, + "partition": false, + "table_name": "wiki_folders", + "row_security": false + }, + { + "kind": "r", + "inherits": false, + "partition": false, + "table_name": "wiki_log_entries", + "row_security": false + }, + { + "kind": "r", + "inherits": false, + "partition": false, + "table_name": "wiki_page_issues", + "row_security": false + }, + { + "kind": "r", + "inherits": false, + "partition": false, + "table_name": "wiki_pages", + "row_security": false + } + ], + "sequences": [ + { + "seqmax": 9223372036854775807, + "seqmin": 1, + "seqcache": 1, + "seqcycle": false, + "seqstart": 100000000, + "sequence": "chunks_seq_id_seq", + "table_name": "chunks", + "column_name": "seq_id", + "seqincrement": 1 + }, + { + "seqmax": 9223372036854775807, + "seqmin": 1, + "seqcache": 1, + "seqcycle": false, + "seqstart": 10000000, + "sequence": "knowledge_tags_seq_id_seq", + "table_name": "knowledge_tags", + "column_name": "seq_id", + "seqincrement": 1 + }, + { + "seqmax": 9223372036854775807, + "seqmin": 1, + "seqcache": 1, + "seqcycle": false, + "seqstart": 1, + "sequence": "wiki_log_entries_id_seq", + "table_name": "wiki_log_entries", + "column_name": "id", + "seqincrement": 1 + } + ], + "constraints": [ + { + "name": "chunks_pkey", + "type": "p", + "namespace": "public", + "definition": "PRIMARY KEY (id)", + "table_name": "chunks", + "referenced_table": "", + "referenced_namespace": "" + }, + { + "name": "knowledge_tag_relations_pkey", + "type": "p", + "namespace": "public", + "definition": "PRIMARY KEY (knowledge_id, tag_id)", + "table_name": "knowledge_tag_relations", + "referenced_table": "", + "referenced_namespace": "" + }, + { + "name": "knowledge_tags_pkey", + "type": "p", + "namespace": "public", + "definition": "PRIMARY KEY (id)", + "table_name": "knowledge_tags", + "referenced_table": "", + "referenced_namespace": "" + }, + { + "name": "knowledges_pkey", + "type": "p", + "namespace": "public", + "definition": "PRIMARY KEY (id)", + "table_name": "knowledges", + "referenced_table": "", + "referenced_namespace": "" + }, + { + "name": "resource_access_grants_resource_id_fkey", + "type": "f", + "namespace": "public", + "definition": "FOREIGN KEY (resource_id) REFERENCES resources(id) ON DELETE CASCADE", + "table_name": "resource_access_grants", + "referenced_table": "resources", + "referenced_namespace": "public" + }, + { + "name": "resource_bindings_pkey", + "type": "p", + "namespace": "public", + "definition": "PRIMARY KEY (id)", + "table_name": "resource_bindings", + "referenced_table": "", + "referenced_namespace": "" + }, + { + "name": "resource_bindings_resource_id_fkey", + "type": "f", + "namespace": "public", + "definition": "FOREIGN KEY (resource_id) REFERENCES resources(id) ON DELETE CASCADE", + "table_name": "resource_bindings", + "referenced_table": "resources", + "referenced_namespace": "public" + }, + { + "name": "resources_handle_key", + "type": "u", + "namespace": "public", + "definition": "UNIQUE (handle)", + "table_name": "resources", + "referenced_table": "", + "referenced_namespace": "" + }, + { + "name": "resources_pkey", + "type": "p", + "namespace": "public", + "definition": "PRIMARY KEY (id)", + "table_name": "resources", + "referenced_table": "", + "referenced_namespace": "" + }, + { + "name": "wiki_folders_pkey", + "type": "p", + "namespace": "public", + "definition": "PRIMARY KEY (id)", + "table_name": "wiki_folders", + "referenced_table": "", + "referenced_namespace": "" + }, + { + "name": "wiki_log_entries_pkey", + "type": "p", + "namespace": "public", + "definition": "PRIMARY KEY (id)", + "table_name": "wiki_log_entries", + "referenced_table": "", + "referenced_namespace": "" + }, + { + "name": "wiki_page_issues_pkey", + "type": "p", + "namespace": "public", + "definition": "PRIMARY KEY (id)", + "table_name": "wiki_page_issues", + "referenced_table": "", + "referenced_namespace": "" + }, + { + "name": "wiki_pages_pkey", + "type": "p", + "namespace": "public", + "definition": "PRIMARY KEY (id)", + "table_name": "wiki_pages", + "referenced_table": "", + "referenced_namespace": "" + } + ] +} \ No newline at end of file diff --git a/internal/releaseadapter/v071/three_lane_integration_test.go b/internal/releaseadapter/v071/three_lane_integration_test.go index f17f608..29857bd 100644 --- a/internal/releaseadapter/v071/three_lane_integration_test.go +++ b/internal/releaseadapter/v071/three_lane_integration_test.go @@ -6,7 +6,7 @@ import ( "encoding/json" "net/http/httptest" "os" - "path/filepath" + "strings" "testing" "time" @@ -17,7 +17,7 @@ import ( releaseworkflow "knowledge-governance/internal/workflows/release" ) -func TestThreeLaneReleaseAndRollbackV071Integration(t *testing.T) { +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") @@ -110,49 +110,29 @@ func TestThreeLaneReleaseAndRollbackV071Integration(t *testing.T) { 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) + // 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) } - if firstResult.PreviousProductionRevision != "absent" || firstResult.ProductionRevision != "review-release-1" { - t.Fatalf("first=%#v", firstResult) + identity := PostgresIdentity{TenantID: 10000, KnowledgeBaseID: "kb-release-safe", KnowledgeID: "knowledge-release-safe"} + before, e := targetSnapshot.Export(ctx, identity) + if e != nil { + t.Fatal(e) } - 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 _, 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) } - if secondResult.PreviousProductionRevision != "review-release-1" || secondResult.ProductionRevision != "review-release-2" { - t.Fatalf("second=%#v", secondResult) + after, e := targetSnapshot.Export(ctx, identity) + if e != nil { + t.Fatal(e) } - rollback, err := publisher.Rollback(ctx, second) - if err != nil { - t.Fatal(err) - } - if rollback.ProductionRevision != "review-release-1" { - t.Fatalf("rollback=%#v", rollback) + 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") } - 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) - } - } } diff --git a/scripts/test-scope.json b/scripts/test-scope.json index 2cc870b..d4a41cb 100644 --- a/scripts/test-scope.json +++ b/scripts/test-scope.json @@ -9,6 +9,80 @@ "⚠️ 文件缺失或解析不了 ⇒ 门禁红:范围声明不出来时,不许默认放行。" ], "optional": [ + {"package":"knowledge-governance/cmd/worker","test":"TestR11RevokedAuthorizationStopsBeforeFirstWrite","reason":"需要显式一次性本机PG治理库:真实授权行在预备份后被撤销,验证零写入与保留预备份;普通CI跳过不是通过"}, + {"package":"knowledge-governance/cmd/worker","test":"TestR11FinalizeFailureAfterTerminalHoldsThenRepairsWithoutRewrite","reason":"需要显式一次性本机PG治理库:真实维护行/作业行/版本事件行上注入收尾故障,验证held与只补收尾不重写;普通CI跳过不是通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR11StableIdentityMatrixIsolated","reason":"显式一次性本机PG/ES/MinIO目录、身份、自然键及备份/授权边界;r11独立runner保存raw与零写读回。普通CI跳过不是通过。"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR11ReferenceAndCursorIsolated","reason":"显式一次性本机PG/ES/MinIO目录、身份、自然键及备份/授权边界;r11独立runner保存raw与零写读回。普通CI跳过不是通过。"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR11NaturalKeyMatrixIsolated","reason":"显式一次性本机PG/ES/MinIO目录、身份、自然键及备份/授权边界;r11独立runner保存raw与零写读回。普通CI跳过不是通过。"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR11GrantBoundaryIsolated","reason":"显式一次性本机PG/ES/MinIO目录、身份、自然键及备份/授权边界;r11独立runner保存raw与零写读回。普通CI跳过不是通过。"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR11CatalogBindingIsolated","reason":"显式一次性本机PG/ES/MinIO目录、身份、自然键及备份/授权边界;r11独立runner保存raw与零写读回。普通CI跳过不是通过。"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR11BackupMutationIsolated","reason":"显式一次性本机PG/ES/MinIO目录、身份、自然键及备份/授权边界;r11独立runner保存raw与零写读回。普通CI跳过不是通过。"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR10RestoreForeignResourceReferencesIsolated","reason":"本机隔离PG/ES/MinIO真实发布后注入未知绑定/外库正文metadata引用,验证Restore在所有副作用前held;普通CI跳过不算通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR10ProductionAdmissionIsolated","reason":"需要显式一次性本机PG/ES/MinIO隔离资源;r10真实数据契约与实际stack准入另存raw及零写读回,普通CI跳过不算通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR10SourceRelationClosureIsolated","reason":"需要显式一次性本机PG/ES/MinIO隔离资源;r10真实数据契约与实际stack准入另存raw及零写读回,普通CI跳过不算通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR10IncomingRelationClosureIsolated","reason":"需要显式一次性本机PG/ES/MinIO隔离资源;r10真实数据契约与实际stack准入另存raw及零写读回,普通CI跳过不算通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR10BodyOnlyResourceIsolated","reason":"需要显式一次性本机PG/ES/MinIO隔离资源;r10真实数据契约与实际stack准入另存raw及零写读回,普通CI跳过不算通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR10UnknownResourceShapeIsolated","reason":"需要显式一次性本机PG/ES/MinIO隔离资源;r10真实数据契约与实际stack准入另存raw及零写读回,普通CI跳过不算通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR10SequenceRejectionIsolated","reason":"需要显式一次性本机PG/ES/MinIO隔离资源;r10真实数据契约与实际stack准入另存raw及零写读回,普通CI跳过不算通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR10SequenceOrderingReplayIsolated","reason":"需要显式一次性本机PG/ES/MinIO隔离资源;r10真实数据契约与实际stack准入另存raw及零写读回,普通CI跳过不算通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestR10SourceSchemaBoundIsolated","reason":"需要显式一次性本机PG/ES/MinIO隔离资源;r10真实数据契约与实际stack准入另存raw及零写读回,普通CI跳过不算通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestFormalWorkerRecoveryIntent","reason":"专属本机隔离进程链:新恢复队列、正式worker/自动grant/维护协调器/PG/ES/MinIO、恢复中SIGKILL与真实ES提交后丢响应;外部隔离runner逐场景执行并单列证据,普通CI跳过不是通过"}, + {"package":"knowledge-governance/internal/releaseadapter/v071","test":"TestFormalWorkerDoubleInterruption","reason":"仅专属本机隔离部署:实际worker与网关进程、Docker维护入口、独立治理/业务PG、MinIO只读/写身份、ES及隔离构建短租约;普通CI跳过不算通过,进程级证据单列"}, + { + "package": "knowledge-governance/internal/objectgateway", + "test": "TestGatewayAcquisitionPersistsAttemptDelivery", + "reason": "仅显式一次性 loopback 治理PG和随机MinIO测试桶运行;验证持久grant交付、跨epoch发送身份及unknown阻断,本机隔离证据单列,普通CI跳过不算通过" + }, + { + "package": "knowledge-governance/internal/objectgateway", + "test": "TestGatewayAcquisitionCannotHandOverUnknownSend", + "reason": "仅显式一次性 loopback 治理PG和随机MinIO测试桶运行;验证持久grant交付、跨epoch发送身份及unknown阻断,本机隔离证据单列,普通CI跳过不算通过" + }, + { + "package": "knowledge-governance/internal/objectgateway", + "test": "TestGatewayNewEpochPreservesOriginalSendIdentity", + "reason": "仅显式一次性 loopback 治理PG和随机MinIO测试桶运行;验证持久grant交付、跨epoch发送身份及unknown阻断,本机隔离证据单列,普通CI跳过不算通过" + }, + { + "package": "knowledge-governance/internal/objectgateway", + "test": "TestGatewayReadinessRequiresJournal", + "reason": "仅显式一次性loopback kg_library_test_gateway_*治理库、随机MinIO桶及本轮构建网关二进制执行;普通CI不带存储凭据,本机隔离实跑另存raw,跳过不算通过" + }, + { + "package": "knowledge-governance/internal/objectgateway", + "test": "TestGatewayRealReplayAndImmutableLedger", + "reason": "仅显式一次性loopback kg_library_test_gateway_*治理库、随机MinIO桶及本轮构建网关二进制执行;普通CI不带存储凭据,本机隔离实跑另存raw,跳过不算通过" + }, + { + "package": "knowledge-governance/internal/objectgateway", + "test": "TestGatewayActualServiceTwoInterruptions", + "reason": "仅显式一次性loopback kg_library_test_gateway_*治理库、随机MinIO桶及本轮构建网关二进制执行;普通CI不带存储凭据,本机隔离实跑另存raw,跳过不算通过" + }, + { + "package": "knowledge-governance/internal/objectgateway", + "test": "TestGatewayAbsenceNeverSettlesUnknown", + "reason": "仅显式一次性loopback kg_library_test_gateway_*治理库、随机MinIO桶及本轮构建网关二进制执行;普通CI不带存储凭据,本机隔离实跑另存raw,跳过不算通过" + }, + { + "package": "knowledge-governance/internal/objectgateway", + "test": "TestGatewayReadOnlyPersistenceBlocksSend", + "reason": "仅显式一次性loopback kg_library_test_gateway_*治理库、随机MinIO桶及本轮构建网关二进制执行;普通CI不带存储凭据,本机隔离实跑另存raw,跳过不算通过" + }, + { + "package": "knowledge-governance/internal/objectgateway", + "test": "TestGatewayIntentCommitFailureNeverSends", + "reason": "仅显式一次性loopback kg_library_test_gateway_*治理库、随机MinIO桶及本轮构建网关二进制执行;普通CI不带存储凭据,本机隔离实跑另存raw,跳过不算通过" + }, + { + "package": "knowledge-governance/internal/objectgateway", + "test": "TestGatewayGrantCannotAuthorizeUnplannedKey", + "reason": "仅显式一次性loopback kg_library_test_gateway_*治理库、随机MinIO桶及本轮构建网关二进制执行;普通CI不带存储凭据,本机隔离实跑另存raw,跳过不算通过" + }, + { + "package": "knowledge-governance/internal/objectgateway", + "test": "TestGatewayTargetIdentityOnEveryCall", + "reason": "仅显式一次性loopback kg_library_test_gateway_*治理库、随机MinIO桶及本轮构建网关二进制执行;普通CI不带存储凭据,本机隔离实跑另存raw,跳过不算通过" + }, { "package": "knowledge-governance/cmd/worker", "test": "TestLibraryReleaseRejectsAnotherTargetBeforeMaintenance", @@ -312,6 +386,36 @@ "package": "knowledge-governance/cmd/worker", "test": "TestUnownedHandoffCreatesNoStageRow", "reason": "需要隔离 fixture PostgreSQL:验证未被持有的 handoff 不建阶段行、不改作业,且用真实 handoff ID 重放时幂等且零写入。CI 无测试库;本机已实跑(go test ./cmd/worker -count=1 → ok)" + }, + { + "package": "knowledge-governance/internal/releaseadapter/v071", + "test": "TestIndexRecoveryHelper", + "reason": "真实ES响应丢失恢复用例的独立子进程;仅由父fixture注入隔离数据库/索引/归档,单独运行跳过不代表恢复通过" + }, + { + "package": "knowledge-governance/internal/releaseadapter/v071", + "test": "TestContractOSSExactVersionsRealOptIn", + "reason": "真实OSS写入须显式获准的隔离前缀和持久证据目录;未配置不连接云端、不改桶设置;HTTP协议桩通过不能替代真实OSS验收" + }, + { + "package": "knowledge-governance/internal/releaseadapter/v071", + "test": "TestLibraryDuplicateSlugRejectedBeforeWriteIsolated", + "reason": "隔离PG/ES/MinIO夹具,重复slug必须写前拒绝且零对象写;默认CI不连接这些服务" + }, + { + "package": "knowledge-governance/internal/releaseadapter/v071", + "test": "TestContractIndexLostResponseRestartCompensatesIsolated", + "reason": "真实隔离PG/ES/MinIO与新子进程恢复;默认CI无存储服务,跳过不算通过" + }, + { + "package": "knowledge-governance/internal/releaseadapter/v071", + "test": "TestContractIndexUnknownEvidenceBoundariesIsolated", + "reason": "真实隔离PG/ES/MinIO;归属marker/内容/CAS及未记录finalize负例,默认CI无这些服务" + }, + { + "package": "knowledge-governance/internal/releaseadapter/v071", + "test": "TestContractIndexClaimDoesNotAlterMappingIsolated", + "reason": "真实隔离PG/ES/MinIO;验证mapping哈希不变和成功后无暂态marker,默认CI无这些服务" } ] }