ortoni-report 4.0.2-beta.1 → 4.0.3

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

package/dist/helpers/resultProcessor.js

@@ -0,0 +1,60 @@
+import AnsiToHtml from "ansi-to-html";
+import path from "path";
+import { attachFiles } from "../utils/attachFiles";
+import { normalizeFilePath, escapeHtml, extractSuites } from "../utils/utils";
+export class TestResultProcessor {
+    constructor(projectRoot) {
+        this.ansiToHtml = new AnsiToHtml({ fg: "var(--snippet-color)" });
+        this.projectRoot = projectRoot;
+    }
+    processTestResult(test, result, projectSet, ortoniConfig) {
+        const status = test.outcome() === "flaky" ? "flaky" : result.status;
+        const projectName = test.titlePath()[1];
+        projectSet.add(projectName);
+        const location = test.location;
+        const filePath = normalizeFilePath(test.titlePath()[2]);
+        const tagPattern = /@[\w]+/g;
+        const title = test.title.replace(tagPattern, "").trim();
+        const suite = test.titlePath()[3].replace(tagPattern, "").trim();
+        const suiteAndTitle = extractSuites(test.titlePath());
+        const suiteHierarchy = suiteAndTitle.hierarchy;
+        const testResult = {
+            suiteHierarchy,
+            key: test.id,
+            annotations: test.annotations,
+            testTags: test.tags,
+            location: `${filePath}:${location.line}:${location.column}`,
+            retryAttemptCount: result.retry,
+            projectName: projectName,
+            suite,
+            title,
+            status,
+            flaky: test.outcome(),
+            duration: result.duration,
+            errors: result.errors.map((e) => this.ansiToHtml.toHtml(escapeHtml(e.stack || e.toString()))),
+            steps: this.processSteps(result.steps),
+            logs: this.ansiToHtml.toHtml(escapeHtml(result.stdout
+                .concat(result.stderr)
+                .map((log) => log)
+                .join("\n"))),
+            filePath: filePath,
+            filters: projectSet,
+            base64Image: ortoniConfig.base64Image,
+            testId: `${filePath}:${projectName}:${title}`,
+        };
+        attachFiles(path.join(test.id, `retry-${result.retry}`), result, testResult, ortoniConfig, testResult.steps, testResult.errors);
+        return testResult;
+    }
+    processSteps(steps) {
+        return steps.map((step) => {
+            const stepLocation = step.location
+                ? `${path.relative(this.projectRoot, step.location.file)}:${step.location.line}:${step.location.column}`
+                : "";
+            return {
+                snippet: this.ansiToHtml.toHtml(escapeHtml(step.error?.snippet || "")),
+                title: step.title,
+                location: step.error ? stepLocation : "",
+            };
+        });
+    }
+}

package/dist/helpers/serverManager.d.ts

@@ -0,0 +1,6 @@
+import { OrtoniReportConfig } from "../types/reporterConfig";
+export declare class ServerManager {
+    private ortoniConfig;
+    constructor(ortoniConfig: OrtoniReportConfig);
+    startServer(folderPath: string, outputFilename: string, overAllStatus: string | undefined): Promise<void>;
+}

package/dist/helpers/serverManager.js

@@ -0,0 +1,15 @@
+import { startReportServer } from "../utils/expressServer";
+export class ServerManager {
+    constructor(ortoniConfig) {
+        this.ortoniConfig = ortoniConfig;
+    }
+    async startServer(folderPath, outputFilename, overAllStatus) {
+        const openOption = this.ortoniConfig.open || "never";
+        const hasFailures = overAllStatus === "failed";
+        if (openOption === "always" ||
+            (openOption === "on-failure" && hasFailures)) {
+            startReportServer(folderPath, outputFilename, this.ortoniConfig.port, openOption);
+            await new Promise((_resolve) => { });
+        }
+    }
+}

