package v071 import ( "context" "os" "reflect" "testing" "knowledge-governance/internal/releasebundle" releaseworkflow "knowledge-governance/internal/workflows/release" ) func TestDocumentTargetCoordinatesPrepareActivateVerifyAndRollback(t *testing.T) { root := t.TempDir() _ = os.Chmod(root, 0o700) archive, _ := NewBundleArchive(root, 16*1024*1024) current := testDocumentBundle(t) prior := cloneBundleWithRevision(t, current, "prod-v0") if err := archive.Save(prior); err != nil { t.Fatal(err) } calls := []string{} target, err := NewDocumentTarget(DocumentTargetConfig{Archive: archive, Contract: &stubContractInspector{contract: targetContractForBundle(current)}, Postgres: &stubPostgresTarget{calls: &calls}, Search: &stubSearchTarget{calls: &calls}, Objects: &stubObjectTarget{calls: &calls}, Verifier: &stubProductionVerifier{calls: &calls}}) if err != nil { t.Fatal(err) } item := releasePlanForArchive() item.PreviousProductionRevision = "prod-v0" change, err := target.Prepare(context.Background(), item, current) if err != nil { t.Fatal(err) } if change.PreviousRevision != "prod-v0" || change.ProductionRevision != "review-v1" { t.Fatalf("change=%#v", change) } if err := target.Activate(context.Background(), item, change); err != nil { t.Fatal(err) } if err := target.Verify(context.Background(), item, change); err != nil { t.Fatal(err) } if err := target.Compensate(context.Background(), item, change); err != nil { t.Fatal(err) } if _, err := target.Restore(context.Background(), item, "prod-v0"); err != nil { t.Fatal(err) } if err := target.VerifyRestored(context.Background(), item, "prod-v0"); err != nil { t.Fatal(err) } want := []string{"object-stage:review-v1", "object-stage:review-v1", "object-promote:review-v1", "postgres-replace", "search-replace", "verify:review-v1", "verify-wiki:review-v1", "object-stage:prod-v0", "object-promote:prod-v0", "postgres-replace", "search-replace", "object-stage:prod-v0", "object-promote:prod-v0", "postgres-replace", "search-replace", "verify:prod-v0", "verify-wiki:prod-v0"} if !reflect.DeepEqual(calls, want) { t.Fatalf("calls=%v\nwant=%v", calls, want) } } func TestDocumentTargetCompensatesFirstReleaseByDisableWithoutDelete(t *testing.T) { root := t.TempDir() _ = os.Chmod(root, 0o700) archive, _ := NewBundleArchive(root, 16*1024*1024) bundle := testDocumentBundle(t) calls := []string{} target, _ := NewDocumentTarget(DocumentTargetConfig{Archive: archive, Contract: &stubContractInspector{contract: targetContractForBundle(bundle)}, Postgres: &stubPostgresTarget{calls: &calls}, Search: &stubSearchTarget{calls: &calls}, Objects: &stubObjectTarget{calls: &calls}, Verifier: &stubProductionVerifier{calls: &calls}}) item := releasePlanForArchive() change, err := target.Prepare(context.Background(), item, bundle) if err != nil { t.Fatal(err) } if change.PreviousRevision != "absent" { t.Fatalf("change=%#v", change) } if err := target.Compensate(context.Background(), item, change); err != nil { t.Fatal(err) } if !reflect.DeepEqual(calls, []string{"object-stage:review-v1", "postgres-disable", "search-disable", "verify-disabled"}) { t.Fatalf("calls=%v", calls) } } type stubContractInspector struct { contract releasebundle.TargetContract err error } func (s *stubContractInspector) Contract(context.Context, releaseworkflow.PlanItem) (releasebundle.TargetContract, error) { return s.contract, s.err } type stubPostgresTarget struct { calls *[]string err error } func (s *stubPostgresTarget) Replace(_ context.Context, _ PostgresIdentity, _ PostgresSnapshot) error { *s.calls = append(*s.calls, "postgres-replace") return s.err } func (s *stubPostgresTarget) Disable(context.Context, PostgresIdentity) error { *s.calls = append(*s.calls, "postgres-disable") return s.err } func (s *stubPostgresTarget) ReplaceWiki(_ context.Context, _ PostgresIdentity, _ PostgresSnapshot) error { *s.calls = append(*s.calls, "postgres-replace-wiki") return s.err } type stubSearchTarget struct { calls *[]string err error } func (s *stubSearchTarget) Replace(_ context.Context, _ SearchIdentity, _ SearchSnapshot) (SearchSnapshot, error) { *s.calls = append(*s.calls, "search-replace") return SearchSnapshot{}, s.err } func (s *stubSearchTarget) Disable(context.Context, SearchIdentity) error { *s.calls = append(*s.calls, "search-disable") return s.err } type stubObjectTarget struct { calls *[]string err error } func (s *stubObjectTarget) Stage(_ context.Context, revision string, _ ObjectSnapshot) (ObjectStage, error) { *s.calls = append(*s.calls, "object-stage:"+revision) return ObjectStage{ReleaseRevision: revision}, s.err } func (s *stubObjectTarget) Promote(_ context.Context, stage ObjectStage) error { *s.calls = append(*s.calls, "object-promote:"+stage.ReleaseRevision) return s.err } type stubProductionVerifier struct { calls *[]string err error } func (s *stubProductionVerifier) Verify(_ context.Context, _ releaseworkflow.PlanItem, bundle *DocumentBundle) error { *s.calls = append(*s.calls, "verify:"+bundle.Manifest.ReleaseRevision) return s.err } func (s *stubProductionVerifier) VerifyDisabled(context.Context, releaseworkflow.PlanItem) error { *s.calls = append(*s.calls, "verify-disabled") return s.err } func (s *stubProductionVerifier) VerifyWiki(_ context.Context, _ releaseworkflow.PlanItem, bundle *DocumentBundle) error { *s.calls = append(*s.calls, "verify-wiki:"+bundle.Manifest.ReleaseRevision) return s.err } func cloneBundleWithRevision(t *testing.T, bundle *DocumentBundle, revision string) *DocumentBundle { t.Helper() clone := *bundle clone.Manifest = bundle.Manifest clone.Manifest.ReleaseRevision = revision clone.Manifest.BundleSHA256 = "" sealed, err := releasebundle.Seal(clone.Manifest) if err != nil { t.Fatal(err) } clone.Manifest = sealed return &clone } func targetContractForBundle(bundle *DocumentBundle) releasebundle.TargetContract { c := bundle.Manifest.Contract return releasebundle.TargetContract{WeKnoraVersion: c.WeKnoraVersion, MigrationVersion: c.MigrationVersion, TenantID: c.TenantID, KnowledgeBaseID: c.KnowledgeBaseID, RetrieverEngine: c.RetrieverEngine, EmbeddingModel: c.EmbeddingModel, EmbeddingDimension: c.EmbeddingDimension, ElasticsearchMappingSHA256: c.ElasticsearchMappingSHA256} } func revisionFromPostgres(snapshot PostgresSnapshot) string { if snapshot.Table("chunks").Rows[0][0] == '{' { return "review-v1" } return "unknown" } func revisionFromSearch(snapshot SearchSnapshot) string { if len(snapshot.Documents) > 0 { return "review-v1" } return "unknown" }