knowledge-governance/internal/workflows/testweknora/validate_test.go

package testweknora

import (
	"context"
	"errors"
	"testing"
	"time"

	"knowledge-governance/internal/governance"
	"knowledge-governance/internal/jobs"
	postgresstore "knowledge-governance/internal/platform/postgres"
	"knowledge-governance/internal/platform/weknora"
)

func TestValidateHandlerAppendsDeterministicChecksAndManualRetrieval(t *testing.T) {
	client := &validateClientStub{
		knowledge:  weknora.Knowledge{ID: "knowledge-1", KnowledgeBaseID: "kb-1"},
		chunkTotal: 3,
	}
	store := &validateStoreStub{publication: postgresstore.PublicationForValidation{
		ID: "publication-1", TestKBID: "kb-1", KnowledgeID: "knowledge-1",
	}}
	now := time.Date(2026, time.September, 4, 4, 10, 0, 0, time.UTC)
	handler, err := NewValidateHandler(ValidateHandlerConfig{
		Store: store, Client: client, RunID: "run-1", PolicyVersion: "structural-v1",
		Now: func() time.Time { return now },
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := handler.Handle(context.Background(), jobs.Job{Payload: []byte(`{"publication_id":"publication-1"}`)}); err != nil {
		t.Fatalf("Handle() error = %v", err)
	}
	if len(store.appended) != 3 {
		t.Fatalf("appended = %d, want 3: %#v", len(store.appended), store.appended)
	}
	byType := map[string]governance.AcceptanceResult{}
	for _, result := range store.appended {
		byType[result.CheckType] = result
	}
	if byType["knowledge_exists"].State != governance.AcceptancePassed {
		t.Fatalf("knowledge_exists = %#v", byType["knowledge_exists"])
	}
	if byType["chunks_present"].State != governance.AcceptancePassed {
		t.Fatalf("chunks_present = %#v", byType["chunks_present"])
	}
	if byType["retrieval_hit"].State != governance.AcceptanceManualRequired {
		t.Fatalf("retrieval_hit = %#v", byType["retrieval_hit"])
	}
	for _, result := range store.appended {
		if result.PublicationID != "publication-1" || result.RunID != "run-1" || result.ObservedAt != now {
			t.Fatalf("acceptance metadata = %#v", result)
		}
	}
}

func TestValidateHandlerFailsChecksWithoutAborting(t *testing.T) {
	client := &validateClientStub{
		knowledge:  weknora.Knowledge{ID: "knowledge-mismatch", KnowledgeBaseID: "kb-other"},
		chunkTotal: 0,
	}
	store := &validateStoreStub{publication: postgresstore.PublicationForValidation{
		ID: "publication-1", TestKBID: "kb-1", KnowledgeID: "knowledge-1",
	}}
	handler, err := NewValidateHandler(ValidateHandlerConfig{
		Store: store, Client: client, RunID: "run-2", PolicyVersion: "structural-v1",
		Now: func() time.Time { return time.Date(2026, time.September, 4, 4, 11, 0, 0, time.UTC) },
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := handler.Handle(context.Background(), jobs.Job{Payload: []byte(`{"publication_id":"publication-1"}`)}); err != nil {
		t.Fatalf("Handle() error = %v", err)
	}
	if len(store.appended) != 3 {
		t.Fatalf("appended = %d, want 3", len(store.appended))
	}
	byType := map[string]governance.AcceptanceResult{}
	for _, result := range store.appended {
		byType[result.CheckType] = result
	}
	if byType["knowledge_exists"].State != governance.AcceptanceFailed || byType["chunks_present"].State != governance.AcceptanceFailed {
		t.Fatalf("failed checks = %#v", store.appended)
	}
	if byType["retrieval_hit"].State != governance.AcceptanceManualRequired {
		t.Fatalf("retrieval still manual = %#v", byType["retrieval_hit"])
	}
}

type validateStoreStub struct {
	publication postgresstore.PublicationForValidation
	appended    []governance.AcceptanceResult
	reviews     []governance.ReviewPublicationRequest
	reviewErr   error
}

func (store *validateStoreStub) LoadPublicationForValidation(context.Context, string) (postgresstore.PublicationForValidation, error) {
	return store.publication, nil
}

func (store *validateStoreStub) AppendAcceptanceResult(_ context.Context, result governance.AcceptanceResult) error {
	store.appended = append(store.appended, result)
	return nil
}

func (store *validateStoreStub) ReviewPublication(_ context.Context, request governance.ReviewPublicationRequest) (governance.PublicationReview, error) {
	if store.reviewErr != nil {
		return governance.PublicationReview{}, store.reviewErr
	}
	store.reviews = append(store.reviews, request)
	return governance.PublicationReview{ID: "rv-auto", PublicationID: request.PublicationID}, nil
}

type validateClientStub struct {
	knowledge  weknora.Knowledge
	chunkTotal int64
}

func (client *validateClientStub) GetKnowledge(context.Context, string) (weknora.Knowledge, error) {
	return client.knowledge, nil
}

func (client *validateClientStub) ListChunks(context.Context, string, int, int, []string) ([]weknora.Chunk, int64, error) {
	chunks := make([]weknora.Chunk, 0, client.chunkTotal)
	for i := int64(0); i < client.chunkTotal; i++ {
		chunks = append(chunks, weknora.Chunk{ID: "chunk", KnowledgeID: "knowledge-1"})
	}
	return chunks, client.chunkTotal, nil
}

// 自动批准：验收通过的知识由系统写入批准，替代"每份文档人工点一次批准"。
// 关键边界：对外不自动、策略可关、验收没过不批、自动批准自己失败也绝不把验收判成失败。
func TestValidateHandlerAutoApprovesVerifiedInternalPublications(t *testing.T) {
	run := func(t *testing.T, scope string, policy governance.AutoReviewPolicy, knowledgeBase, knowledgeID string, reviewErr error) (*validateStoreStub, error) {
		t.Helper()
		client := &validateClientStub{
			knowledge:  weknora.Knowledge{ID: knowledgeID, KnowledgeBaseID: knowledgeBase},
			chunkTotal: 3,
		}
		store := &validateStoreStub{
			publication: postgresstore.PublicationForValidation{ID: "publication-1", TestKBID: "kb-1", KnowledgeID: "knowledge-1", TargetScope: scope},
			reviewErr:   reviewErr,
		}
		now := time.Date(2026, time.October, 10, 8, 0, 0, 0, time.UTC)
		handler, err := NewValidateHandler(ValidateHandlerConfig{
			Store: store, Client: client, RunID: "run-1", PolicyVersion: "structural-v1",
			AutoReviewPolicy: policy, Now: func() time.Time { return now },
		})
		if err != nil {
			t.Fatal(err)
		}
		return store, handler.Handle(context.Background(), jobs.Job{ID: "job-1", Payload: []byte(`{"publication_id":"publication-1"}`)})
	}

	store, err := run(t, "internal", governance.AutoReviewInternal, "kb-1", "knowledge-1", nil)
	if err != nil {
		t.Fatalf("Handle() error = %v", err)
	}
	if len(store.reviews) != 1 {
		t.Fatalf("auto reviews = %d, want 1", len(store.reviews))
	}
	review := store.reviews[0]
	if review.ReviewerRef != "system:auto" || review.Decision != governance.ReviewApproved || review.DecidedVisibility != governance.VisibilityInternal || review.DecisionCode != "approved_for_release" {
		t.Fatalf("auto review = %#v", review)
	}
	if review.Now.IsZero() {
		t.Fatalf("auto review must carry the observation time")
	}

	// 对外：默认不自动批准。
	external, err := run(t, "external", governance.AutoReviewInternal, "kb-1", "knowledge-1", nil)
	if err != nil || len(external.reviews) != 0 {
		t.Fatalf("external auto reviews = %d error = %v", len(external.reviews), err)
	}
	// 策略关闭。
	off, err := run(t, "internal", governance.AutoReviewOff, "kb-1", "knowledge-1", nil)
	if err != nil || len(off.reviews) != 0 {
		t.Fatalf("off auto reviews = %d error = %v", len(off.reviews), err)
	}
	// 验收没过（知识存在性校验失败）：不批准。
	failed, err := run(t, "internal", governance.AutoReviewInternal, "kb-other", "knowledge-1", nil)
	if err != nil || len(failed.reviews) != 0 {
		t.Fatalf("failed-acceptance auto reviews = %d error = %v", len(failed.reviews), err)
	}
	// 自动批准自己失败（例如已被人工审过）不能让验收失败。
	conflicted, err := run(t, "internal", governance.AutoReviewInternal, "kb-1", "knowledge-1", postgresstore.ErrPublicationReviewNotEligible)
	if err != nil {
		t.Fatalf("review-not-eligible must not fail validation: %v", err)
	}
	if len(conflicted.reviews) != 0 || len(conflicted.appended) != 3 {
		t.Fatalf("conflicted reviews = %d appended = %d", len(conflicted.reviews), len(conflicted.appended))
	}
	// 其他错误也只是上报，不影响验收结论。
	reported := 0
	client := &validateClientStub{knowledge: weknora.Knowledge{ID: "knowledge-1", KnowledgeBaseID: "kb-1"}, chunkTotal: 3}
	store2 := &validateStoreStub{publication: postgresstore.PublicationForValidation{ID: "publication-1", TestKBID: "kb-1", KnowledgeID: "knowledge-1", TargetScope: "internal"}, reviewErr: errors.New("boom")}
	handler, err := NewValidateHandler(ValidateHandlerConfig{
		Store: store2, Client: client, RunID: "run-1", PolicyVersion: "structural-v1",
		AutoReviewPolicy: governance.AutoReviewInternal, Report: func(error) { reported++ },
		Now: func() time.Time { return time.Now().UTC() },
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := handler.Handle(context.Background(), jobs.Job{ID: "job-2", Payload: []byte(`{"publication_id":"publication-1"}`)}); err != nil {
		t.Fatalf("auto review failure must not fail validation: %v", err)
	}
	if reported != 1 {
		t.Fatalf("reported = %d, want 1", reported)
	}
}