ortoni-report 4.0.2-beta.1 → 4.0.3

package/dist/cli.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import {
+  DatabaseManager,
+  FileManager,
+  HTMLGenerator,
+  startReportServer
+} from "./chunk-4RZ5C7KY.mjs";
+
+// src/cli.ts
+import { program } from "commander";
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/mergeData.ts
+import * as fs from "fs";
+import * as path from "path";
+async function mergeAllData(options = {}) {
+  const folderPath = options.dir || "ortoni-report";
+  console.info(`Ortoni Report: Merging shard files in folder: ${folderPath}`);
+  if (!fs.existsSync(folderPath)) {
+    console.error(`Ortoni Report: folder "${folderPath}" does not exist.`);
+    process.exitCode = 1;
+    return;
+  }
+  const filenames = fs.readdirSync(folderPath).filter((f) => f.startsWith("ortoni-shard-") && f.endsWith(".json"));
+  if (filenames.length === 0) {
+    console.error("Ortoni Report: \u274C No shard files found to merge.");
+    process.exitCode = 1;
+    return;
+  }
+  const shardFileIndex = (name) => {
+    const m = name.match(/ortoni-shard-(\d+)-of-(\d+)\.json$/);
+    return m ? parseInt(m[1], 10) : null;
+  };
+  const sortedFiles = filenames.map((f) => ({ f, idx: shardFileIndex(f) })).sort((a, b) => {
+    if (a.idx === null && b.idx === null) return a.f.localeCompare(b.f);
+    if (a.idx === null) return 1;
+    if (b.idx === null) return -1;
+    return a.idx - b.idx;
+  }).map((x) => x.f);
+  const allResults = [];
+  const projectSet = /* @__PURE__ */ new Set();
+  let totalDurationSum = 0;
+  let mergedUserConfig = null;
+  let mergedUserMeta = null;
+  const badShards = [];
+  const shardCounts = {};
+  const shardDurMap = {};
+  for (const file of sortedFiles) {
+    const fullPath = path.join(folderPath, file);
+    try {
+      const shardRaw = fs.readFileSync(fullPath, "utf-8");
+      const shardData = JSON.parse(shardRaw);
+      if (!Array.isArray(shardData.results)) {
+        console.warn(
+          `Ortoni Report: Shard ${file} missing results array \u2014 skipping.`
+        );
+        badShards.push(file);
+        continue;
+      }
+      shardData.results.forEach((r) => allResults.push(r));
+      shardCounts[file] = shardData.results.length;
+      if (Array.isArray(shardData.projectSet)) {
+        shardData.projectSet.forEach((p) => projectSet.add(p));
+      }
+      const rawShardDur = shardData.totalDuration;
+      let durToAdd = 0;
+      let perTestSum = 0;
+      if (typeof rawShardDur === "number") {
+        durToAdd = rawShardDur;
+      } else {
+        perTestSum = Array.isArray(shardData.results) ? shardData.results.reduce(
+          (acc, t) => acc + (Number(t?.duration) || 0),
+          0
+        ) : 0;
+        durToAdd = perTestSum;
+      }
+      totalDurationSum += durToAdd;
+      shardDurMap[file] = durToAdd;
+      if (shardData.userConfig) {
+        if (!mergedUserConfig) mergedUserConfig = { ...shardData.userConfig };
+        else {
+          Object.keys(shardData.userConfig).forEach((k) => {
+            if (mergedUserConfig[k] === void 0 || mergedUserConfig[k] === null || mergedUserConfig[k] === "") {
+              mergedUserConfig[k] = shardData.userConfig[k];
+            } else if (shardData.userConfig[k] !== mergedUserConfig[k]) {
+              console.warn(
+                `Ortoni Report: userConfig mismatch for key "${k}" between shards. Using first value "${mergedUserConfig[k]}".`
+              );
+            }
+          });
+        }
+      }
+      if (shardData.userMeta) {
+        if (!mergedUserMeta) mergedUserMeta = { ...shardData.userMeta };
+        else {
+          mergedUserMeta.meta = {
+            ...mergedUserMeta.meta || {},
+            ...shardData.userMeta.meta || {}
+          };
+        }
+      }
+    } catch (err) {
+      console.error(`Ortoni Report: Failed to parse shard ${file}:`, err);
+      badShards.push(file);
+      continue;
+    }
+  }
+  if (badShards.length > 0) {
+    console.warn(
+      `Ortoni Report: Completed merge with ${badShards.length} bad shard(s) skipped:`,
+      badShards
+    );
+  }
+  const totalDuration = totalDurationSum;
+  const saveHistoryFromOptions = typeof options.saveHistory === "boolean" ? options.saveHistory : void 0;
+  const saveHistoryFromShard = mergedUserConfig && typeof mergedUserConfig.saveHistory === "boolean" ? mergedUserConfig.saveHistory : void 0;
+  const saveHistory = saveHistoryFromOptions ?? saveHistoryFromShard ?? true;
+  let dbManager;
+  let runId;
+  if (saveHistory) {
+    try {
+      dbManager = new DatabaseManager();
+      const dbPath = path.join(folderPath, "ortoni-data-history.sqlite");
+      await dbManager.initialize(dbPath);
+      runId = await dbManager.saveTestRun();
+      if (typeof runId === "number") {
+        await dbManager.saveTestResults(runId, allResults);
+        console.info(
+          `Ortoni Report: Saved ${allResults.length} results to DB (runId=${runId}).`
+        );
+      } else {
+        console.warn(
+          "Ortoni Report: Failed to create test run in DB; proceeding without saving results."
+        );
+      }
+    } catch (err) {
+      console.error(
+        "Ortoni Report: Error while saving history to DB. Proceeding without DB:",
+        err
+      );
+      dbManager = void 0;
+      runId = void 0;
+    }
+  } else {
+    console.info(
+      "Ortoni Report: Skipping history save (saveHistory=false). (Typical for CI runs)"
+    );
+  }
+  const htmlGenerator = new HTMLGenerator(
+    { ...mergedUserConfig || {}, meta: mergedUserMeta?.meta },
+    dbManager
+  );
+  const finalReportData = await htmlGenerator.generateFinalReport(
+    // filteredResults: typically filter out skipped for display (keeps existing behavior)
+    allResults.filter((r) => r.status !== "skipped"),
+    totalDuration,
+    allResults,
+    projectSet
+    // pass Set<string> as original generateFinalReport expects
+  );
+  const fileManager = new FileManager(folderPath);
+  const outputFileName = options.file || "ortoni-report.html";
+  const outputPath = fileManager.writeReportFile(
+    outputFileName,
+    finalReportData
+  );
+  console.log(`\u2705 Final merged report generated at ${await outputPath}`);
+  console.log(`\u2705 Shards merged: ${sortedFiles.length}`);
+  console.log(`\u2705 Tests per shard:`, shardCounts);
+  console.log(`\u2705 Total tests merged ${allResults.length}`);
+}
+
+// src/cli.ts
+program.version("4.0.1").description("Ortoni Report - CLI");
+program.command("show-report").description("Open Ortoni Report").option(
+  "-d, --dir <path>",
+  "Path to the folder containing the report",
+  "ortoni-report"
+).option(
+  "-f, --file <filename>",
+  "Name of the report file",
+  "ortoni-report.html"
+).option("-p, --port <port>", "Port to run the server", "2004").action((options) => {
+  const projectRoot = process.cwd();
+  const folderPath = path2.resolve(projectRoot, options.dir);
+  const filePath = path2.resolve(folderPath, options.file);
+  const port = parseInt(options.port) || 2004;
+  if (!fs2.existsSync(filePath)) {
+    console.error(
+      `\u274C Error: The file "${filePath}" does not exist in "${folderPath}".`
+    );
+    process.exit(1);
+  }
+  startReportServer(folderPath, path2.basename(filePath), port, "always");
+});
+program.command("merge-report").description("Merge sharded reports into one final report").option(
+  "-d, --dir <path>",
+  "Path to the folder containing shard files",
+  "ortoni-report"
+).option("-f, --file <filename>", "Output report file", "ortoni-report.html").action(async (options) => {
+  await mergeAllData({
+    dir: options.dir,
+    file: options.file,
+    saveHistory: false
+  });
+});
+program.parse(process.argv);

