package main import ( "context" "encoding/json" "errors" "flag" "io" "log" "os" "strconv" "strings" "time" "github.com/jackc/pgx/v5/pgxpool" "knowledge-governance/internal/governance" postgresstore "knowledge-governance/internal/platform/postgres" "knowledge-governance/internal/platform/weknora" ) type reportStore interface { LoadPublicationForValidation(context.Context, string) (postgresstore.PublicationForValidation, error) ListAcceptanceResults(context.Context, string) ([]governance.AcceptanceRecord, error) } type reportClient interface { GetKnowledge(context.Context, string) (weknora.Knowledge, error) ListChunks(context.Context, string, int, int, []string) ([]weknora.Chunk, int64, error) SearchKnowledge(context.Context, weknora.SearchRequest) ([]weknora.SearchResult, error) } type e2eReport struct { PublicationID string `json:"publication_id"` RemoteStatus string `json:"remote_status"` ChunkTotal int64 `json:"chunk_total"` ChunkItemsRead int64 `json:"chunk_items_read"` AllChunksMatch bool `json:"all_chunks_match"` SearchResultCount int `json:"search_result_count"` TargetSearchHits int `json:"target_search_hits"` MarkerFound bool `json:"marker_found"` MaxScore float64 `json:"max_score"` StructuralPassed bool `json:"structural_passed"` SemanticState string `json:"semantic_state"` } func main() { if err := run(context.Background(), os.Args[1:], os.Getenv, os.Stdout); err != nil { log.Fatal(err) } } func run(ctx context.Context, args []string, getenv func(string) string, output io.Writer) error { flags := flag.NewFlagSet("test-weknora-e2e-report", flag.ContinueOnError) flags.SetOutput(io.Discard) publicationID := flags.String("publication-id", "", "governance publication ID") query := flags.String("query", "", "synthetic scoped retrieval query") expectedMarker := flags.String("expected-marker", "", "synthetic marker expected in a scoped result") if err := flags.Parse(args); err != nil { return errors.New("invalid report arguments") } if *publicationID == "" || *query == "" || *expectedMarker == "" { return errors.New("--publication-id, --query and --expected-marker are required") } databaseURL := getenv("DATABASE_URL") baseURL := getenv("TEST_WEKNORA_BASE_URL") keyFile := getenv("TEST_WEKNORA_API_KEY_FILE") if databaseURL == "" || baseURL == "" || keyFile == "" { return errors.New("database and test WeKnora configuration are required") } allowDockerHTTP := false if raw := getenv("TEST_WEKNORA_ALLOW_DOCKER_HTTP"); raw != "" { parsed, err := strconv.ParseBool(raw) if err != nil { return errors.New("invalid Docker HTTP setting") } allowDockerHTTP = parsed } apiKey, err := weknora.ReadAPIKeyFile(keyFile) if err != nil { return errors.New("read test WeKnora API key") } client, err := weknora.NewClient(weknora.ClientConfig{ BaseURL: baseURL, APIKey: apiKey, Timeout: 60 * time.Second, AllowDockerHTTP: allowDockerHTTP, }) if err != nil { return errors.New("create test WeKnora client") } pool, err := pgxpool.New(ctx, databaseURL) if err != nil { return errors.New("open governance database") } defer pool.Close() if err := pool.Ping(ctx); err != nil { return errors.New("connect governance database") } report, err := verifyPublication(ctx, postgresstore.NewStore(pool), client, *publicationID, *query, *expectedMarker) if err != nil { return err } return json.NewEncoder(output).Encode(report) } func verifyPublication(ctx context.Context, store reportStore, client reportClient, publicationID, query, expectedMarker string) (e2eReport, error) { publication, err := store.LoadPublicationForValidation(ctx, publicationID) if err != nil { return e2eReport{}, errors.New("load completed publication") } knowledge, err := client.GetKnowledge(ctx, publication.KnowledgeID) if err != nil || knowledge.ID != publication.KnowledgeID || knowledge.KnowledgeBaseID != publication.TestKBID { return e2eReport{}, errors.New("verify remote knowledge identity") } report := e2eReport{ PublicationID: publication.ID, RemoteStatus: knowledge.ParseStatus, AllChunksMatch: true, } for page := 1; page <= 100; page++ { chunks, total, err := client.ListChunks(ctx, publication.KnowledgeID, page, 100, []string{"text", "image_ocr"}) if err != nil { return e2eReport{}, errors.New("read remote chunks") } report.ChunkTotal = total for _, chunk := range chunks { report.ChunkItemsRead++ if chunk.KnowledgeID != publication.KnowledgeID { report.AllChunksMatch = false } } if report.ChunkItemsRead >= total || len(chunks) == 0 { break } if page == 100 { return e2eReport{}, errors.New("remote chunk pagination limit exceeded") } } results, err := client.SearchKnowledge(ctx, weknora.SearchRequest{Query: query, KnowledgeIDs: []string{publication.KnowledgeID}}) if err != nil { return e2eReport{}, errors.New("run scoped retrieval probe") } report.SearchResultCount = len(results) for _, result := range results { if result.KnowledgeID == publication.KnowledgeID { report.TargetSearchHits++ if strings.Contains(result.Content, expectedMarker) { report.MarkerFound = true } } if result.Score > report.MaxScore { report.MaxScore = result.Score } } acceptance, err := store.ListAcceptanceResults(ctx, publication.ID) if err != nil { return e2eReport{}, errors.New("read governance acceptance results") } structural := map[string]bool{"knowledge_exists": false, "chunks_present": false} for _, record := range acceptance { if _, ok := structural[record.CheckType]; ok && record.State == string(governance.AcceptancePassed) { structural[record.CheckType] = true } if record.CheckType == "retrieval_hit" { report.SemanticState = record.State } } report.StructuralPassed = structural["knowledge_exists"] && structural["chunks_present"] if report.RemoteStatus != "completed" || report.ChunkTotal <= 0 || report.ChunkItemsRead != report.ChunkTotal || !report.AllChunksMatch || report.TargetSearchHits == 0 || !report.MarkerFound { return e2eReport{}, errors.New("end-to-end verification failed") } return report, nil }