ortoni-report 1.1.5 → 1.1.7

package/dist/ortoni-report.d.ts

@@ -1,13 +1,54 @@
-import { TestStep, Reporter, FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
+import { Reporter, FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
 
+/**
+ * Configuration options for OrtoniReport.
+ */
 interface OrtoniReportConfig {
+    /**
+     * The name of the project.
+     * @example "Ortoni Project"
+     */
     projectName?: string;
+    /**
+     * The name of the author.
+     * @example "John Doe"
+     */
     authorName?: string;
+    /**
+     * The type of tests being run.
+     * @example "Regression"
+     */
     testType?: string;
+    /**
+     * The preferred theme for the report.
+     * Can be either "light" or "dark".
+     * @default "System theme"
+     * @example "dark"
+     */
     preferredTheme?: 'light' | 'dark';
+    /**
+     * If true, images will be encoded in base64.
+     * @default false
+     * @example true
+     */
+    base64Image?: boolean;
+    /**
+     * The local relative or absolute path to the logo image.
+     * @example "./assets/logo.png"
+     * @example "/absolute/path/to/logo.png"
+     */
+    logo?: string;
 }
 
+interface Steps {
+    snippet: string | undefined;
+    title: string;
+    location: string;
+}
 interface TestResultData {
+    suiteTags: string[];
+    testTags: string[];
+    location: string;
     retry: string;
     isRetry: number;
     projectName: any;
@@ -17,14 +58,18 @@ interface TestResultData {
     flaky: string;
     duration: string;
     errors: any[];
-    steps: TestStep[];
+    steps: Steps[];
     logs: string;
-    screenshotPath: string | null;
-    filePath: any;
+    screenshotPath?: string | null | undefined;
+    filePath: string;
     projects: Set<string>;
+    tracePath?: string;
+    videoPath?: string;
+    base64Image: boolean | undefined;
 }
 
 declare class OrtoniReport implements Reporter {
+    private projectRoot;
     private results;
     private groupedResults;
     private suiteName;
@@ -33,6 +78,7 @@ declare class OrtoniReport implements Reporter {
     onBegin(config: FullConfig, suite: Suite): void;
     onTestBegin(test: TestCase, result: TestResult): void;
     private projectSet;
+    private tagsSet;
     onTestEnd(test: TestCase, result: TestResult): void;
     onEnd(result: FullResult): void;
     generateHTML(filteredResults: TestResultData[], totalDuration: string): string;

package/dist/ortoni-report.js

@@ -73,144 +73,175 @@ function formatDate(date) {
   const time = date.toLocaleTimeString();
   return `${day}-${month}-${year} ${time}`;
 }
+function safeStringify(obj, indent = 2) {
+  const cache = /* @__PURE__ */ 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;
+}
 
 // src/ortoni-report.ts
 var OrtoniReport = class {
   constructor(config = {}) {
+    this.projectRoot = "";
     this.results = [];
     this.projectSet = /* @__PURE__ */ new Set();
+    this.tagsSet = /* @__PURE__ */ new Set();
     this.config = config;
   }
   onBegin(config, suite) {
     this.results = [];
+    this.projectRoot = config.rootDir;
   }
   onTestBegin(test, result) {
   }
   onTestEnd(test, result) {
-    let status = result.status;
-    if (test.outcome() === "flaky") {
-      status = "flaky";
-    }
-    this.projectSet.add(test.titlePath()[1]);
-    const testResult = {
-      retry: result.retry > 0 ? "retry" : "",
-      isRetry: result.retry,
-      projectName: test.titlePath()[1],
-      suite: test.titlePath()[3],
-      title: test.title,
-      status,
-      flaky: test.outcome(),
-      duration: msToTime(result.duration),
-      errors: result.errors.map((e) => import_safe.default.strip(e.message || e.toString())),
-      steps: result.steps.map((step) => ({
-        titlePath: step.titlePath,
-        category: step.category,
-        duration: step.duration,
-        error: step.error,
-        location: step.location,
-        parent: step.parent,
-        startTime: step.startTime,
-        steps: step.steps,
-        title: step.title
-      })),
-      logs: import_safe.default.strip(result.stdout.concat(result.stderr).map((log) => log).join("\n")),
-      screenshotPath: null,
-      filePath: normalizeFilePath(test.titlePath()[2]),
-      projects: this.projectSet
-    };
-    if (result.attachments) {
-      const screenshot = result.attachments.find((attachment) => attachment.name === "screenshot");
-      if (screenshot && screenshot.path) {
-        const screenshotContent = import_fs.default.readFileSync(screenshot.path, "base64");
-        testResult.screenshotPath = screenshotContent;
+    try {
+      let status = result.status;
+      if (test.outcome() === "flaky") {
+        status = "flaky";
+      }
+      const projectName = test.titlePath()[1];
+      this.projectSet.add(projectName);
+      const location = test.location;
+      const filePath = normalizeFilePath(test.titlePath()[2]);
+      const tagPattern = /@[\w]+/g;
+      const testTags = test.title.match(tagPattern) || [];
+      const title = test.title.replace(tagPattern, "").trim();
+      const suiteTags = test.titlePath()[3].match(tagPattern) || [];
+      const suite = test.titlePath()[3].replace(tagPattern, "").trim();
+      const testResult = {
+        suiteTags,
+        testTags,
+        location: `${filePath}:${location.line}:${location.column}`,
+        retry: result.retry > 0 ? "retry" : "",
+        isRetry: result.retry,
+        projectName,
+        suite,
+        title,
+        status,
+        flaky: test.outcome(),
+        duration: msToTime(result.duration),
+        errors: result.errors.map((e) => import_safe.default.strip(e.message || e.toString())),
+        steps: result.steps.map((step) => {
+          const location2 = step.location ? `${import_path2.default.relative(this.projectRoot, step.location.file)}:${step.location.line}:${step.location.column}` : "";
+          return {
+            snippet: import_safe.default.strip(step.error?.snippet || ""),
+            title: step.title,
+            location: step.error ? location2 : ""
+          };
+        }),
+        logs: import_safe.default.strip(result.stdout.concat(result.stderr).map((log) => log).join("\n")),
+        filePath,
+        projects: this.projectSet,
+        base64Image: this.config.base64Image
+      };
+      if (result.attachments) {
+        const screenshot = result.attachments.find((attachment) => attachment.name === "screenshot");
+        if (this.config.base64Image) {
+          if (screenshot && screenshot.path) {
+            try {
+              const screenshotContent = import_fs.default.readFileSync(screenshot.path, "base64");
+              testResult.screenshotPath = `data:image/png;base64,${screenshotContent}`;
+            } catch (error) {
+              console.error(`OrtoniReport: Failed to read screenshot file: ${screenshot.path}`, error);
+            }
+          }
+        } else {
+          if (screenshot && screenshot.path) {
+            testResult.screenshotPath = import_path2.default.resolve(screenshot.path);
+          }
+        }
+        const tracePath = result.attachments.find((attachment) => attachment.name === "trace");
+        if (tracePath?.path) {
+          testResult.tracePath = import_path2.default.resolve(__dirname, tracePath.path);
+        }
+        const videoPath = result.attachments.find((attachment) => attachment.name === "video");
+        if (videoPath?.path) {
+          testResult.videoPath = import_path2.default.resolve(__dirname, videoPath.path);
+        }
       }
+      this.results.push(testResult);
+    } catch (error) {
+      console.error("OrtoniReport: Error processing test end:", error);
     }
-    this.results.push(testResult);
   }
   onEnd(result) {
-    const filteredResults = this.results.filter((r) => r.status !== "skipped" && !r.isRetry);
-    const totalDuration = msToTime(result.duration);
-    this.groupedResults = this.results.reduce((acc, result2, index) => {
-      const filePath = result2.filePath;
-      const suiteName = result2.suite;
-      const projectName = result2.projectName;
-      if (!acc[filePath]) {
-        acc[filePath] = {};
-      }
-      if (!acc[filePath][suiteName]) {
-        acc[filePath][suiteName] = {};
-      }
-      if (!acc[filePath][suiteName][projectName]) {
-        acc[filePath][suiteName][projectName] = [];
-      }
-      acc[filePath][suiteName][projectName].push({ ...result2, index });
-      return acc;
-    }, {});
-    import_handlebars.default.registerHelper("json", function(context) {
-      return safeStringify(context);
-    });
-    import_handlebars.default.registerHelper("eq", function(actualStatus, expectedStatus) {
-      return actualStatus === expectedStatus;
-    });
-    import_handlebars.default.registerHelper("or", () => {
-      var args = Array.prototype.slice.call(arguments);
-      var options = args.pop();
-      for (var i = 0; i < args.length; i++) {
-        if (args[i]) {
-          return options.fn(this);
+    try {
+      const filteredResults = this.results.filter((r) => r.status !== "skipped" && !r.isRetry);
+      const totalDuration = msToTime(result.duration);
+      this.groupedResults = this.results.reduce((acc, result2, index) => {
+        const filePath = result2.filePath;
+        const suiteName = result2.suite;
+        const projectName = result2.projectName;
+        if (!acc[filePath]) {
+          acc[filePath] = {};
         }
-      }
-      return options.inverse(this);
-    });
-    import_handlebars.default.registerHelper("gt", function(a, b) {
-      return a > b;
-    });
-    const html = this.generateHTML(filteredResults, totalDuration);
-    const outputPath = import_path2.default.resolve(process.cwd(), "ortoni-report.html");
-    import_fs.default.writeFileSync(outputPath, html);
-    console.log(`Ortoni HTML report generated at ${outputPath}`);
+        if (!acc[filePath][suiteName]) {
+          acc[filePath][suiteName] = {};
+        }
+        if (!acc[filePath][suiteName][projectName]) {
+          acc[filePath][suiteName][projectName] = [];
+        }
+        acc[filePath][suiteName][projectName].push({ ...result2, index });
+        return acc;
+      }, {});
+      import_handlebars.default.registerHelper("json", function(context) {
+        return safeStringify(context);
+      });
+      import_handlebars.default.registerHelper("eq", function(actualStatus, expectedStatus) {
+        return actualStatus === expectedStatus;
+      });
+      const html = this.generateHTML(filteredResults, totalDuration);
+      const outputPath = import_path2.default.resolve(process.cwd(), "ortoni-report.html");
+      import_fs.default.writeFileSync(outputPath, html);
+      console.log(`Ortoni HTML report generated at ${outputPath}`);
+    } catch (error) {
+      console.error("OrtoniReport: Error generating report:", error);
+    }
   }
   generateHTML(filteredResults, totalDuration) {
-    const totalTests = filteredResults.length;
-    const passedTests = this.results.filter((r) => r.status === "passed").length;
-    const flakyTests = this.results.filter((r) => r.flaky === "flaky").length;
-    const failed = filteredResults.filter((r) => r.status === "failed" || r.status === "timedOut").length;
-    const successRate = ((passedTests + flakyTests) / totalTests * 100).toFixed(2);
-    const templateSource = import_fs.default.readFileSync(import_path2.default.resolve(__dirname, "report-template.hbs"), "utf-8");
-    const template = import_handlebars.default.compile(templateSource);
-    const data = {
-      totalDuration,
-      suiteName: this.suiteName,
-      results: this.results,
-      retryCount: this.results.filter((r) => r.isRetry).length,
-      passCount: passedTests,
-      failCount: failed,
-      skipCount: this.results.filter((r) => r.status === "skipped").length,
-      flakyCount: flakyTests,
-      totalCount: filteredResults.length,
-      groupedResults: this.groupedResults,
-      projectName: this.config.projectName,
-      authorName: this.config.authorName,
-      testType: this.config.testType,
-      preferredTheme: this.config.preferredTheme,
-      successRate,
-      lastRunDate: formatDate(/* @__PURE__ */ new Date()),
-      projects: this.projectSet
-    };
-    return template(data);
+    try {
+      const totalTests = filteredResults.length;
+      const passedTests = this.results.filter((r) => r.status === "passed").length;
+      const flakyTests = this.results.filter((r) => r.flaky === "flaky").length;
+      const failed = filteredResults.filter((r) => r.status === "failed" || r.status === "timedOut").length;
+      const successRate = ((passedTests + flakyTests) / totalTests * 100).toFixed(2);
+      const templateSource = import_fs.default.readFileSync(import_path2.default.resolve(__dirname, "report-template.hbs"), "utf-8");
+      const template = import_handlebars.default.compile(templateSource);
+      const logo = this.config.logo;
+      const data = {
+        logo: logo ? import_path2.default.resolve(logo) : void 0,
+        totalDuration,
+        suiteName: this.suiteName,
+        results: this.results,
+        retryCount: this.results.filter((r) => r.isRetry).length,
+        passCount: passedTests,
+        failCount: failed,
+        skipCount: this.results.filter((r) => r.status === "skipped").length,
+        flakyCount: flakyTests,
+        totalCount: filteredResults.length,
+        groupedResults: this.groupedResults,
+        projectName: this.config.projectName,
+        authorName: this.config.authorName,
+        testType: this.config.testType,
+        preferredTheme: this.config.preferredTheme,
+        successRate,
+        lastRunDate: formatDate(/* @__PURE__ */ new Date()),
+        projects: this.projectSet
+      };
+      return template(data);
+    } catch (error) {
+      console.error("OrtoniReport:  Error generating HTML:", error);
+      return `<html><body><h1>Report generation failed</h1><pre>${error.stack}</pre></body></html>`;
+    }
   }
 };
-function safeStringify(obj, indent = 2) {
-  const cache = /* @__PURE__ */ 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;
-}