package/dist/helpers/HTMLGenerator.d.ts

@@ -0,0 +1,89 @@
+import { TestResultData } from "../types/testResults";
+import { OrtoniReportConfig } from "../types/reporterConfig";
+import { DatabaseManager } from "./databaseManager";
+export declare class HTMLGenerator {
+    private ortoniConfig;
+    private dbManager?;
+    constructor(ortoniConfig: OrtoniReportConfig, dbManager?: DatabaseManager);
+    generateFinalReport(filteredResults: TestResultData[], totalDuration: number, results: TestResultData[], projectSet: Set<string>): Promise<{
+        summary: {
+            overAllResult: {
+                pass: number;
+                fail: number;
+                skip: number;
+                retry: number;
+                flaky: number;
+                total: number;
+            };
+            successRate: string;
+            lastRunDate: string;
+            totalDuration: number;
+            stats: {
+                projectNames: string[];
+                totalTests: number[];
+                passedTests: number[];
+                failedTests: number[];
+                skippedTests: number[];
+                retryTests: number[];
+                flakyTests: number[];
+            };
+        };
+        testResult: {
+            tests: any;
+            testHistories: {
+                testId: string;
+                history: any[];
+            }[];
+            allTags: string[];
+            set: Set<string>;
+        };
+        userConfig: {
+            projectName: string;
+            authorName: string;
+            type: string;
+            title: string;
+        };
+        userMeta: {
+            meta: Record<string, string>;
+        };
+        preferences: {
+            logo: string;
+            showProject: boolean;
+        };
+        analytics: {
+            reportData: {
+                summary: {};
+                trends: {};
+                flakyTests: any[];
+                slowTests: any[];
+                note: string;
+            } | {
+                summary: {};
+                trends: {};
+                flakyTests: any[];
+                slowTests: any[];
+                note?: undefined;
+            };
+        };
+    }>;
+    /**
+     * Return safe analytics/report data.
+     * If no dbManager is provided, return empty defaults and a note explaining why.
+     */
+    getReportData(): Promise<{
+        summary: {};
+        trends: {};
+        flakyTests: any[];
+        slowTests: any[];
+        note: string;
+    } | {
+        summary: {};
+        trends: {};
+        flakyTests: any[];
+        slowTests: any[];
+        note?: undefined;
+    }>;
+    private prepareReportData;
+    private calculateProjectResults;
+    private extractProjectStats;
+}

