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

package testweknora

import (
	"context"
	"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
}

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
}

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
}