package/dist/helpers/templateLoader.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Read the bundled index.html template.
+ *
+ * Resolution order:
+ *  1) require.resolve('<pkgName>/dist/index.html') via require (synchronous; CJS fast path)
+ *  2) createRequire(resolve) via dynamic import('module') (async ESM fallback)
+ *  3) relative to this file: ../dist/index.html (dev/run-from-repo)
+ *  4) node_modules/<pkgName>/dist/index.html from process.cwd()
+ *  5) process.cwd()/dist/index.html
+ *
+ * Returns the template string. Throws a helpful Error if not found.
+ *
+ * NOTE: This function is async because dynamic import('module') is async in ESM.
+ */
+export declare function readBundledTemplate(pkgName?: string): Promise<string>;

package/dist/helpers/templateLoader.js

@@ -0,0 +1,88 @@
+// src/helpers/templateLoader.ts
+import fs from "fs";
+import path from "path";
+/**
+ * Read the bundled index.html template.
+ *
+ * Resolution order:
+ *  1) require.resolve('<pkgName>/dist/index.html') via require (synchronous; CJS fast path)
+ *  2) createRequire(resolve) via dynamic import('module') (async ESM fallback)
+ *  3) relative to this file: ../dist/index.html (dev/run-from-repo)
+ *  4) node_modules/<pkgName>/dist/index.html from process.cwd()
+ *  5) process.cwd()/dist/index.html
+ *
+ * Returns the template string. Throws a helpful Error if not found.
+ *
+ * NOTE: This function is async because dynamic import('module') is async in ESM.
+ */
+export async function readBundledTemplate(pkgName = "ortoni-report") {
+    const packagedRel = "dist/index.html";
+    // 1) Sync CJS fast-path: if `require` exists (typical for CJS consumers)
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        if (typeof require === "function") {
+            // Use require.resolve to reliably find the file inside installed package
+            const resolved = require.resolve(`${pkgName}/${packagedRel}`);
+            if (fs.existsSync(resolved)) {
+                return fs.readFileSync(resolved, "utf-8");
+            }
+        }
+    }
+    catch {
+        // ignore and continue to async fallback
+    }
+    // 2) Async ESM-safe createRequire via dynamic import (no eval)
+    try {
+        // dynamic import of 'module' works in ESM environments
+        const moduleNS = await import("module");
+        if (moduleNS && typeof moduleNS.createRequire === "function") {
+            const createRequire = moduleNS.createRequire;
+            // createRequire needs a filename/URL; use this file (works for both ESM and CJS)
+            const req = createRequire(
+            // @ts-ignore
+            typeof __filename !== "undefined" ? __filename : import.meta.url);
+            const resolved = req.resolve(`${pkgName}/${packagedRel}`);
+            if (fs.existsSync(resolved)) {
+                return fs.readFileSync(resolved, "utf-8");
+            }
+        }
+    }
+    catch {
+        // ignore and try file fallbacks below
+    }
+    // 3) Relative to this module (useful in dev or mono-repo)
+    try {
+        const here = path.resolve(__dirname, "../dist/index.html");
+        if (fs.existsSync(here))
+            return fs.readFileSync(here, "utf-8");
+    }
+    catch {
+        // ignore
+    }
+    // 4) node_modules lookup from process.cwd()
+    try {
+        const nm = path.join(process.cwd(), "node_modules", pkgName, packagedRel);
+        if (fs.existsSync(nm))
+            return fs.readFileSync(nm, "utf-8");
+    }
+    catch {
+        // ignore
+    }
+    // 5) fallback to process.cwd()/dist/index.html
+    try {
+        const alt = path.join(process.cwd(), "dist", "index.html");
+        if (fs.existsSync(alt))
+            return fs.readFileSync(alt, "utf-8");
+    }
+    catch {
+        // ignore
+    }
+    // Helpful error for maintainers / users
+    throw new Error(`ortoni-report template not found (tried:\n` +
+        `  - require.resolve('${pkgName}/${packagedRel}')\n` +
+        `  - import('module').createRequire(...).resolve('${pkgName}/${packagedRel}')\n` +
+        `  - relative ../dist/index.html\n` +
+        `  - ${path.join(process.cwd(), "node_modules", pkgName, packagedRel)}\n` +
+        `  - ${path.join(process.cwd(), "dist", "index.html")}\n` +
+        `Ensure 'dist/index.html' is present in the published package and package.json 'files' includes 'dist/'.`);
+}