knowledge-governance/internal/platform/postgres/library_target_test.go

package postgres

import (
	"context"
	"testing"
	"time"

	"knowledge-governance/internal/governance"
)

// Exercise the existing SQL against a real disposable PostgreSQL schema.
// Keep the unbound legacy namespace available to prove history survives
// while configured targets cannot adopt it.
func targetTestStore(s *Store, target string) *Store {
	return s.WithLibraryTarget(target)
}

func TestLibraryTargetRejectsForeignEvidenceJobsAndGrants(t *testing.T) {
	legacy, _ := openVersionStore(t)
	a, b := legacy.WithLibraryTarget("target-a"), legacy.WithLibraryTarget("target-b")
	ctx := context.Background()
	now := time.Now().UTC()
	recordPrebackup(t, ctx, a, "internal", "backup-job", "backup", now)
	if err := a.RecordLibraryVersion(ctx, governance.LibraryVersion{ID: "source-seal", Scope: "internal", Kind: governance.LibraryVersionTestSealed, SnapshotID: "source", SourceJobID: "seal-job", CreatedAt: now}); err != nil {
		t.Fatal(err)
	}
	checks := []struct {
		name string
		run  func() bool
	}{
		{"version list", func() bool {
			rows, err := b.LibraryVersions(ctx, "internal", 100)
			return err == nil && len(rows) == 1 && rows[0].Kind == governance.LibraryVersionTestSealed
		}},
		{"exact backup", func() bool {
			_, found, err := b.LibraryVersionByRef(ctx, "internal", governance.LibraryVersionProductionPrebackup, "backup-job", "backup")
			return err == nil && !found
		}},
		{"snapshot version", func() bool {
			_, found, err := b.LibraryVersionOfSnapshot(ctx, "internal", governance.LibraryVersionProductionPrebackup, "backup")
			return err == nil && !found
		}},
		{"provenance", func() bool {
			rows, err := b.LibraryVersionsBySnapshot(ctx, "internal", "backup")
			return err == nil && len(rows) == 0
		}},
		{"snapshot kinds", func() bool {
			rows, err := b.LibrarySnapshotKinds(ctx, "internal", "backup")
			return err == nil && len(rows) == 0
		}},
		{"reuse sources", func() bool {
			rows, err := b.LibraryReuseSources(ctx, "internal", 100)
			return err == nil && len(rows) == 0
		}},
		{"handoff candidates", func() bool {
			rows, err := b.LibrarySnapshotCandidates(ctx, "internal", time.Time{}, "", 100)
			return err == nil && len(rows) == 1 && rows[0].SnapshotID == "source"
		}},
	}
	for _, check := range checks {
		t.Run(check.name, func(t *testing.T) {
			if !check.run() {
				t.Fatal("foreign target evidence was accepted or source seal was hidden")
			}
		})
	}
	job, _, err := a.CreateLibraryJob(ctx, governance.LibraryJob{ID: "target-a-job", Scope: "internal", Kind: governance.LibraryJobSync, IdempotencyKey: "target-a-job", RequestDigest: "digest", TargetSnapshotID: "source"}, governance.SyncStages(), now)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := b.LibraryJob(ctx, job.ID); err == nil {
		t.Error("new executor admitted old target job")
	}
	if _, _, err := b.PrepareLibraryJobResume(ctx, job.ID, now); err == nil {
		t.Error("new target resumed old target job")
	}
	grant := governance.LibraryReleaseAuthorization{ID: "grant-a", Scope: "internal", SnapshotID: "source", ParamsDigest: "same-input", AuthorizedBy: "admin", ExpiresAt: now.Add(time.Hour), CreatedAt: now}
	if err := a.CreateLibraryAuthorization(ctx, grant); err != nil {
		t.Fatal(err)
	}
	if _, found, err := b.ActiveLibraryAuthorization(ctx, "internal", "source", "same-input", now); err != nil || found {
		t.Errorf("foreign grant accepted: found=%v err=%v", found, err)
	}
	if rows, err := b.LibraryAuthorizations(ctx, "internal", 100); err != nil || len(rows) != 0 {
		t.Errorf("foreign grant listed: rows=%v err=%v", rows, err)
	}
	if err := b.RevokeLibraryAuthorization(ctx, grant.ID, now); err == nil {
		t.Error("foreign grant revoked")
	}
	if _, found, err := a.ActiveLibraryAuthorization(ctx, "internal", "source", "same-input", now); err != nil || !found {
		t.Errorf("original grant must remain valid: found=%v err=%v", found, err)
	}
}

