ortoni-report 4.0.2 → 4.0.4

package/dist/cli.js

@@ -34,24 +34,6 @@ var path3 = __toESM(require("path"));
 // src/helpers/databaseManager.ts
 var import_sqlite = require("sqlite");
 var import_sqlite3 = __toESM(require("sqlite3"));
-
-// src/utils/utils.ts
-function formatDateLocal(dateInput) {
-  const date = typeof dateInput === "string" ? new Date(dateInput) : dateInput;
-  const options = {
-    year: "numeric",
-    month: "short",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: true,
-    timeZoneName: "short"
-    // or "Asia/Kolkata"
-  };
-  return new Intl.DateTimeFormat(void 0, options).format(date);
-}
-
-// src/helpers/databaseManager.ts
 var DatabaseManager = class {
   constructor() {
     this.db = null;
@@ -175,7 +157,8 @@ var DatabaseManager = class {
       );
       return results.map((result) => ({
         ...result,
-        run_date: formatDateLocal(result.run_date)
+        run_date: result.run_date
+        // Return raw ISO string to avoid parsing issues in browser
       }));
     } catch (error) {
       console.error("OrtoniReport: Error getting test history:", error);
@@ -258,7 +241,8 @@ var DatabaseManager = class {
       );
       return rows.reverse().map((row) => ({
         ...row,
-        run_date: formatDateLocal(row.run_date),
+        run_date: row.run_date,
+        // Return raw ISO string for chart compatibility
         avg_duration: Math.round(row.avg_duration || 0)
         // raw ms avg
       }));
@@ -351,6 +335,28 @@ function groupResults(config, results) {
   }
 }
 
+// src/utils/utils.ts
+function formatDateLocal(dateInput) {
+  if (!dateInput) return "N/A";
+  try {
+    const date = typeof dateInput === "string" ? new Date(dateInput) : dateInput;
+    if (isNaN(date.getTime())) {
+      return "N/A";
+    }
+    const options = {
+      year: "numeric",
+      month: "short",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: true
+    };
+    return new Intl.DateTimeFormat("en-US", options).format(date);
+  } catch (e) {
+    return "N/A";
+  }
+}
+
 // src/helpers/HTMLGenerator.ts
 var HTMLGenerator = class {
   constructor(ortoniConfig, dbManager) {
@@ -424,7 +430,7 @@ var HTMLGenerator = class {
       results,
       projectSet
     );
-    const lastRunDate = (/* @__PURE__ */ new Date()).toLocaleString();
+    const lastRunDate = formatDateLocal(/* @__PURE__ */ new Date());
     const testHistories = await Promise.all(
       results.map(async (result) => {
         const testId = `${result.filePath}:${result.projectName}:${result.title}`;

package/dist/cli.mjs

@@ -4,7 +4,7 @@ import {
   FileManager,
   HTMLGenerator,
   startReportServer
-} from "./chunk-4RZ5C7KY.mjs";
+} from "./chunk-L6VOLEP2.mjs";
 
 // src/cli.ts
 import { program } from "commander";

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,164 @@
+import { groupResults } from "../utils/groupProjects";
+import { formatDateLocal } from "../utils/utils";
+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 = formatDateLocal(new Date());
+        // 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;
+    }[]>;
+}

package/dist/helpers/databaseManager.js

@@ -0,0 +1,267 @@
+import { open } from "sqlite";
+import sqlite3 from "sqlite3";
+export class DatabaseManager {
+    constructor() {
+        this.db = null;
+    }
+    async initialize(dbPath) {
+        try {
+            this.db = await open({
+                filename: dbPath,
+                driver: sqlite3.Database,
+            });
+            await this.createTables();
+            await this.createIndexes();
+        }
+        catch (error) {
+            console.error("OrtoniReport: Error initializing database:", error);
+        }
+    }
+    async createTables() {
+        if (!this.db) {
+            console.error("OrtoniReport: Database not initialized");
+            return;
+        }
+        try {
+            await this.db.exec(`
+        CREATE TABLE IF NOT EXISTS test_runs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          run_date TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS test_results (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          run_id INTEGER,
+          test_id TEXT,
+          status TEXT,
+          duration INTEGER, -- store duration as raw ms
+          error_message TEXT,
+          FOREIGN KEY (run_id) REFERENCES test_runs (id)
+        );
+      `);
+        }
+        catch (error) {
+            console.error("OrtoniReport: Error creating tables:", error);
+        }
+    }
+    async createIndexes() {
+        if (!this.db) {
+            console.error("OrtoniReport: Database not initialized");
+            return;
+        }
+        try {
+            await this.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_test_id ON test_results (test_id);
+        CREATE INDEX IF NOT EXISTS idx_run_id ON test_results (run_id);
+      `);
+        }
+        catch (error) {
+            console.error("OrtoniReport: Error creating indexes:", error);
+        }
+    }
+    async saveTestRun() {
+        if (!this.db) {
+            console.error("OrtoniReport: Database not initialized");
+            return null;
+        }
+        try {
+            const runDate = new Date().toISOString();
+            const { lastID } = await this.db.run(`
+        INSERT INTO test_runs (run_date)
+        VALUES (?)
+      `, [runDate]);
+            return lastID;
+        }
+        catch (error) {
+            console.error("OrtoniReport: Error saving test run:", error);
+            return null;
+        }
+    }
+    async saveTestResults(runId, results) {
+        if (!this.db) {
+            console.error("OrtoniReport: Database not initialized");
+            return;
+        }
+        try {
+            await this.db.exec("BEGIN TRANSACTION;");
+            const stmt = await this.db.prepare(`
+        INSERT INTO test_results (run_id, test_id, status, duration, error_message)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+            for (const result of results) {
+                await stmt.run([
+                    runId,
+                    `${result.filePath}:${result.projectName}:${result.title}`,
+                    result.status,
+                    result.duration,
+                    result.errors.join("\n"),
+                ]);
+            }
+            await stmt.finalize();
+            await this.db.exec("COMMIT;");
+        }
+        catch (error) {
+            await this.db.exec("ROLLBACK;");
+            console.error("OrtoniReport: Error saving test results:", error);
+        }
+    }
+    async getTestHistory(testId, limit = 10) {
+        if (!this.db) {
+            console.error("OrtoniReport: Database not initialized");
+            return [];
+        }
+        try {
+            const results = await this.db.all(`
+        SELECT tr.status, tr.duration, tr.error_message, trun.run_date
+        FROM test_results tr
+        JOIN test_runs trun ON tr.run_id = trun.id
+        WHERE tr.test_id = ?
+        ORDER BY trun.run_date DESC
+        LIMIT ?
+      `, [testId, limit]);
+            return results.map((result) => ({
+                ...result,
+                run_date: result.run_date, // Return raw ISO string to avoid parsing issues in browser
+            }));
+        }
+        catch (error) {
+            console.error("OrtoniReport: Error getting test history:", error);
+            return [];
+        }
+    }
+    async close() {
+        if (this.db) {
+            try {
+                await this.db.close();
+            }
+            catch (error) {
+                console.error("OrtoniReport: Error closing database:", error);
+            }
+            finally {
+                this.db = null;
+            }
+        }
+    }
+    async getSummaryData() {
+        if (!this.db) {
+            console.error("OrtoniReport: Database not initialized");
+            return {
+                totalRuns: 0,
+                totalTests: 0,
+                passed: 0,
+                failed: 0,
+                passRate: 0,
+                avgDuration: 0,
+            };
+        }
+        try {
+            const summary = await this.db.get(`
+      SELECT
+        (SELECT COUNT(*) FROM test_runs) as totalRuns,
+        (SELECT COUNT(*) FROM test_results) as totalTests,
+        (SELECT COUNT(*) FROM test_results WHERE status = 'passed') as passed,
+        (SELECT COUNT(*) FROM test_results WHERE status = 'failed') as failed,
+        (SELECT AVG(duration) FROM test_results) as avgDuration
+    `);
+            const passRate = summary.totalTests
+                ? ((summary.passed / summary.totalTests) * 100).toFixed(2)
+                : 0;
+            return {
+                totalRuns: summary.totalRuns,
+                totalTests: summary.totalTests,
+                passed: summary.passed,
+                failed: summary.failed,
+                passRate: parseFloat(passRate.toString()),
+                avgDuration: Math.round(summary.avgDuration || 0), // raw ms avg
+            };
+        }
+        catch (error) {
+            console.error("OrtoniReport: Error getting summary data:", error);
+            return {
+                totalRuns: 0,
+                totalTests: 0,
+                passed: 0,
+                failed: 0,
+                passRate: 0,
+                avgDuration: 0,
+            };
+        }
+    }
+    async getTrends(limit = 100) {
+        if (!this.db) {
+            console.error("OrtoniReport: Database not initialized");
+            return [];
+        }
+        try {
+            const rows = await this.db.all(`
+      SELECT trun.run_date,
+        SUM(CASE WHEN tr.status = 'passed' THEN 1 ELSE 0 END) AS passed,
+        SUM(CASE WHEN tr.status = 'failed' THEN 1 ELSE 0 END) AS failed,
+        AVG(tr.duration) AS avg_duration
+      FROM test_results tr
+      JOIN test_runs trun ON tr.run_id = trun.id
+      GROUP BY trun.run_date
+      ORDER BY trun.run_date DESC
+      LIMIT ?
+    `, [limit]);
+            return rows.reverse().map((row) => ({
+                ...row,
+                run_date: row.run_date,
+                avg_duration: Math.round(row.avg_duration || 0), // raw ms avg
+            }));
+        }
+        catch (error) {
+            console.error("OrtoniReport: Error getting trends data:", error);
+            return [];
+        }
+    }
+    async getFlakyTests(limit = 10) {
+        if (!this.db) {
+            console.error("OrtoniReport: Database not initialized");
+            return [];
+        }
+        try {
+            return await this.db.all(`
+      SELECT
+        test_id,
+        COUNT(*) AS total,
+        SUM(CASE WHEN status = 'flaky' THEN 1 ELSE 0 END) AS flaky,
+        AVG(duration) AS avg_duration
+      FROM test_results
+      GROUP BY test_id
+      HAVING flaky > 0
+      ORDER BY flaky DESC
+      LIMIT ?
+    `, [limit]);
+        }
+        catch (error) {
+            console.error("OrtoniReport: Error getting flaky tests:", error);
+            return [];
+        }
+    }
+    async getSlowTests(limit = 10) {
+        if (!this.db) {
+            console.error("OrtoniReport: Database not initialized");
+            return [];
+        }
+        try {
+            const rows = await this.db.all(`
+      SELECT
+        test_id,
+        AVG(duration) AS avg_duration
+      FROM test_results
+      GROUP BY test_id
+      ORDER BY avg_duration DESC
+      LIMIT ?
+    `, [limit]);
+            return rows.map((row) => ({
+                test_id: row.test_id,
+                avg_duration: Math.round(row.avg_duration || 0), // raw ms avg
+            }));
+        }
+        catch (error) {
+            console.error("OrtoniReport: Error getting slow tests:", error);
+            return [];
+        }
+    }
+}

package/dist/helpers/fileManager.d.ts

@@ -0,0 +1,8 @@
+export declare class FileManager {
+    private folderPath;
+    constructor(folderPath: string);
+    ensureReportDirectory(): void;
+    writeReportFile(filename: string, data: unknown): Promise<string>;
+    writeRawFile(filename: string, data: unknown): string;
+    copyTraceViewerAssets(skip: boolean): void;
+}