package/dist/helpers/HTMLGenerator.js

@@ -0,0 +1,163 @@
+import { groupResults } from "../utils/groupProjects";
+export class HTMLGenerator {
+    constructor(ortoniConfig, dbManager) {
+        this.ortoniConfig = ortoniConfig;
+        this.dbManager = dbManager; // may be undefined in CI or when saveHistory=false
+    }
+    async generateFinalReport(filteredResults, totalDuration, results, projectSet) {
+        const data = await this.prepareReportData(filteredResults, totalDuration, results, projectSet);
+        return data;
+    }
+    /**
+     * Return safe analytics/report data.
+     * If no dbManager is provided, return empty defaults and a note explaining why.
+     */
+    async getReportData() {
+        if (!this.dbManager) {
+            return {
+                summary: {},
+                trends: {},
+                flakyTests: [],
+                slowTests: [],
+                note: "Test history/trends are unavailable (saveHistory disabled or DB not initialized).",
+            };
+        }
+        try {
+            const [summary, trends, flakyTests, slowTests] = await Promise.all([
+                this.dbManager.getSummaryData
+                    ? this.dbManager.getSummaryData()
+                    : Promise.resolve({}),
+                this.dbManager.getTrends
+                    ? this.dbManager.getTrends()
+                    : Promise.resolve({}),
+                this.dbManager.getFlakyTests
+                    ? this.dbManager.getFlakyTests()
+                    : Promise.resolve([]),
+                this.dbManager.getSlowTests
+                    ? this.dbManager.getSlowTests()
+                    : Promise.resolve([]),
+            ]);
+            return {
+                summary: summary ?? {},
+                trends: trends ?? {},
+                flakyTests: flakyTests ?? [],
+                slowTests: slowTests ?? [],
+            };
+        }
+        catch (err) {
+            console.warn("HTMLGenerator: failed to read analytics from DB, continuing without history.", err);
+            return {
+                summary: {},
+                trends: {},
+                flakyTests: [],
+                slowTests: [],
+                note: "Test history/trends could not be loaded due to a DB error.",
+            };
+        }
+    }
+    async prepareReportData(filteredResults, totalDuration, results, projectSet) {
+        const totalTests = filteredResults.length;
+        const passedTests = results.filter((r) => r.status === "passed").length;
+        const flakyTests = results.filter((r) => r.status === "flaky").length;
+        const failed = filteredResults.filter((r) => r.status === "failed" || r.status === "timedOut").length;
+        const successRate = totalTests === 0
+            ? "0.00"
+            : (((passedTests + flakyTests) / totalTests) * 100).toFixed(2);
+        const allTags = new Set();
+        results.forEach((result) => (result.testTags || []).forEach((tag) => allTags.add(tag)));
+        const projectResults = this.calculateProjectResults(filteredResults, results, projectSet);
+        const lastRunDate = new Date().toLocaleString();
+        // Fetch per-test histories only if DB manager exists; otherwise return empty history arrays.
+        const testHistories = await Promise.all(results.map(async (result) => {
+            const testId = `${result.filePath}:${result.projectName}:${result.title}`;
+            if (!this.dbManager || !this.dbManager.getTestHistory) {
+                return {
+                    testId,
+                    history: [],
+                };
+            }
+            try {
+                const history = await this.dbManager.getTestHistory(testId);
+                return {
+                    testId,
+                    history: history ?? [],
+                };
+            }
+            catch (err) {
+                // If a single test history fails, return empty history for that test and continue
+                console.warn(`HTMLGenerator: failed to read history for ${testId}`, err);
+                return {
+                    testId,
+                    history: [],
+                };
+            }
+        }));
+        // Fetch analytics/reportData using the safe getter (this will handle missing DB)
+        const reportData = await this.getReportData();
+        return {
+            summary: {
+                overAllResult: {
+                    pass: passedTests,
+                    fail: failed,
+                    skip: results.filter((r) => r.status === "skipped").length,
+                    retry: results.filter((r) => r.retryAttemptCount).length,
+                    flaky: flakyTests,
+                    total: filteredResults.length,
+                },
+                successRate,
+                lastRunDate,
+                totalDuration,
+                stats: this.extractProjectStats(projectResults),
+            },
+            testResult: {
+                tests: groupResults(this.ortoniConfig, results),
+                testHistories,
+                allTags: Array.from(allTags),
+                set: projectSet,
+            },
+            userConfig: {
+                projectName: this.ortoniConfig.projectName,
+                authorName: this.ortoniConfig.authorName,
+                type: this.ortoniConfig.testType,
+                title: this.ortoniConfig.title,
+            },
+            userMeta: {
+                meta: this.ortoniConfig.meta,
+            },
+            preferences: {
+                logo: this.ortoniConfig.logo || undefined,
+                showProject: this.ortoniConfig.showProject || false,
+            },
+            analytics: {
+                reportData: reportData,
+            },
+        };
+    }
+    calculateProjectResults(filteredResults, results, projectSet) {
+        return Array.from(projectSet).map((projectName) => {
+            const projectTests = filteredResults.filter((r) => r.projectName === projectName);
+            const allProjectTests = results.filter((r) => r.projectName === projectName);
+            return {
+                projectName,
+                passedTests: projectTests.filter((r) => r.status === "passed").length,
+                failedTests: projectTests.filter((r) => r.status === "failed" || r.status === "timedOut").length,
+                skippedTests: allProjectTests.filter((r) => r.status === "skipped")
+                    .length,
+                retryTests: allProjectTests.filter((r) => r.retryAttemptCount).length,
+                flakyTests: allProjectTests.filter((r) => r.status === "flaky").length,
+                totalTests: projectTests.length,
+            };
+        });
+    }
+    extractProjectStats(projectResults) {
+        return {
+            projectNames: projectResults.map((result) => result.projectName),
+            totalTests: projectResults.map((result) => result.totalTests),
+            passedTests: projectResults.map((result) => result.passedTests),
+            failedTests: projectResults.map((result) => result.failedTests),
+            skippedTests: projectResults.map((result) => result.skippedTests),
+            retryTests: projectResults.map((result) => result.retryTests),
+            flakyTests: projectResults.map((result) => result.flakyTests),
+        };
+    }
+}

package/dist/helpers/databaseManager.d.ts

@@ -0,0 +1,35 @@
+import { TestResultData } from "../types/testResults";
+export declare class DatabaseManager {
+    private db;
+    initialize(dbPath: string): Promise<void>;
+    private createTables;
+    private createIndexes;
+    saveTestRun(): Promise<number | null>;
+    saveTestResults(runId: number, results: TestResultData[]): Promise<void>;
+    getTestHistory(testId: string, limit?: number): Promise<any[]>;
+    close(): Promise<void>;
+    getSummaryData(): Promise<{
+        totalRuns: number;
+        totalTests: number;
+        passed: number;
+        failed: number;
+        passRate: number;
+        avgDuration: number;
+    }>;
+    getTrends(limit?: number): Promise<{
+        run_date: string;
+        passed: number;
+        failed: number;
+        avg_duration: number;
+    }[]>;
+    getFlakyTests(limit?: number): Promise<{
+        test_id: string;
+        total: number;
+        flaky: number;
+        avg_duration: number;
+    }[]>;
+    getSlowTests(limit?: number): Promise<{
+        test_id: string;
+        avg_duration: number;
+    }[]>;
+}