knowledge-governance/internal/releaseadapter/v071/document_target_test.go

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"
}