package postgres import ( "context" "errors" "strings" "testing" "time" "github.com/jackc/pgx/v5" "github.com/jackc/pgx/v5/pgconn" "knowledge-governance/internal/governance" ) func TestListReviewCandidatesReturnsSafeCurrentGateProjection(t *testing.T) { now := time.Date(2026, 9, 6, 8, 0, 0, 0, time.UTC) db := &recordingDB{ row: reviewCountRow{count: 1}, rows: &reviewCandidateRows{values: []reviewCandidateRow{{ publicationID: "tp-safe", title: "Synthetic review item", sourceType: "manual", currentVisibility: "internal", acceptanceRunID: "job-safe", knowledgeState: "passed", chunksState: "passed", retrievalState: "manual_required", gateStatus: "ready", gateCode: "ready", reviewState: "pending", updatedAt: now, }}}, } page, err := NewStore(db).ListReviewCandidates(context.Background(), governance.ReviewCandidateFilter{ReviewState: "pending", Limit: 20, Offset: 0}) if err != nil { t.Fatalf("ListReviewCandidates() error = %v", err) } if page.Total != 1 || len(page.Items) != 1 { t.Fatalf("page = %#v", page) } item := page.Items[0] if item.PublicationID != "tp-safe" || item.GateStatus != governance.ReviewGateReady || item.ReviewState != governance.ReviewPending || item.RetrievalHit != governance.AcceptanceManualRequired { t.Fatalf("item = %#v", item) } joined := strings.ToLower(db.queryRowSQL + "\n" + db.querySQL) for _, required := range []string{ "from acceptance_results", "distinct on (publication_id)", "knowledge_exists", "chunks_present", "retrieval_hit", "manual_required", "from publication_reviews", "publication_updated_at", "acceptance_run_id", } { if !strings.Contains(joined, required) { t.Errorf("review queue SQL missing %q", required) } } for _, forbidden := range []string{"knowledge_id", "test_kb_id", "local_spool_ref", "stable_external_id", "canonical_uri_hash", "raw_record_summary", "secret_ref", "base_url"} { if strings.Contains(joined, forbidden) { t.Errorf("review queue SQL includes forbidden projection %q", forbidden) } } } func TestListReviewCandidatesRejectsInvalidFilter(t *testing.T) { _, err := NewStore(&recordingDB{}).ListReviewCandidates(context.Background(), governance.ReviewCandidateFilter{ReviewState: "invalid", Limit: 20}) if !errors.Is(err, ErrInvalidReviewFilter) { t.Fatalf("error = %v, want ErrInvalidReviewFilter", err) } } func TestReviewPublicationAppendsCurrentAcceptanceBoundDecision(t *testing.T) { now := time.Date(2026, 9, 6, 8, 10, 0, 0, time.UTC) db := &recordingDB{row: publicationReviewRow{ id: "rv-safe", publicationID: "tp-safe", decision: "approved", visibility: "internal", reviewerRef: "engineer-1", decisionCode: "approved_for_release", acceptanceRunID: "job-safe", publicationUpdatedAt: now.Add(-time.Minute), createdAt: now, }} review, err := NewStore(db).ReviewPublication(context.Background(), governance.ReviewPublicationRequest{ PublicationID: "tp-safe", Decision: governance.ReviewApproved, DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "engineer-1", DecisionCode: "approved_for_release", Now: now, }) if err != nil { t.Fatalf("ReviewPublication() error = %v", err) } if review.ID != "rv-safe" || review.Decision != governance.ReviewApproved || review.AcceptanceRunID != "job-safe" { t.Fatalf("review = %#v", review) } sql := strings.ToLower(db.queryRowSQL) for _, required := range []string{ "insert into publication_reviews", "acceptance_run_id", "publication_updated_at", "gate_status = 'ready'", "on conflict", "returning", } { if !strings.Contains(sql, required) { t.Errorf("review SQL missing %q", required) } } } func TestReviewPublicationRejectsInvalidDecisionContract(t *testing.T) { requests := []governance.ReviewPublicationRequest{ {PublicationID: "tp-safe", Decision: governance.ReviewApproved, DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "engineer-1", DecisionCode: "needs_correction", Now: time.Now()}, {PublicationID: "tp-safe", Decision: governance.ReviewRejected, DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "engineer-1", DecisionCode: "approved_for_release", Now: time.Now()}, {PublicationID: "tp-safe", Decision: governance.ReviewApproved, DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "bad\nactor", DecisionCode: "approved_for_release", Now: time.Now()}, } for _, request := range requests { if _, err := NewStore(&recordingDB{}).ReviewPublication(context.Background(), request); !errors.Is(err, ErrInvalidPublicationReview) { t.Fatalf("request=%#v error=%v, want ErrInvalidPublicationReview", request, err) } } } func TestReviewPublicationReturnsNotEligibleWhenGateRejects(t *testing.T) { db := &recordingDB{row: sourceScanErrorRow{err: pgx.ErrNoRows}} _, err := NewStore(db).ReviewPublication(context.Background(), governance.ReviewPublicationRequest{ PublicationID: "tp-safe", Decision: governance.ReviewApproved, DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "engineer-1", DecisionCode: "approved_for_release", Now: time.Now(), }) if !errors.Is(err, ErrPublicationReviewNotEligible) { t.Fatalf("error=%v, want ErrPublicationReviewNotEligible", err) } } type reviewCountRow struct{ count int } func (r reviewCountRow) Scan(dest ...any) error { *dest[0].(*int) = r.count return nil } type publicationReviewRow struct { id, publicationID, decision, visibility, reviewerRef, decisionCode string acceptanceRunID string publicationUpdatedAt, createdAt time.Time } func (r publicationReviewRow) Scan(dest ...any) error { *dest[0].(*string), *dest[1].(*string), *dest[2].(*string), *dest[3].(*string) = r.id, r.publicationID, r.decision, r.visibility *dest[4].(*string), *dest[5].(*string), *dest[6].(*string) = r.reviewerRef, r.decisionCode, r.acceptanceRunID *dest[7].(*time.Time), *dest[8].(*time.Time) = r.publicationUpdatedAt, r.createdAt return nil } type reviewCandidateRow struct { publicationID, title, sourceType, currentVisibility string acceptanceRunID, knowledgeState, chunksState string retrievalState, gateStatus, gateCode, reviewState string decidedVisibility, decisionCode, reviewerRef string reviewedAt *time.Time updatedAt time.Time } type reviewCandidateRows struct { values []reviewCandidateRow index int } func (r *reviewCandidateRows) Close() {} func (r *reviewCandidateRows) Err() error { return nil } func (r *reviewCandidateRows) CommandTag() pgconn.CommandTag { return pgconn.CommandTag{} } func (r *reviewCandidateRows) FieldDescriptions() []pgconn.FieldDescription { return nil } func (r *reviewCandidateRows) RawValues() [][]byte { return nil } func (r *reviewCandidateRows) Conn() *pgx.Conn { return nil } func (r *reviewCandidateRows) Next() bool { if r.index >= len(r.values) { return false } r.index++ return true } func (r *reviewCandidateRows) Scan(dest ...any) error { v := r.values[r.index-1] *dest[0].(*string), *dest[1].(*string), *dest[2].(*string), *dest[3].(*string) = v.publicationID, v.title, v.sourceType, v.currentVisibility *dest[4].(*string), *dest[5].(*string), *dest[6].(*string), *dest[7].(*string) = v.acceptanceRunID, v.knowledgeState, v.chunksState, v.retrievalState *dest[8].(*string), *dest[9].(*string), *dest[10].(*string) = v.gateStatus, v.gateCode, v.reviewState *dest[11].(*string), *dest[12].(*string), *dest[13].(*string) = v.decidedVisibility, v.decisionCode, v.reviewerRef *dest[14].(**time.Time), *dest[15].(*time.Time) = v.reviewedAt, v.updatedAt return nil } func (r *reviewCandidateRows) Values() ([]any, error) { return nil, nil }