ortoni-report 4.0.2-beta.1 → 4.0.3

package/dist/ortoni-report.mjs

@@ -8,9 +8,9 @@ import {
   extractSuites,
   normalizeFilePath,
   startReportServer
-} from "./chunk-JEIWNUQY.mjs";
+} from "./chunk-4RZ5C7KY.mjs";
 
-// src/helpers/resultProcessor .ts
+// src/helpers/resultProcessor.ts
 import AnsiToHtml from "ansi-to-html";
 import path2 from "path";
 
@@ -1272,7 +1272,7 @@ function getFileExtension(contentType) {
   return extensions[contentType] || "unknown";
 }
 
-// src/helpers/resultProcessor .ts
+// src/helpers/resultProcessor.ts
 var TestResultProcessor = class {
   constructor(projectRoot) {
     this.ansiToHtml = new AnsiToHtml({ fg: "var(--snippet-color)" });
@@ -1317,7 +1317,7 @@ var TestResultProcessor = class {
       testId: `${filePath}:${projectName}:${title}`
     };
     attachFiles(
-      test.id,
+      path2.join(test.id, `retry-${result.retry}`),
       result,
       testResult,
       ortoniConfig,
@@ -1343,7 +1343,7 @@ var ServerManager = class {
   constructor(ortoniConfig) {
     this.ortoniConfig = ortoniConfig;
   }
-  startServer(folderPath, outputFilename, overAllStatus) {
+  async startServer(folderPath, outputFilename, overAllStatus) {
     const openOption = this.ortoniConfig.open || "never";
     const hasFailures = overAllStatus === "failed";
     if (openOption === "always" || openOption === "on-failure" && hasFailures) {
@@ -1353,6 +1353,8 @@ var ServerManager = class {
         this.ortoniConfig.port,
         openOption
       );
+      await new Promise((_resolve) => {
+      });
     }
   }
 };
@@ -1391,7 +1393,7 @@ var OrtoniReport = class {
     await this.dbManager.initialize(
       path3.join(this.folderPath, "ortoni-data-history.sqlite")
     );
-    this.config = config?.shard;
+    this.shardConfig = config?.shard;
   }
   onStdOut(chunk, _test, _result) {
     if (this.reportsCount == 1 && this.showConsoleLogs) {
@@ -1408,7 +1410,7 @@ var OrtoniReport = class {
       );
       this.results.push(testResult);
     } catch (error) {
-      console.error("OrtoniReport: Error processing test end:", error);
+      console.error("Ortoni Report: Error processing test end:", error);
     }
   }
   printsToStdio() {
@@ -1427,12 +1429,12 @@ var OrtoniReport = class {
           (r) => r.status !== "skipped"
         );
         const totalDuration = result.duration;
-        if (this.config && this.config.total > 1) {
-          const shard = this.config;
+        if (this.shardConfig && this.shardConfig.total > 1) {
+          const shard = this.shardConfig;
           const shardFile = `ortoni-shard-${shard.current}-of-${shard.total}.json`;
           const shardData = {
-            status: result.status,
-            duration: totalDuration,
+            // status: result.status,
+            totalDuration,
             results: this.results,
             projectSet: Array.from(this.projectSet),
             userConfig: {
@@ -1445,8 +1447,11 @@ var OrtoniReport = class {
               meta: this.ortoniConfig.meta
             }
           };
-          this.fileManager.writeRawFile(shardFile, shardData);
-          console.log(`\u{1F4E6} OrtoniReport wrote shard file: ${shardFile}`);
+          const shardFilePath = this.fileManager.writeRawFile(
+            shardFile,
+            shardData
+          );
+          console.info(`Ortoni Report: Shard data written to ${shardFilePath}`);
           this.shouldGenerateReport = false;
           return;
         }
@@ -1459,21 +1464,21 @@ var OrtoniReport = class {
             this.results,
             this.projectSet
           );
-          this.outputPath = this.fileManager.writeReportFile(
+          this.outputPath = await this.fileManager.writeReportFile(
             this.outputFilename,
             finalReportData
           );
         } else {
-          console.error("OrtoniReport: Error saving test run to database");
+          console.error("Ortoni Report: Error saving test run to database");
         }
       } else {
         console.error(
-          "OrtoniReport: Report generation skipped due to error in Playwright worker!"
+          "Ortoni Report: Report generation skipped due to error in Playwright worker!"
         );
       }
     } catch (error) {
       this.shouldGenerateReport = false;
-      console.error("OrtoniReport: Error generating report:", error);
+      console.error("Ortoni Report: Error generating report:", error);
     }
   }
   async onExit() {
@@ -1481,17 +1486,15 @@ var OrtoniReport = class {
       await this.dbManager.close();
       if (this.shouldGenerateReport) {
         this.fileManager.copyTraceViewerAssets(this.skipTraceViewer);
-        console.info(`Ortoni HTML report generated at ${this.outputPath}`);
-        this.serverManager.startServer(
+        console.info(`Ortoni Report generated at ${this.outputPath}`);
+        await this.serverManager.startServer(
           this.folderPath,
           this.outputFilename,
           this.overAllStatus
         );
-        await new Promise((_resolve) => {
-        });
       }
     } catch (error) {
-      console.error("OrtoniReport: Error in onExit:", error);
+      console.error("Ortoni Report: Error in onExit:", error);
     }
   }
 };

package/dist/{ortoni-report.d.cts → types/reporterConfig.d.ts}

@@ -1,9 +1,7 @@
-import { Reporter, FullConfig, Suite, TestCase, TestResult, TestError, FullResult } from '@playwright/test/reporter';
-
 /**
  * Configuration options for OrtoniReport.
  */
-interface OrtoniReportConfig {
+export interface OrtoniReportConfig {
     /**
      * Open the report in local host (Trace viewer is accessible only in localhost)
      * @example "always"| "never"| "on-failure";
@@ -78,34 +76,11 @@ interface OrtoniReportConfig {
      * @example { "key": "value" } as string
      */
     meta?: Record<string, string>;
+    /**
+     * Save the history of the reports in a SQL file to be used in future reports.
+     * The history file will be saved in the report folder.
+     * @default true
+     * @example false (to disable)
+     */
+    saveHistory?: boolean;
 }
-
-declare class OrtoniReport implements Reporter {
-    private ortoniConfig;
-    private testResultProcessor;
-    private htmlGenerator;
-    private fileManager;
-    private serverManager;
-    private results;
-    private projectSet;
-    private overAllStatus;
-    private folderPath;
-    private outputFilename;
-    private outputPath;
-    private dbManager;
-    private shouldGenerateReport;
-    private showConsoleLogs;
-    private skipTraceViewer;
-    private config;
-    constructor(ortoniConfig?: OrtoniReportConfig);
-    private reportsCount;
-    onBegin(config: FullConfig, _suite: Suite): Promise<void>;
-    onStdOut(chunk: string | Buffer, _test: void | TestCase, _result: void | TestResult): void;
-    onTestEnd(test: TestCase, result: TestResult): void;
-    printsToStdio(): boolean;
-    onError(error: TestError): void;
-    onEnd(result: FullResult): Promise<void>;
-    onExit(): Promise<void>;
-}
-
-export { OrtoniReport, type OrtoniReportConfig, OrtoniReport as default };

package/dist/types/reporterConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/types/testResults.d.ts

@@ -0,0 +1,31 @@
+export interface Steps {
+    snippet: string | undefined;
+    title: string;
+    location: string;
+}
+export interface TestResultData {
+    suiteHierarchy: string;
+    key: string;
+    annotations: any[];
+    testTags: string[];
+    location: string;
+    retryAttemptCount: number;
+    projectName: any;
+    suite: any;
+    title: string;
+    status: "passed" | "failed" | "timedOut" | "skipped" | "interrupted" | "expected" | "unexpected" | "flaky";
+    flaky: string;
+    duration: number;
+    errors: any[];
+    steps: Steps[];
+    logs: string;
+    screenshotPath?: string | null | undefined;
+    screenshots?: string[];
+    filePath: string;
+    filters: Set<string>;
+    tracePath?: string;
+    videoPath?: string[];
+    markdownPath?: string;
+    base64Image: boolean | undefined;
+    testId: string;
+}

package/dist/types/testResults.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/attachFiles.d.ts

@@ -0,0 +1,4 @@
+import { TestResult } from "@playwright/test/reporter";
+import { Steps, TestResultData } from "../types/testResults";
+import { OrtoniReportConfig } from "../types/reporterConfig";
+export declare function attachFiles(subFolder: string, result: TestResult, testResult: TestResultData, config: OrtoniReportConfig, steps?: Steps[], errors?: string[]): void;

package/dist/utils/attachFiles.js

@@ -0,0 +1,87 @@
+import path from "path";
+import fs from "fs";
+import { convertMarkdownToHtml } from "../helpers/markdownConverter";
+export function attachFiles(subFolder, result, testResult, config, steps, errors) {
+    const folderPath = config.folderPath || "ortoni-report";
+    const attachmentsFolder = path.join(folderPath, "ortoni-data", "attachments", subFolder);
+    if (!fs.existsSync(attachmentsFolder)) {
+        fs.mkdirSync(attachmentsFolder, { recursive: true });
+    }
+    if (!result.attachments)
+        return;
+    const { base64Image } = config;
+    testResult.screenshots = [];
+    testResult.videoPath = [];
+    result.attachments.forEach((attachment) => {
+        const { contentType, name, path: attachmentPath, body } = attachment;
+        if (!attachmentPath && !body)
+            return;
+        const fileName = attachmentPath
+            ? path.basename(attachmentPath)
+            : `${name}.${getFileExtension(contentType)}`;
+        const relativePath = path.join("ortoni-data", "attachments", subFolder, fileName);
+        const fullPath = path.join(attachmentsFolder, fileName);
+        if (contentType === "image/png") {
+            handleImage(attachmentPath, body, base64Image, fullPath, relativePath, testResult);
+        }
+        else if (name === "video") {
+            handleAttachment(attachmentPath, fullPath, relativePath, "videoPath", testResult);
+        }
+        else if (name === "trace") {
+            handleAttachment(attachmentPath, fullPath, relativePath, "tracePath", testResult);
+        }
+        else if (name === "error-context") {
+            handleAttachment(attachmentPath, fullPath, relativePath, "markdownPath", testResult, steps, errors);
+        }
+    });
+}
+function handleImage(attachmentPath, body, base64Image, fullPath, relativePath, testResult) {
+    let screenshotPath = "";
+    if (attachmentPath) {
+        try {
+            const screenshotContent = fs.readFileSync(attachmentPath, base64Image ? "base64" : undefined);
+            screenshotPath = base64Image
+                ? `data:image/png;base64,${screenshotContent}`
+                : relativePath;
+            if (!base64Image) {
+                fs.copyFileSync(attachmentPath, fullPath);
+            }
+        }
+        catch (error) {
+            console.error(`OrtoniReport: Failed to read screenshot file: ${attachmentPath}`, error);
+        }
+    }
+    else if (body) {
+        screenshotPath = `data:image/png;base64,${body.toString("base64")}`;
+    }
+    if (screenshotPath) {
+        testResult.screenshots?.push(screenshotPath);
+    }
+}
+function handleAttachment(attachmentPath, fullPath, relativePath, resultKey, testResult, steps, errors) {
+    if (attachmentPath) {
+        fs.copyFileSync(attachmentPath, fullPath);
+        if (resultKey === "videoPath") {
+            testResult[resultKey]?.push(relativePath);
+        }
+        else if (resultKey === "tracePath") {
+            testResult[resultKey] = relativePath;
+        }
+    }
+    if (resultKey === "markdownPath" && errors) {
+        const htmlPath = fullPath.replace(/\.md$/, ".html");
+        const htmlRelativePath = relativePath.replace(/\.md$/, ".html");
+        convertMarkdownToHtml(fullPath, htmlPath);
+        testResult[resultKey] = htmlRelativePath;
+        return;
+    }
+}
+function getFileExtension(contentType) {
+    const extensions = {
+        "image/png": "png",
+        "video/webm": "webm",
+        "application/zip": "zip",
+        "text/markdown": "md",
+    };
+    return extensions[contentType] || "unknown";
+}

package/dist/utils/expressServer.d.ts

@@ -0,0 +1 @@
+export declare function startReportServer(reportFolder: string, reportFilename: string, port: number, open: string | undefined): void;

package/dist/utils/expressServer.js

@@ -0,0 +1,61 @@
+import express from "express";
+import path from "path";
+import { spawn } from "child_process";
+export function startReportServer(reportFolder, reportFilename, port = 2004, open) {
+    const app = express();
+    app.use(express.static(reportFolder, { index: false }));
+    app.get("/", (_req, res) => {
+        try {
+            res.sendFile(path.resolve(reportFolder, reportFilename));
+        }
+        catch (error) {
+            console.error("Ortoni Report: Error sending report file:", error);
+            res.status(500).send("Error loading report");
+        }
+    });
+    try {
+        const server = app.listen(port, () => {
+            console.log(`Server is running at http://localhost:${port} \nPress Ctrl+C to stop.`);
+            if (open === "always" || open === "on-failure") {
+                try {
+                    openBrowser(`http://localhost:${port}`);
+                }
+                catch (error) {
+                    console.error("Ortoni Report: Error opening browser:", error);
+                }
+            }
+        });
+        server.on("error", (error) => {
+            if (error.code === "EADDRINUSE") {
+                console.error(`Ortoni Report: Port ${port} is already in use. Trying a different port...`);
+            }
+            else {
+                console.error("Ortoni Report: Server error:", error);
+            }
+        });
+    }
+    catch (error) {
+        console.error("Ortoni Report: Error starting the server:", error);
+    }
+}
+function openBrowser(url) {
+    const platform = process.platform;
+    let command;
+    try {
+        if (platform === "win32") {
+            command = "cmd";
+            spawn(command, ["/c", "start", url]);
+        }
+        else if (platform === "darwin") {
+            command = "open";
+            spawn(command, [url]);
+        }
+        else {
+            command = "xdg-open";
+            spawn(command, [url]);
+        }
+    }
+    catch (error) {
+        console.error("Ortoni Report: Error opening the browser:", error);
+    }
+}

package/dist/utils/groupProjects.d.ts

@@ -0,0 +1,3 @@
+import { OrtoniReportConfig } from "../types/reporterConfig";
+import { TestResultData } from "../types/testResults";
+export declare function groupResults(config: OrtoniReportConfig, results: TestResultData[]): any;

package/dist/utils/groupProjects.js

@@ -0,0 +1,30 @@
+export function groupResults(config, results) {
+    if (config.showProject) {
+        // Group by filePath, suite, and projectName
+        const groupedResults = results.reduce((acc, result, index) => {
+            const testId = `${result.filePath}:${result.projectName}:${result.title}`;
+            const key = `${testId}-${result.key}-${result.retryAttemptCount}`;
+            const { filePath, suite, projectName } = result;
+            acc[filePath] = acc[filePath] || {};
+            acc[filePath][suite] = acc[filePath][suite] || {};
+            acc[filePath][suite][projectName] =
+                acc[filePath][suite][projectName] || [];
+            acc[filePath][suite][projectName].push({ ...result, index, testId, key });
+            return acc;
+        }, {});
+        return groupedResults;
+    }
+    else {
+        // Group by filePath and suite, ignoring projectName
+        const groupedResults = results.reduce((acc, result, index) => {
+            const testId = `${result.filePath}:${result.projectName}:${result.title}`;
+            const key = `${testId}-${result.key}-${result.retryAttemptCount}`;
+            const { filePath, suite } = result;
+            acc[filePath] = acc[filePath] || {};
+            acc[filePath][suite] = acc[filePath][suite] || [];
+            acc[filePath][suite].push({ ...result, index, testId, key });
+            return acc;
+        }, {});
+        return groupedResults;
+    }
+}

package/dist/utils/utils.d.ts

@@ -0,0 +1,15 @@
+export declare function normalizeFilePath(filePath: string): string;
+export declare function formatDate(date: Date): string;
+export declare function safeStringify(obj: any, indent?: number): string;
+export declare function ensureHtmlExtension(filename: string): string;
+export declare function escapeHtml(unsafe: string): string;
+export declare function formatDateUTC(date: Date): string;
+export declare function formatDateLocal(dateInput: Date | string): string;
+export declare function formatDateNoTimezone(isoString: string): string;
+type SuiteAndTitle = {
+    hierarchy: string;
+    topLevelSuite: string;
+    parentSuite: string;
+};
+export declare function extractSuites(titlePath: string[]): SuiteAndTitle;
+export {};

package/dist/utils/utils.js

@@ -0,0 +1,84 @@
+import path from "path";
+export function normalizeFilePath(filePath) {
+    // Normalize the path to handle different separators
+    const normalizedPath = path.normalize(filePath);
+    // Get the base name of the file (removes any leading directories)
+    return path.basename(normalizedPath);
+}
+export function formatDate(date) {
+    const day = String(date.getDate()).padStart(2, "0");
+    const month = date.toLocaleString("default", { month: "short" });
+    const year = date.getFullYear();
+    const time = date.toLocaleTimeString();
+    return `${day}-${month}-${year} ${time}`;
+}
+export function safeStringify(obj, indent = 2) {
+    const cache = new Set();
+    const json = JSON.stringify(obj, (key, value) => {
+        if (typeof value === "object" && value !== null) {
+            if (cache.has(value)) {
+                return;
+            }
+            cache.add(value);
+        }
+        return value;
+    }, indent);
+    cache.clear();
+    return json;
+}
+export function ensureHtmlExtension(filename) {
+    const ext = path.extname(filename);
+    if (ext && ext.toLowerCase() === ".html") {
+        return filename;
+    }
+    return `${filename}.html`;
+}
+export function escapeHtml(unsafe) {
+    if (typeof unsafe !== "string") {
+        return String(unsafe);
+    }
+    return unsafe.replace(/[&<"']/g, function (match) {
+        const escapeMap = {
+            "&": "&amp;",
+            "<": "&lt;",
+            ">": "&gt;",
+            '"': "&quot;",
+            "'": "&#039;",
+        };
+        return escapeMap[match] || match;
+    });
+}
+export function formatDateUTC(date) {
+    return date.toISOString();
+}
+export 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(undefined, options).format(date);
+}
+export function formatDateNoTimezone(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleString("en-US", {
+        dateStyle: "medium",
+        timeStyle: "short",
+    });
+}
+export function extractSuites(titlePath) {
+    const tagPattern = /@[\w]+/g;
+    const suiteParts = titlePath
+        .slice(3, titlePath.length - 1)
+        .map((p) => p.replace(tagPattern, "").trim());
+    return {
+        hierarchy: suiteParts.join(" > "),
+        topLevelSuite: suiteParts[0] ?? "",
+        parentSuite: suiteParts[suiteParts.length - 1] ?? "", // last suite
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ortoni-report",
-  "version": "4.0.2-beta.1",
+  "version": "4.0.3",
   "description": "Playwright Report By LetCode with Koushik",
   "scripts": {
     "tsc": "tsc",
@@ -8,10 +8,11 @@
     "release": "npm publish"
   },
   "bin": {
-    "ortoni-report": "./dist/cli/cli.js"
+    "ortoni-report": "./dist/cli.js"
   },
   "files": [
-    "dist",
+    "dist/",
+    "dist/index.html",
     "README.md",
     "CHANGELOG.md"
   ],
@@ -52,5 +53,11 @@
   },
   "main": "dist/ortoni-report.js",
   "module": "dist/ortoni-report.mjs",
-  "types": "dist/ortoni-report.d.ts"
+  "types": "dist/ortoni-report.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/ortoni-report.js",
+      "import": "./dist/ortoni-report.mjs"
+    }
+  }
 }