func TestLibraryTargetRejectsForeignOperationReplay(t *testing.T) {
	legacy, _ := openVersionStore(t)
	a, b := legacy.WithLibraryTarget("target-a"), legacy.WithLibraryTarget("target-b")
	ctx := context.Background()
	op := governance.LibraryOperation{ID: "operation", Scope: "internal", Kind: governance.LibraryJobSync, TargetSnapshotID: "snapshot", RequestDigest: "digest", OperationKey: "same-key", CreatedAt: time.Now(), Actor: "admin"}
	if _, _, err := a.EnsureLibraryOperation(ctx, op); err != nil {
		t.Fatal(err)
	}
	if _, _, err := b.EnsureLibraryOperation(ctx, op); err == nil {
		t.Error("new target replayed foreign operation")
	}
	if _, err := b.LibraryOperation(ctx, op.ID); err == nil {
		t.Error("new target read foreign operation as its own")
	}
}

func TestLibraryTargetRejectsEventIdentityCollision(t *testing.T) {
	legacy, _ := openVersionStore(t)
	a, b := legacy.WithLibraryTarget("target-a"), legacy.WithLibraryTarget("target-b")
	ctx := context.Background()
	event := governance.LibraryVersion{ID: "same-event", Scope: "internal", Kind: governance.LibraryVersionProductionEffective, SnapshotID: "snapshot", SourceJobID: "job", CreatedAt: time.Now()}
	if err := a.RecordLibraryVersion(ctx, event); err != nil {
		t.Fatal(err)
	}
	if err := b.RecordLibraryVersion(ctx, event); err == nil {
		t.Fatal("foreign event collision was silently accepted")
	}
	event.ID = "seal"
	event.Kind = governance.LibraryVersionTestSealed
	if err := a.RecordLibraryVersion(ctx, event); err != nil {
		t.Fatal(err)
	}
	if err := b.RecordLibraryVersion(ctx, event); err != nil {
		t.Fatalf("source seal replay must remain independent: %v", err)
	}
}

func TestLibraryTargetSeparatesCurrentAndPreservesLegacy(t *testing.T) {
	legacy, pool := openVersionStore(t)
	a := targetTestStore(legacy, "target-a")
	b := targetTestStore(legacy, "target-b")
	ctx := context.Background()
	now := time.Now().UTC()
	record := func(s *Store, id string, at time.Time) {
		t.Helper()
		if err := s.RecordLibraryVersion(ctx, governance.LibraryVersion{
			ID: id, Scope: "internal", Kind: governance.LibraryVersionProductionEffective,
			SnapshotID: "snapshot-" + id, SourceJobID: "job-" + id, Evidence: map[string]any{"verified": true}, CreatedAt: at,
		}); err != nil {
			t.Fatal(err)
		}
	}
	record(legacy, "legacy", now)
	if _, found, err := b.LibraryCurrentVersion(ctx, "internal"); err != nil || found {
		t.Fatalf("new target inherited legacy current: found=%v err=%v", found, err)
	}
	record(a, "a", now.Add(time.Second))
	record(b, "b", now.Add(2*time.Second))
	for _, tc := range []struct {
		s    *Store
		want string
	}{{legacy, "legacy"}, {a, "a"}, {b, "b"}} {
		got, found, err := tc.s.LibraryCurrentVersion(ctx, "internal")
		if err != nil || !found || got.ID != tc.want || got.SupersededAt != nil {
			t.Fatalf("target current must remain independent: want=%s got=%+v found=%v err=%v", tc.want, got, found, err)
		}
	}
	var count int
	if err := pool.QueryRow(ctx, "SELECT count(*) FROM library_versions").Scan(&count); err != nil || count != 3 {
		t.Fatalf("history changed: count=%d err=%v", count, err)
	}
}