ortoni-report 4.0.2 → 4.0.3

package/changelog.md

@@ -1,5 +1,10 @@
 # Change Log:
 
+## V4.0.3
+
+- **Improvemnts/Fix:**
+  - With Retries Attachments are same for all failures #100
+
 ## V4.0.2
 
 - **Improvemnts/Fix:**

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;
+    }[]>;
+}

package/dist/helpers/databaseManager.js

@@ -0,0 +1,268 @@
+import { open } from "sqlite";
+import sqlite3 from "sqlite3";
+import { formatDateLocal } from "../utils/utils";
+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: formatDateLocal(result.run_date),
+            }));
+        }
+        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: formatDateLocal(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;
+}

package/dist/helpers/fileManager.js

@@ -0,0 +1,60 @@
+import fs from "fs";
+import path from "path";
+import { readBundledTemplate } from "./templateLoader";
+export class FileManager {
+    constructor(folderPath) {
+        this.folderPath = folderPath;
+    }
+    ensureReportDirectory() {
+        const ortoniDataFolder = path.join(this.folderPath, "ortoni-data");
+        if (!fs.existsSync(this.folderPath)) {
+            fs.mkdirSync(this.folderPath, { recursive: true });
+        }
+        else {
+            if (fs.existsSync(ortoniDataFolder)) {
+                fs.rmSync(ortoniDataFolder, { recursive: true, force: true });
+            }
+        }
+    }
+    async writeReportFile(filename, data) {
+        let html = await readBundledTemplate();
+        // let html = fs.readFileSync(templatePath, "utf-8");
+        const reportJSON = JSON.stringify({
+            data,
+        });
+        html = html.replace("__ORTONI_TEST_REPORTDATA__", reportJSON);
+        const outputPath = path.join(process.cwd(), this.folderPath, filename);
+        fs.writeFileSync(outputPath, html);
+        return outputPath;
+    }
+    writeRawFile(filename, data) {
+        const outputPath = path.join(process.cwd(), this.folderPath, filename);
+        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+        const content = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+        fs.writeFileSync(outputPath, content, "utf-8");
+        return outputPath;
+    }
+    copyTraceViewerAssets(skip) {
+        if (skip)
+            return;
+        const traceViewerFolder = path.join(require.resolve("playwright-core"), "..", "lib", "vite", "traceViewer");
+        const traceViewerTargetFolder = path.join(this.folderPath, "trace");
+        const traceViewerAssetsTargetFolder = path.join(traceViewerTargetFolder, "assets");
+        fs.mkdirSync(traceViewerAssetsTargetFolder, { recursive: true });
+        // Copy main trace viewer files
+        for (const file of fs.readdirSync(traceViewerFolder)) {
+            if (file.endsWith(".map") ||
+                file.includes("watch") ||
+                file.includes("assets"))
+                continue;
+            fs.copyFileSync(path.join(traceViewerFolder, file), path.join(traceViewerTargetFolder, file));
+        }
+        // Copy assets
+        const assetsFolder = path.join(traceViewerFolder, "assets");
+        for (const file of fs.readdirSync(assetsFolder)) {
+            if (file.endsWith(".map") || file.includes("xtermModule"))
+                continue;
+            fs.copyFileSync(path.join(assetsFolder, file), path.join(traceViewerAssetsTargetFolder, file));
+        }
+    }
+}

package/dist/helpers/markdownConverter.d.ts

@@ -0,0 +1 @@
+export declare function convertMarkdownToHtml(markdownPath: string, htmlOutputPath: string): void;

package/dist/helpers/markdownConverter.js

@@ -0,0 +1,14 @@
+import fs from "fs";
+import { marked } from "marked";
+export function convertMarkdownToHtml(markdownPath, htmlOutputPath) {
+    const hasMarkdown = fs.existsSync(markdownPath);
+    const markdownContent = hasMarkdown
+        ? fs.readFileSync(markdownPath, "utf-8")
+        : "";
+    const markdownHtml = hasMarkdown ? marked(markdownContent) : "";
+    const drawerHtml = `${markdownHtml || ""}`;
+    fs.writeFileSync(htmlOutputPath, drawerHtml.trim(), "utf-8");
+    if (hasMarkdown) {
+        fs.unlinkSync(markdownPath);
+    }
+}

package/dist/helpers/resultProcessor.d.ts

@@ -0,0 +1,10 @@
+import { TestCase, TestResult } from "@playwright/test/reporter";
+import { TestResultData } from "../types/testResults";
+import { OrtoniReportConfig } from "../types/reporterConfig";
+export declare class TestResultProcessor {
+    private ansiToHtml;
+    private projectRoot;
+    constructor(projectRoot: string);
+    processTestResult(test: TestCase, result: TestResult, projectSet: Set<string>, ortoniConfig: OrtoniReportConfig): TestResultData;
+    private processSteps;
+}