diff --git a/README.md b/README.md
index 8a80fac30..eb4bd9deb 100644
--- a/README.md
+++ b/README.md
@@ -233,49 +233,62 @@ Scenario('test title', () => {
})
```
-## HTML Reporter
+## HTML Reports
-CodeceptJS includes a powerful built-in HTML Reporter that generates comprehensive, interactive test reports with detailed information about your test runs. The HTML reporter is **enabled by default** for all new projects and provides:
+Generate beautiful HTML reports using **[@testomatio/reporter](https://github.com/testomatio/reporter)** package.
-### Features
-
-- **Interactive Dashboard**: Visual statistics, pie charts, and expandable test details
-- **Step-by-Step Execution**: Shows individual test steps with timing and status indicators
-- **BDD/Gherkin Support**: Full support for feature files with proper scenario formatting
-- **System Information**: Comprehensive environment details including browser versions
-- **Advanced Filtering**: Real-time filtering by status, tags, features, and test types
-- **History Tracking**: Multi-run history with trend visualization
-- **Error Details**: Clean formatting of error messages and stack traces
-- **Artifacts Support**: Display screenshots and other test artifacts
+### Installation
-### Visual Examples
+```sh
+npm install @testomatio/reporter --save-dev
+```
-#### Interactive Test Dashboard
+### Configuration
-The main dashboard provides a complete overview with interactive statistics and pie charts:
+Add the `testomatio` plugin to your `codecept.conf.js`:
-
+```js
+plugins: {
+ testomatio: {
+ enabled: true,
+ require: '@testomatio/reporter/lib/adapter/codecept',
+ },
+}
+```
-#### Detailed Test Results
+### Usage
-Each test shows comprehensive execution details with expandable step information:
+Generate HTML reports by setting the `TESTOMATIO_HTML_REPORT_SAVE` environment variable:
-
+```sh
+TESTOMATIO_HTML_REPORT_SAVE=1 npx codeceptjs run
+```
-#### Advanced Filtering Capabilities
+The report will be saved to `html-report/testomatio-report.html`.
-Real-time filtering allows quick navigation through test results:
+### Features
-
+- Modern, responsive interface with real-time statistics
+- Detailed test information with step-by-step breakdown
+- Screenshots, videos, and artifacts display
+- BDD/Gherkin support with proper scenario formatting
+- Customizable output location and filename
+- Optional integration with [Testomat.io](https://testomat.io) cloud
-#### BDD/Gherkin Support
+### Customization
-Full support for Gherkin scenarios with proper feature formatting:
+```sh
+# Custom output folder
+TESTOMATIO_HTML_REPORT_SAVE=1 TESTOMATIO_HTML_REPORT_FOLDER=./reports npx codeceptjs run
-
+# Custom filename
+TESTOMATIO_HTML_REPORT_SAVE=1 TESTOMATIO_HTML_FILENAME=my-report.html npx codeceptjs run
-The HTML reporter generates self-contained reports that can be easily shared with your team. Learn more about configuration and features in the [HTML Reporter documentation](https://codecept.io/plugins/#htmlreporter).
+# Integrate with Testomat.io cloud
+TESTOMATIO_HTML_REPORT_SAVE=1 TESTOMATIO=your_api_key npx codeceptjs run
+```
+Learn more in the [Testomat.io Reporter documentation](https://docs.testomat.io/test-reporting/pipes/html/).
## PageObjects
CodeceptJS provides the most simple way to create and use page objects in your test.
diff --git a/docs/plugins.md b/docs/plugins.md
index 1a279cd37..d79ba0dfa 100644
--- a/docs/plugins.md
+++ b/docs/plugins.md
@@ -523,44 +523,6 @@ More config options are available:
* `config` (optional, default `{}`)
-## htmlReporter
-
-HTML Reporter Plugin for CodeceptJS
-
-Generates comprehensive HTML reports showing:
-
-* Test statistics
-* Feature/Scenario details
-* Individual step results
-* Test artifacts (screenshots, etc.)
-
-## Configuration
-
-```js
-"plugins": {
- "htmlReporter": {
- "enabled": true,
- "output": "./output",
- "reportFileName": "report.html",
- "includeArtifacts": true,
- "showSteps": true,
- "showSkipped": true,
- "showMetadata": true,
- "showTags": true,
- "showRetries": true,
- "exportStats": false,
- "exportStatsPath": "./stats.json",
- "keepHistory": false,
- "historyPath": "./test-history.json",
- "maxHistoryEntries": 50
- }
-}
-```
-
-### Parameters
-
-* `config`
-
## pageInfo
Collects information from web page after each failed test and adds it to the test as an artifact.
diff --git a/docs/reports.md b/docs/reports.md
index 0f138fc89..54f55a17a 100644
--- a/docs/reports.md
+++ b/docs/reports.md
@@ -236,64 +236,57 @@ codeceptjs run
## Html
-### Built-in HTML Reporter
+### Testomat.io HTML Reporter
-CodeceptJS includes a built-in HTML reporter plugin that generates comprehensive HTML reports with detailed test information.
+For modern HTML reports, use **[@testomatio/reporter](https://github.com/testomatio/reporter)** package.
-#### Features
+#### Installation
-- **Interactive Test Results**: Click on tests to expand and view detailed information
-- **Step-by-Step Details**: Shows individual test steps with status indicators and timing
-- **Test Statistics**: Visual cards showing totals, passed, failed, and pending test counts
-- **Error Information**: Detailed error messages for failed tests with clean formatting
-- **Artifacts Support**: Display screenshots and other test artifacts with modal viewing
-- **Responsive Design**: Mobile-friendly layout that works on all screen sizes
-- **Professional Styling**: Modern, clean interface with color-coded status indicators
+```sh
+npm install @testomatio/reporter --save-dev
+```
#### Configuration
-Add the `htmlReporter` plugin to your `codecept.conf.js`:
+Add the `testomatio` plugin to your `codecept.conf.js`:
```js
exports.config = {
- // ... your other configuration
plugins: {
- htmlReporter: {
+ testomatio: {
enabled: true,
- output: './output', // Directory for the report
- reportFileName: 'report.html', // Name of the HTML file
- includeArtifacts: true, // Include screenshots/artifacts
- showSteps: true, // Show individual test steps
- showSkipped: true, // Show skipped tests
+ require: '@testomatio/reporter/lib/adapter/codecept',
},
},
}
```
-#### Configuration Options
-
-- `output` (optional, default: `./output`) - Directory where the HTML report will be saved
-- `reportFileName` (optional, default: `'report.html'`) - Name of the generated HTML file
-- `includeArtifacts` (optional, default: `true`) - Whether to include screenshots and other artifacts
-- `showSteps` (optional, default: `true`) - Whether to display individual test steps
-- `showSkipped` (optional, default: `true`) - Whether to include skipped tests in the report
-
#### Usage
-Run your tests normally and the HTML report will be automatically generated:
+Generate HTML reports with environment variable:
```sh
-npx codeceptjs run
+TESTOMATIO_HTML_REPORT_SAVE=1 npx codeceptjs run
```
-The report will be saved to `output/report.html` (or your configured location) and includes:
+Report is saved to `html-report/testomatio-report.html`.
+
+#### Configuration Options
+
+Customize report location:
+
+```sh
+# Custom folder
+TESTOMATIO_HTML_REPORT_SAVE=1 TESTOMATIO_HTML_REPORT_FOLDER=./reports npx codeceptjs run
+
+# Custom filename
+TESTOMATIO_HTML_REPORT_SAVE=1 TESTOMATIO_HTML_FILENAME=my-report.html npx codeceptjs run
-- Overview statistics with visual cards
-- Expandable test details showing steps and timing
-- Error messages for failed tests
-- Screenshots and artifacts (if available)
-- Interactive failures section
+# With Testomat.io cloud
+TESTOMATIO_HTML_REPORT_SAVE=1 TESTOMATIO=your_api_key npx codeceptjs run
+```
+For more details, see [documentation](https://docs.testomat.io/test-reporting/pipes/html/).
### Mochawesome
Best HTML reports could be produced with [mochawesome](https://www.npmjs.com/package/mochawesome) reporter.
diff --git a/docs/shared/html-reporter-bdd-details.png b/docs/shared/html-reporter-bdd-details.png
deleted file mode 100644
index 56db49b86..000000000
Binary files a/docs/shared/html-reporter-bdd-details.png and /dev/null differ
diff --git a/docs/shared/html-reporter-filtering.png b/docs/shared/html-reporter-filtering.png
deleted file mode 100644
index 519608324..000000000
Binary files a/docs/shared/html-reporter-filtering.png and /dev/null differ
diff --git a/docs/shared/html-reporter-main-dashboard.png b/docs/shared/html-reporter-main-dashboard.png
deleted file mode 100644
index 79bc68506..000000000
Binary files a/docs/shared/html-reporter-main-dashboard.png and /dev/null differ
diff --git a/docs/shared/html-reporter-test-details.png b/docs/shared/html-reporter-test-details.png
deleted file mode 100644
index 6227a158b..000000000
Binary files a/docs/shared/html-reporter-test-details.png and /dev/null differ
diff --git a/lib/command/init.js b/lib/command/init.js
index 882a792ad..589ec51be 100644
--- a/lib/command/init.js
+++ b/lib/command/init.js
@@ -20,9 +20,6 @@ const defaultConfig = {
helpers: {},
include: {},
plugins: {
- htmlReporter: {
- enabled: true,
- },
},
}
diff --git a/lib/plugin/htmlReporter.js b/lib/plugin/htmlReporter.js
deleted file mode 100644
index c762d8fae..000000000
--- a/lib/plugin/htmlReporter.js
+++ /dev/null
@@ -1,3648 +0,0 @@
-// @ts-nocheck
-// TypeScript: Import Node.js types for process, fs, path, etc.
-///
-
-import fs from 'fs'
-import path from 'path'
-import { mkdirp } from 'mkdirp'
-import crypto from 'crypto'
-import { threadId } from 'worker_threads'
-import { template } from '../utils.js'
-import { getMachineInfo } from '../command/info.js'
-
-import event from '../event.js'
-import output from '../output.js'
-import Codecept from '../codecept.js'
-
-const defaultConfig = {
- output: typeof global !== 'undefined' && global.output_dir ? global.output_dir : './output',
- reportFileName: 'report.html',
- includeArtifacts: true,
- showSteps: true,
- showSkipped: true,
- showMetadata: true,
- showTags: true,
- showRetries: true,
- exportStats: false,
- exportStatsPath: './stats.json',
- keepHistory: false,
- historyPath: './test-history.json',
- maxHistoryEntries: 50,
-}
-
-/**
- * HTML Reporter Plugin for CodeceptJS
- *
- * Generates comprehensive HTML reports showing:
- * - Test statistics
- * - Feature/Scenario details
- * - Individual step results
- * - Test artifacts (screenshots, etc.)
- *
- * ## Configuration
- *
- * ```js
- * "plugins": {
- * "htmlReporter": {
- * "enabled": true,
- * "output": "./output",
- * "reportFileName": "report.html",
- * "includeArtifacts": true,
- * "showSteps": true,
- * "showSkipped": true,
- * "showMetadata": true,
- * "showTags": true,
- * "showRetries": true,
- * "exportStats": false,
- * "exportStatsPath": "./stats.json",
- * "keepHistory": false,
- * "historyPath": "./test-history.json",
- * "maxHistoryEntries": 50
- * }
- * }
- * ```
- */
-export default function (config) {
- const options = { ...defaultConfig, ...config }
- /**
- * TypeScript: Explicitly type reportData arrays as any[] to avoid 'never' errors
- */
- let reportData = {
- stats: {},
- tests: [],
- failures: [],
- hooks: [],
- startTime: null,
- endTime: null,
- retries: [],
- config: options,
- }
- let currentTestSteps = []
- let currentTestHooks = []
- let currentBddSteps = [] // Track BDD/Gherkin steps
- let testRetryAttempts = new Map() // Track retry attempts per test
- let currentSuite = null // Track current suite for BDD detection
-
- // Initialize report directory
- const reportDir = options.output ? path.resolve(global.codecept_dir, options.output) : path.resolve(global.output_dir || './output')
- mkdirp.sync(reportDir)
-
- // Track overall test execution
- event.dispatcher.on(event.all.before, () => {
- reportData.startTime = new Date().toISOString()
- output.print('HTML Reporter: Starting HTML report generation...')
- })
-
- // Track test start to initialize steps and hooks collection
- event.dispatcher.on(event.test.before, test => {
- currentTestSteps = []
- currentTestHooks = []
- currentBddSteps = []
-
- // Track current suite for BDD detection
- currentSuite = test.parent
-
- // Enhanced retry detection with priority-based approach
- const testId = generateTestId(test)
-
- // Only set retry count if not already set, using priority order
- if (!testRetryAttempts.has(testId)) {
- // Method 1: Check retryNum property (most reliable)
- if (test.retryNum && test.retryNum > 0) {
- testRetryAttempts.set(testId, test.retryNum)
- output.debug(`HTML Reporter: Retry count detected (retryNum) for ${test.title}, attempts: ${test.retryNum}`)
- }
- // Method 2: Check currentRetry property
- else if (test.currentRetry && test.currentRetry > 0) {
- testRetryAttempts.set(testId, test.currentRetry)
- output.debug(`HTML Reporter: Retry count detected (currentRetry) for ${test.title}, attempts: ${test.currentRetry}`)
- }
- // Method 3: Check if this is a retried test
- else if (test.retriedTest && test.retriedTest()) {
- const originalTest = test.retriedTest()
- const originalTestId = generateTestId(originalTest)
- if (!testRetryAttempts.has(originalTestId)) {
- testRetryAttempts.set(originalTestId, 1) // Start with 1 retry
- } else {
- testRetryAttempts.set(originalTestId, testRetryAttempts.get(originalTestId) + 1)
- }
- output.debug(`HTML Reporter: Retry detected (retriedTest) for ${originalTest.title}, attempts: ${testRetryAttempts.get(originalTestId)}`)
- }
- // Method 4: Check if test has been seen before (indicating a retry)
- else if (reportData.tests.some(t => t.id === testId)) {
- testRetryAttempts.set(testId, 1) // First retry detected
- output.debug(`HTML Reporter: Retry detected (duplicate test) for ${test.title}, attempts: 1`)
- }
- }
- })
-
- // Collect step information
- event.dispatcher.on(event.step.started, step => {
- step.htmlReporterStartTime = Date.now()
- })
-
- event.dispatcher.on(event.step.finished, step => {
- if (step.htmlReporterStartTime) {
- step.htmlReporterDuration = Date.now() - step.htmlReporterStartTime
- }
-
- // Serialize args immediately to preserve them through worker serialization
- let serializedArgs = []
- if (step.args && Array.isArray(step.args)) {
- serializedArgs = step.args.map(arg => {
- try {
- // Try to convert to JSON-friendly format
- if (typeof arg === 'string') return arg
- if (typeof arg === 'number') return arg
- if (typeof arg === 'boolean') return arg
- if (arg === null || arg === undefined) return arg
- // For objects, try to serialize them
- return JSON.parse(JSON.stringify(arg))
- } catch (e) {
- // If serialization fails, convert to string
- return String(arg)
- }
- })
- }
-
- currentTestSteps.push({
- name: step.name,
- actor: step.actor,
- args: serializedArgs,
- status: step.failed ? 'failed' : 'success',
- duration: step.htmlReporterDuration || step.duration || 0,
- })
- })
-
- // Collect hook information
- event.dispatcher.on(event.hook.started, hook => {
- hook.htmlReporterStartTime = Date.now()
- })
-
- event.dispatcher.on(event.hook.finished, hook => {
- if (hook.htmlReporterStartTime) {
- hook.duration = Date.now() - hook.htmlReporterStartTime
- }
- // Enhanced hook info: include type, name, location, error, and context
- const hookInfo = {
- title: hook.title,
- type: hook.type || 'unknown', // before, after, beforeSuite, afterSuite
- status: hook.err ? 'failed' : 'passed',
- duration: hook.duration || 0,
- error: hook.err ? hook.err.message || hook.err.toString() : null,
- location: hook.file || hook.location || (hook.ctx && hook.ctx.test && hook.ctx.test.file) || null,
- context: hook.ctx
- ? {
- testTitle: hook.ctx.test?.title,
- suiteTitle: hook.ctx.test?.parent?.title,
- feature: hook.ctx.test?.parent?.feature?.name,
- }
- : null,
- }
- currentTestHooks.push(hookInfo)
- reportData.hooks.push(hookInfo)
- })
-
- // Collect BDD/Gherkin step information
- event.dispatcher.on(event.bddStep.started, step => {
- step.htmlReporterStartTime = Date.now()
- })
-
- event.dispatcher.on(event.bddStep.finished, step => {
- if (step.htmlReporterStartTime) {
- step.htmlReporterDuration = Date.now() - step.htmlReporterStartTime
- }
- currentBddSteps.push({
- keyword: step.actor || 'Given',
- text: step.name,
- status: step.failed ? 'failed' : 'success',
- duration: step.htmlReporterDuration || step.duration || 0,
- comment: step.comment,
- })
- })
-
- // Collect skipped tests
- event.dispatcher.on(event.test.skipped, test => {
- const testId = generateTestId(test)
-
- // Detect if this is a BDD/Gherkin test
- const suite = test.parent || test.suite || currentSuite
- const isBddTest = isBddGherkinTest(test, suite)
- const featureInfo = isBddTest ? getBddFeatureInfo(test, suite) : null
-
- // Extract parent/suite title
- const parentTitle = test.parent?.title || test.suite?.title || (suite && suite.title) || null
- const suiteTitle = test.suite?.title || (suite && suite.title) || null
-
- const testData = {
- ...test,
- id: testId,
- state: 'pending', // Use 'pending' as the state for skipped tests
- duration: 0,
- steps: [],
- hooks: [],
- artifacts: [],
- tags: test.tags || [],
- meta: test.meta || {},
- opts: test.opts || {},
- notes: test.notes || [],
- retryAttempts: 0,
- uid: test.uid,
- isBdd: isBddTest,
- feature: featureInfo,
- parentTitle: parentTitle,
- suiteTitle: suiteTitle,
- }
-
- reportData.tests.push(testData)
- output.debug(`HTML Reporter: Added skipped test - ${test.title}`)
- })
-
- // Collect test results
- event.dispatcher.on(event.test.finished, test => {
- const testId = generateTestId(test)
- let retryAttempts = testRetryAttempts.get(testId) || 0
-
- // Additional retry detection in test.finished event
- // Check if this test has retry indicators we might have missed
- if (retryAttempts === 0) {
- if (test.retryNum && test.retryNum > 0) {
- retryAttempts = test.retryNum
- testRetryAttempts.set(testId, retryAttempts)
- output.debug(`HTML Reporter: Late retry detection (retryNum) for ${test.title}, attempts: ${retryAttempts}`)
- } else if (test.currentRetry && test.currentRetry > 0) {
- retryAttempts = test.currentRetry
- testRetryAttempts.set(testId, retryAttempts)
- output.debug(`HTML Reporter: Late retry detection (currentRetry) for ${test.title}, attempts: ${retryAttempts}`)
- } else if (test._retries && test._retries > 0) {
- retryAttempts = test._retries
- testRetryAttempts.set(testId, retryAttempts)
- output.debug(`HTML Reporter: Late retry detection (_retries) for ${test.title}, attempts: ${retryAttempts}`)
- }
- }
-
- // Debug logging
- output.debug(`HTML Reporter: Test finished - ${test.title}, State: ${test.state}, Retries: ${retryAttempts}`)
-
- // Detect if this is a BDD/Gherkin test - use test.parent directly instead of currentSuite
- const suite = test.parent || test.suite || currentSuite
- const isBddTest = isBddGherkinTest(test, suite)
- const steps = isBddTest ? currentBddSteps : currentTestSteps
- const featureInfo = isBddTest ? getBddFeatureInfo(test, suite) : null
-
- // Check if this test already exists in reportData.tests (from a previous retry)
- const existingTestIndex = reportData.tests.findIndex(t => t.id === testId)
- const hasFailedBefore = existingTestIndex >= 0 && reportData.tests[existingTestIndex] && reportData.tests[existingTestIndex].state === 'failed'
- const currentlyFailed = test.state === 'failed'
-
- // Debug artifacts collection (but don't process them yet - screenshots may not be ready)
- output.debug(`HTML Reporter: Test ${test.title} artifacts at test.finished: ${JSON.stringify(test.artifacts)}`)
-
- // Extract parent/suite title before serialization (for worker mode)
- // This ensures the feature name is preserved when test data is JSON stringified
- const parentTitle = test.parent?.title || test.suite?.title || (suite && suite.title) || null
- const suiteTitle = test.suite?.title || (suite && suite.title) || null
-
- const testData = {
- ...test,
- id: testId,
- duration: test.duration || 0,
- steps: [...steps], // Copy the steps (BDD or regular)
- hooks: [...currentTestHooks], // Copy the hooks
- artifacts: test.artifacts || [], // Keep original artifacts for now
- tags: test.tags || [],
- meta: test.meta || {},
- opts: test.opts || {},
- notes: test.notes || [],
- retryAttempts: currentlyFailed || hasFailedBefore ? retryAttempts : 0, // Only show retries for failed tests
- uid: test.uid,
- isBdd: isBddTest,
- feature: featureInfo,
- // Store parent/suite titles as simple strings for worker mode serialization
- parentTitle: parentTitle,
- suiteTitle: suiteTitle,
- }
-
- if (existingTestIndex >= 0) {
- // Update existing test with final result (including failed state)
- if (existingTestIndex >= 0) reportData.tests[existingTestIndex] = testData
- output.debug(`HTML Reporter: Updated existing test - ${test.title}, Final state: ${test.state}`)
- } else {
- // Add new test
- reportData.tests.push(testData)
- output.debug(`HTML Reporter: Added new test - ${test.title}, State: ${test.state}`)
- }
-
- // Track retry information - only add if there were actual retries AND the test failed at some point
- const existingRetryIndex = reportData.retries.findIndex(r => r.testId === testId)
-
- // Only track retries if:
- // 1. There are retry attempts detected AND (test failed now OR failed before)
- // 2. OR there's an existing retry record (meaning it failed before)
- if ((retryAttempts > 0 && (currentlyFailed || hasFailedBefore)) || existingRetryIndex >= 0) {
- // If no retry attempts detected but we have an existing retry record, increment it
- if (retryAttempts === 0 && existingRetryIndex >= 0) {
- retryAttempts = reportData.retries[existingRetryIndex].attempts + 1
- testRetryAttempts.set(testId, retryAttempts)
- output.debug(`HTML Reporter: Incremented retry count for duplicate test ${test.title}, attempts: ${retryAttempts}`)
- }
-
- // Remove existing retry info for this test and add updated one
- reportData.retries = reportData.retries.filter(r => r.testId !== testId)
- reportData.retries.push({
- testId: testId,
- testTitle: test.title,
- attempts: retryAttempts,
- finalState: test.state,
- duration: test.duration || 0,
- })
- output.debug(`HTML Reporter: Added retry info for ${test.title}, attempts: ${retryAttempts}, state: ${test.state}`)
- }
-
- // Fallback: If this test already exists and either failed before or is failing now, it's a retry
- else if (existingTestIndex >= 0 && (hasFailedBefore || currentlyFailed)) {
- const fallbackAttempts = 1
- testRetryAttempts.set(testId, fallbackAttempts)
- reportData.retries.push({
- testId: testId,
- testTitle: test.title,
- attempts: fallbackAttempts,
- finalState: test.state,
- duration: test.duration || 0,
- })
- output.debug(`HTML Reporter: Fallback retry detection for failed test ${test.title}, attempts: ${fallbackAttempts}`)
- }
- })
-
- // Generate final report
- event.dispatcher.on(event.all.result, async result => {
- reportData.endTime = new Date().toISOString()
- reportData.duration = new Date(reportData.endTime).getTime() - new Date(reportData.startTime).getTime()
-
- // Process artifacts now that all async tasks (including screenshots) are complete
- output.debug(`HTML Reporter: Processing artifacts for ${reportData.tests.length} tests after all async tasks complete`)
-
- reportData.tests.forEach(test => {
- const originalArtifacts = test.artifacts
- let collectedArtifacts = []
-
- output.debug(`HTML Reporter: Processing test "${test.title}" (ID: ${test.id})`)
- output.debug(`HTML Reporter: Test ${test.title} final artifacts: ${JSON.stringify(originalArtifacts)}`)
-
- if (originalArtifacts) {
- if (Array.isArray(originalArtifacts)) {
- collectedArtifacts = originalArtifacts
- output.debug(`HTML Reporter: Using array artifacts: ${collectedArtifacts.length} items`)
- } else if (typeof originalArtifacts === 'object') {
- // Convert object properties to array (screenshotOnFail plugin format)
- collectedArtifacts = Object.values(originalArtifacts).filter(artifact => artifact)
- output.debug(`HTML Reporter: Converted artifacts object to array: ${collectedArtifacts.length} items`)
- output.debug(`HTML Reporter: Converted artifacts: ${JSON.stringify(collectedArtifacts)}`)
- }
- }
-
- // Only use filesystem fallback if no artifacts found from screenshotOnFail plugin
- if (collectedArtifacts.length === 0 && test.state === 'failed') {
- output.debug(`HTML Reporter: No artifacts from plugin, trying filesystem for test "${test.title}"`)
- collectedArtifacts = collectScreenshotsFromFilesystem(test, test.id)
- output.debug(`HTML Reporter: Collected ${collectedArtifacts.length} screenshots from filesystem for failed test "${test.title}"`)
- if (collectedArtifacts.length > 0) {
- output.debug(`HTML Reporter: Filesystem screenshots for "${test.title}": ${JSON.stringify(collectedArtifacts)}`)
- }
- }
-
- // Update test with processed artifacts
- test.artifacts = collectedArtifacts
- output.debug(`HTML Reporter: Final artifacts for "${test.title}": ${JSON.stringify(test.artifacts)}`)
- })
-
- // Calculate stats from our collected test data instead of using result.stats
- const passedTests = reportData.tests.filter(t => t.state === 'passed').length
- const failedTests = reportData.tests.filter(t => t.state === 'failed').length
- // Combine pending and skipped tests (both represent tests that were not run)
- const pendingTests = reportData.tests.filter(t => t.state === 'pending' || t.state === 'skipped').length
-
- // Calculate flaky tests (passed but had retries)
- const flakyTests = reportData.tests.filter(t => t.state === 'passed' && t.retryAttempts > 0).length
-
- // Count total artifacts
- const totalArtifacts = reportData.tests.reduce((sum, t) => sum + (t.artifacts?.length || 0), 0)
-
- // Populate failures from our collected test data with enhanced details
- reportData.failures = reportData.tests
- .filter(t => t.state === 'failed')
- .map(t => {
- const testName = t.title || 'Unknown Test'
- // Try to get feature name from BDD, preserved titles (worker mode), or direct access
- let featureName = t.feature?.name || t.parentTitle || t.suiteTitle || t.parent?.title || t.suite?.title || 'Unknown Feature'
- if (featureName === 'Unknown Feature' && t.suite && t.suite.feature && t.suite.feature.name) {
- featureName = t.suite.feature.name
- }
-
- if (t.err) {
- const errorMessage = t.err.message || t.err.toString() || 'Test failed'
- const errorStack = t.err.stack || ''
- const filePath = t.file || t.parent?.file || ''
-
- // Create enhanced failure object with test details
- return {
- testName: testName,
- featureName: featureName,
- message: errorMessage,
- stack: errorStack,
- filePath: filePath,
- toString: () => `${testName} (${featureName})\n${errorMessage}\n${errorStack}`.trim(),
- }
- }
-
- return {
- testName: testName,
- featureName: featureName,
- message: `Test failed: ${testName}`,
- stack: '',
- filePath: t.file || t.parent?.file || '',
- toString: () => `${testName} (${featureName})\nTest failed: ${testName}`,
- }
- })
-
- reportData.stats = {
- tests: reportData.tests.length,
- passes: passedTests,
- failures: failedTests,
- pending: pendingTests,
- duration: reportData.duration,
- failedHooks: result.stats?.failedHooks || 0,
- flaky: flakyTests,
- artifacts: totalArtifacts,
- }
-
- // Debug logging for final stats
- output.debug(`HTML Reporter: Calculated stats - Tests: ${reportData.stats.tests}, Passes: ${reportData.stats.passes}, Failures: ${reportData.stats.failures}`)
- output.debug(`HTML Reporter: Collected ${reportData.tests.length} tests in reportData`)
- output.debug(`HTML Reporter: Failures array has ${reportData.failures.length} items`)
- output.debug(`HTML Reporter: Retries array has ${reportData.retries.length} items`)
- output.debug(`HTML Reporter: testRetryAttempts Map size: ${testRetryAttempts.size}`)
-
- // Log retry attempts map contents
- for (const [testId, attempts] of testRetryAttempts.entries()) {
- output.debug(`HTML Reporter: testRetryAttempts - ${testId}: ${attempts} attempts`)
- }
-
- reportData.tests.forEach(test => {
- output.debug(`HTML Reporter: Test in reportData - ${test.title}, State: ${test.state}, Retries: ${test.retryAttempts}`)
- })
-
- // Check if running with workers
- if (process.env.RUNS_WITH_WORKERS) {
- // In worker mode, save results to a JSON file for later consolidation
- const workerId = threadId
- const jsonFileName = `worker-${workerId}-results.json`
- const jsonPath = path.join(reportDir, jsonFileName)
-
- try {
- // Always overwrite the file with the latest complete data from this worker
- // This prevents double-counting when the event is triggered multiple times
- fs.writeFileSync(jsonPath, safeJsonStringify(reportData))
- output.debug(`HTML Reporter: Generated worker JSON results: ${jsonFileName}`)
- } catch (error) {
- output.debug(`HTML Reporter: Failed to write worker JSON: ${error.message}`)
- }
- return
- }
-
- // Single process mode - generate report normally
- try {
- await generateHtmlReport(reportData, options)
- } catch (error) {
- output.print(`Failed to generate HTML report: ${error.message}`)
- output.debug(`HTML Reporter error stack: ${error.stack}`)
- }
-
- // Export stats if configured
- if (options.exportStats) {
- exportTestStats(reportData, options)
- }
-
- // Save history if configured
- if (options.keepHistory) {
- saveTestHistory(reportData, options)
- }
- })
-
- // Handle worker consolidation after all workers complete
- event.dispatcher.on(event.workers.result, async result => {
- if (process.env.RUNS_WITH_WORKERS) {
- // Only run consolidation in main process
- await consolidateWorkerJsonResults(options)
- }
- })
-
- /**
- * Safely serialize data to JSON, handling circular references
- */
- function safeJsonStringify(data) {
- const seen = new WeakSet()
- return JSON.stringify(
- data,
- (key, value) => {
- if (typeof value === 'object' && value !== null) {
- if (seen.has(value)) {
- // For error objects, try to extract useful information instead of "[Circular Reference]"
- if (key === 'err' || key === 'error') {
- return {
- message: value.message || 'Error occurred',
- stack: value.stack || '',
- name: value.name || 'Error',
- }
- }
- // Skip circular references for other objects
- return undefined
- }
- seen.add(value)
-
- // Special handling for error objects to preserve important properties
- if (value instanceof Error || (value.message && value.stack)) {
- return {
- message: value.message || '',
- stack: value.stack || '',
- name: value.name || 'Error',
- toString: () => value.message || 'Error occurred',
- }
- }
- }
- return value
- },
- 2,
- )
- }
-
- function generateTestId(test) {
- return crypto
- .createHash('sha256')
- .update(`${test.parent?.title || 'unknown'}_${test.title}`)
- .digest('hex')
- .substring(0, 8)
- }
-
- function collectScreenshotsFromFilesystem(test, testId) {
- const screenshots = []
-
- try {
- // Common screenshot locations to check
- const possibleDirs = [
- reportDir, // Same as report directory
- global.output_dir || './output', // Global output directory
- path.resolve(global.codecept_dir || '.', 'output'), // Codecept output directory
- path.resolve('.', 'output'), // Current directory output
- path.resolve('.', '_output'), // Alternative output directory
- path.resolve('output'), // Relative output directory
- path.resolve('qa', 'output'), // QA project output directory
- path.resolve('..', 'qa', 'output'), // Parent QA project output directory
- ]
-
- // Use the exact same logic as screenshotOnFail plugin's testToFileName function
- const originalTestName = test.title || 'test'
- const originalFeatureName = test.parent?.title || 'feature'
-
- // Replicate testToFileName logic from lib/mocha/test.js
- function replicateTestToFileName(testTitle) {
- let fileName = testTitle
-
- // Slice to 100 characters first
- fileName = fileName.slice(0, 100)
-
- // Handle data-driven tests: remove everything from '{' onwards (with 3 chars before)
- if (fileName.indexOf('{') !== -1) {
- fileName = fileName.substr(0, fileName.indexOf('{') - 3).trim()
- }
-
- // Apply clearString logic from utils.js
- if (fileName.endsWith('.')) {
- fileName = fileName.slice(0, -1)
- }
- fileName = fileName
- .replace(/ /g, '_')
- .replace(/"/g, "'")
- .replace(/\//g, '_')
- .replace(//g, ')')
- .replace(/:/g, '_')
- .replace(/\\/g, '_')
- .replace(/\|/g, '_')
- .replace(/\?/g, '.')
- .replace(/\*/g, '^')
- .replace(/'/g, '')
-
- // Final slice to 100 characters
- return fileName.slice(0, 100)
- }
-
- const testName = replicateTestToFileName(originalTestName)
- const featureName = replicateTestToFileName(originalFeatureName)
-
- output.debug(`HTML Reporter: Original test title: "${originalTestName}"`)
- output.debug(`HTML Reporter: CodeceptJS filename: "${testName}"`)
-
- // Generate possible screenshot names based on CodeceptJS patterns
- const possibleNames = [
- `${testName}.failed.png`, // Primary CodeceptJS screenshotOnFail pattern
- `${testName}.failed.jpg`,
- `${featureName}_${testName}.failed.png`,
- `${featureName}_${testName}.failed.jpg`,
- `Test_${testName}.failed.png`, // Alternative pattern
- `Test_${testName}.failed.jpg`,
- `${testName}.png`,
- `${testName}.jpg`,
- `${featureName}_${testName}.png`,
- `${featureName}_${testName}.jpg`,
- `failed_${testName}.png`,
- `failed_${testName}.jpg`,
- `screenshot_${testId}.png`,
- `screenshot_${testId}.jpg`,
- 'screenshot.png',
- 'screenshot.jpg',
- 'failure.png',
- 'failure.jpg',
- ]
-
- output.debug(`HTML Reporter: Checking ${possibleNames.length} possible screenshot names for "${testName}"`)
-
- // Search for screenshots in possible directories
- for (const dir of possibleDirs) {
- output.debug(`HTML Reporter: Checking directory: ${dir}`)
- if (!fs.existsSync(dir)) {
- output.debug(`HTML Reporter: Directory does not exist: ${dir}`)
- continue
- }
-
- try {
- const files = fs.readdirSync(dir)
- output.debug(`HTML Reporter: Found ${files.length} files in ${dir}`)
-
- // Look for exact matches first
- for (const name of possibleNames) {
- if (files.includes(name)) {
- const fullPath = path.join(dir, name)
- if (!screenshots.includes(fullPath)) {
- screenshots.push(fullPath)
- output.debug(`HTML Reporter: Found screenshot: ${fullPath}`)
- }
- }
- }
-
- // Look for screenshot files that are specifically for this test
- // Be more strict to avoid cross-test contamination
- const screenshotFiles = files.filter(file => {
- const lowerFile = file.toLowerCase()
- const lowerTestName = testName.toLowerCase()
- const lowerFeatureName = featureName.toLowerCase()
-
- return (
- file.match(/\.(png|jpg|jpeg|gif|webp|bmp)$/i) &&
- // Exact test name matches with .failed pattern (most specific)
- (file === `${testName}.failed.png` ||
- file === `${testName}.failed.jpg` ||
- file === `${featureName}_${testName}.failed.png` ||
- file === `${featureName}_${testName}.failed.jpg` ||
- file === `Test_${testName}.failed.png` ||
- file === `Test_${testName}.failed.jpg` ||
- // Word boundary checks for .failed pattern
- (lowerFile.includes('.failed.') &&
- (lowerFile.startsWith(lowerTestName + '.') || lowerFile.startsWith(lowerFeatureName + '_' + lowerTestName + '.') || lowerFile.startsWith('test_' + lowerTestName + '.'))))
- )
- })
-
- for (const file of screenshotFiles) {
- const fullPath = path.join(dir, file)
- if (!screenshots.includes(fullPath)) {
- screenshots.push(fullPath)
- output.debug(`HTML Reporter: Found related screenshot: ${fullPath}`)
- }
- }
- } catch (error) {
- // Ignore directory read errors
- output.debug(`HTML Reporter: Could not read directory ${dir}: ${error.message}`)
- }
- }
- } catch (error) {
- output.debug(`HTML Reporter: Error collecting screenshots: ${error.message}`)
- }
-
- return screenshots
- }
-
- function isBddGherkinTest(test, suite) {
- // Check if the suite has BDD/Gherkin properties
- return !!(suite && (suite.feature || suite.file?.endsWith('.feature')))
- }
-
- function getBddFeatureInfo(test, suite) {
- if (!suite) return null
-
- return {
- name: suite.feature?.name || suite.title,
- description: suite.feature?.description || suite.comment || '',
- language: suite.feature?.language || 'en',
- tags: suite.tags || [],
- file: suite.file || '',
- }
- }
-
- function exportTestStats(data, config) {
- const statsPath = path.resolve(reportDir, config.exportStatsPath)
-
- const exportData = {
- timestamp: data.endTime, // Already an ISO string
- duration: data.duration,
- stats: data.stats,
- retries: data.retries,
- testCount: data.tests.length,
- passedTests: data.tests.filter(t => t.state === 'passed').length,
- failedTests: data.tests.filter(t => t.state === 'failed').length,
- pendingTests: data.tests.filter(t => t.state === 'pending').length,
- tests: data.tests.map(test => ({
- id: test.id,
- title: test.title,
- feature: test.parent?.title || 'Unknown',
- state: test.state,
- duration: test.duration,
- tags: test.tags,
- meta: test.meta,
- retryAttempts: test.retryAttempts,
- uid: test.uid,
- })),
- }
-
- try {
- fs.writeFileSync(statsPath, JSON.stringify(exportData, null, 2))
- output.print(`Test stats exported to: ${statsPath}`)
- } catch (error) {
- output.print(`Failed to export test stats: ${error.message}`)
- }
- }
-
- function saveTestHistory(data, config) {
- const historyPath = path.resolve(reportDir, config.historyPath)
- let history = []
-
- // Load existing history
- try {
- if (fs.existsSync(historyPath)) {
- history = JSON.parse(fs.readFileSync(historyPath, 'utf8'))
- }
- } catch (error) {
- output.print(`Failed to load existing history: ${error.message}`)
- }
-
- // Add current run to history
- history.unshift({
- timestamp: data.endTime, // Already an ISO string
- duration: data.duration,
- stats: data.stats,
- retries: data.retries.length,
- testCount: data.tests.length,
- })
-
- // Limit history entries
- if (history.length > config.maxHistoryEntries) {
- history = history.slice(0, config.maxHistoryEntries)
- }
-
- try {
- fs.writeFileSync(historyPath, JSON.stringify(history, null, 2))
- output.print(`Test history saved to: ${historyPath}`)
- } catch (error) {
- output.print(`Failed to save test history: ${error.message}`)
- }
- }
-
- /**
- * Consolidates JSON reports from multiple workers into a single HTML report
- */
- async function consolidateWorkerJsonResults(config) {
- const jsonFiles = fs.readdirSync(reportDir).filter(file => file.startsWith('worker-') && file.endsWith('-results.json'))
-
- if (jsonFiles.length === 0) {
- output.debug('HTML Reporter: No worker JSON results found to consolidate')
- return
- }
-
- output.debug(`HTML Reporter: Found ${jsonFiles.length} worker JSON files to consolidate`)
-
- // Initialize consolidated data structure
- const consolidatedData = {
- stats: {
- tests: 0,
- passes: 0,
- failures: 0,
- pending: 0,
- skipped: 0,
- duration: 0,
- failedHooks: 0,
- },
- tests: [],
- failures: [],
- hooks: [],
- startTime: new Date(),
- endTime: new Date(),
- retries: [],
- duration: 0,
- }
-
- try {
- // Process each worker's JSON file
- for (const jsonFile of jsonFiles) {
- const jsonPath = path.join(reportDir, jsonFile)
- try {
- const workerData = JSON.parse(fs.readFileSync(jsonPath, 'utf8'))
-
- // Extract worker ID from filename (e.g., "worker-0-results.json" -> 0)
- const workerIdMatch = jsonFile.match(/worker-(\d+)-results\.json/)
- const workerIndex = workerIdMatch ? parseInt(workerIdMatch[1], 10) : undefined
-
- // Merge stats
- if (workerData.stats) {
- consolidatedData.stats.passes += workerData.stats.passes || 0
- consolidatedData.stats.failures += workerData.stats.failures || 0
- consolidatedData.stats.tests += workerData.stats.tests || 0
- consolidatedData.stats.pending += workerData.stats.pending || 0
- consolidatedData.stats.skipped += workerData.stats.skipped || 0
- consolidatedData.stats.duration += workerData.stats.duration || 0
- consolidatedData.stats.failedHooks += workerData.stats.failedHooks || 0
- }
-
- // Merge tests and add worker index
- if (workerData.tests) {
- const testsWithWorkerIndex = workerData.tests.map(test => ({
- ...test,
- workerIndex: workerIndex,
- }))
- consolidatedData.tests.push(...testsWithWorkerIndex)
- }
- if (workerData.failures) consolidatedData.failures.push(...workerData.failures)
- if (workerData.hooks) consolidatedData.hooks.push(...workerData.hooks)
- if (workerData.retries) consolidatedData.retries.push(...workerData.retries)
-
- // Update timestamps
- if (workerData.startTime) {
- const workerStart = new Date(workerData.startTime).getTime()
- const currentStart = new Date(consolidatedData.startTime).getTime()
- if (workerStart < currentStart) {
- consolidatedData.startTime = workerData.startTime
- }
- }
-
- if (workerData.endTime) {
- const workerEnd = new Date(workerData.endTime).getTime()
- const currentEnd = new Date(consolidatedData.endTime).getTime()
- if (workerEnd > currentEnd) {
- consolidatedData.endTime = workerData.endTime
- }
- }
-
- // Update duration
- if (workerData.duration) {
- consolidatedData.duration = Math.max(consolidatedData.duration, workerData.duration)
- }
-
- // Clean up the worker JSON file
- try {
- fs.unlinkSync(jsonPath)
- } catch (error) {
- output.print(`Failed to delete worker JSON file ${jsonFile}: ${error.message}`)
- }
- } catch (error) {
- output.print(`Failed to process worker JSON file ${jsonFile}: ${error.message}`)
- }
- }
-
- // Generate the final HTML report
- generateHtmlReport(consolidatedData, config)
-
- // Export stats if configured
- if (config.exportStats) {
- exportTestStats(consolidatedData, config)
- }
-
- // Save history if configured
- if (config.keepHistory) {
- saveTestHistory(consolidatedData, config)
- }
-
- output.debug(`HTML Reporter: Successfully consolidated ${jsonFiles.length} worker reports`)
- } catch (error) {
- output.debug(`HTML Reporter: Failed to consolidate worker reports: ${error.message}`)
- }
- }
-
- async function generateHtmlReport(data, config) {
- const reportPath = path.join(reportDir, config.reportFileName)
-
- // Load history if available
- let history = []
- if (config.keepHistory) {
- const historyPath = path.resolve(reportDir, config.historyPath)
- try {
- if (fs.existsSync(historyPath)) {
- history = JSON.parse(fs.readFileSync(historyPath, 'utf8')) // Show all available history
- }
- } catch (error) {
- output.print(`Failed to load history for report: ${error.message}`)
- }
-
- // Add current run to history for chart display (before saving to file)
- const currentRun = {
- timestamp: data.endTime, // Already an ISO string
- duration: data.duration,
- stats: data.stats,
- retries: data.retries.length,
- testCount: data.tests.length,
- }
- history.unshift(currentRun)
-
- // Limit history entries for chart display
- if (history.length > config.maxHistoryEntries) {
- history = history.slice(0, config.maxHistoryEntries)
- }
- }
-
- // Get system information
- const systemInfo = await getMachineInfo()
-
- const html = template(getHtmlTemplate(), {
- title: `CodeceptJS Test Report v${Codecept.version()}`,
- timestamp: data.endTime, // Already an ISO string
- duration: formatDuration(data.duration),
- stats: JSON.stringify(data.stats),
- history: JSON.stringify(history),
- statsHtml: generateStatsHtml(data.stats),
- testsHtml: generateTestsHtml(data.tests, config),
- retriesHtml: config.showRetries ? generateRetriesHtml(data.retries) : '',
- cssStyles: getCssStyles(),
- jsScripts: getJsScripts(),
- showRetries: config.showRetries ? 'block' : 'none',
- showHistory: config.keepHistory && history.length > 0 ? 'block' : 'none',
- codeceptVersion: Codecept.version(),
- systemInfoHtml: generateSystemInfoHtml(systemInfo),
- })
-
- fs.writeFileSync(reportPath, html)
- output.print(`HTML Report saved to: ${reportPath}`)
- }
-
- function generateStatsHtml(stats) {
- const passed = stats.passes || 0
- const failed = stats.failures || 0
- const pending = stats.pending || 0
- const total = stats.tests || 0
- const flaky = stats.flaky || 0
- const artifactCount = stats.artifacts || 0
- const passRate = total > 0 ? ((passed / total) * 100).toFixed(1) : '0.0'
- const failRate = total > 0 ? ((failed / total) * 100).toFixed(1) : '0.0'
-
- return `
-
-
-
Total
- ${total}
-
-
-
Passed
- ${passed}
-
-
-
Failed
- ${failed}
-
-
-
Skipped
- ${pending}
-
-
-
Flaky
- ${flaky}
-
-
-
Artifacts
- ${artifactCount}
-
-
- Pass Rate: ${passRate}%
- Fail Rate: ${failRate}%
-
-
-
-
-
- `
- }
-
- function generateTestsHtml(tests, config) {
- if (!tests || tests.length === 0) {
- return 'No tests found.
'
- }
-
- // Group tests by feature name
- const grouped = {}
- tests.forEach(test => {
- const feature = test.isBdd && test.feature ? test.feature.name : test.parentTitle || test.suiteTitle || test.parent?.title || test.suite?.title || 'Unknown Feature'
- if (!grouped[feature]) grouped[feature] = []
- grouped[feature].push(test)
- })
-
- // Render each feature section
- return Object.entries(grouped)
- .map(([feature, tests]) => {
- const featureId = feature.replace(/[^a-zA-Z0-9]/g, '-').toLowerCase()
- return `
-
-
- ${escapeHtml(feature)}
- ▼
-
-
- ${tests
- .map(test => {
- const statusClass = test.state || 'unknown'
- const steps = config.showSteps && test.steps ? (test.isBdd ? generateBddStepsHtml(test.steps) : generateStepsHtml(test.steps)) : ''
- const featureDetails = test.isBdd && test.feature ? generateBddFeatureHtml(test.feature) : ''
- const hooks = test.hooks && test.hooks.length > 0 ? generateHooksHtml(test.hooks) : ''
- const artifacts = config.includeArtifacts && test.artifacts ? generateArtifactsHtml(test.artifacts, test.state === 'failed') : ''
- const metadata = config.showMetadata && (test.meta || test.opts) ? generateMetadataHtml(test.meta, test.opts) : ''
- const tags = config.showTags && test.tags && test.tags.length > 0 ? generateTagsHtml(test.tags) : ''
- const retries = config.showRetries && test.retryAttempts > 0 ? generateTestRetryHtml(test.retryAttempts, test.state) : ''
- const notes = test.notes && test.notes.length > 0 ? generateNotesHtml(test.notes) : ''
-
- // Worker badge - show worker index if test has worker info
- const workerBadge = test.workerIndex !== undefined ? `
Worker ${test.workerIndex}` : ''
-
- return `
-
-
-
- ${test.err ? `
${escapeHtml(getErrorMessage(test))}` : ''}
- ${featureDetails}
- ${tags}
- ${metadata}
- ${retries}
- ${notes}
- ${hooks}
- ${steps}
- ${artifacts}
-
-
- `
- })
- .join('')}
-
- ●
- ${actor}.${stepName}(${args})
- ${formatDuration(step.duration)}
-
- `
- })
- .join('')
-
- return `
-
-
Steps:
-
${stepsHtml}
-
- ●
- ${keyword}
- ${escapeHtml(text)}
- ${formatDuration(step.duration)}
- ${comment}
-
- `
- })
- .join('')
-
- return `
-
-
Scenario Steps:
-
${stepsHtml}
-
${escapeHtml(feature.description)}
` : ''
- const featureTags = feature.tags && feature.tags.length > 0 ? `${feature.tags.map(tag => `${escapeHtml(tag)}`).join('')}
` : ''
-
- return `
-
-
Feature Information:
-
-
Feature: ${escapeHtml(feature.name)}
- ${description}
- ${featureTags}
- ${feature.file ? `
File: ${escapeHtml(feature.file)}
` : ''}
-
-
Location: ${escapeHtml(hook.location)}
` : ''
- const context = hook.context ? `Test: ${escapeHtml(hook.context.testTitle || 'N/A')}, Suite: ${escapeHtml(hook.context.suiteTitle || 'N/A')}
` : ''
-
- return `
-
-
●
-
-
${hookType}: ${hookTitle}
-
${formatDuration(hook.duration)}
- ${location}
- ${context}
- ${hook.error ? `
${escapeHtml(hook.error)}
` : ''}
-
-
-
Hooks:
-
${hooksHtml}
-
${escapeHtml(key)}: ${escapeHtml(displayValue)}
`
- })
- .join('')
-
- return `
-
- `
- }
-
- function generateTagsHtml(tags) {
- if (!tags || tags.length === 0) return ''
-
- const tagsHtml = tags.map(tag => `${escapeHtml(tag)}`).join('')
-
- return `
-
- `
- }
-
- function generateNotesHtml(notes) {
- if (!notes || notes.length === 0) return ''
-
- const notesHtml = notes.map(note => `${note.type || 'info'}: ${escapeHtml(note.text)}
`).join('')
-
- return `
-
-
Notes:
-
${notesHtml}
-
-
Retry History:
-
-
- Total retry attempts: ${retryAttempts}
- ${statusBadge}
-
-
- This test was retried ${retryAttempts} time${retryAttempts > 1 ? 's' : ''} before ${testState === 'passed' ? 'passing' : 'failing'}.
-
-
-
-
-
-
-
Screenshots:
-
${screenshotsHtml}
-
-
Screenshots:
-
${screenshotsHtml}
-
${escapeHtml(artifact.toString())}
`).join('')
-
- artifactsHtml += `
-
-
Other Artifacts:
-
${otherArtifactsHtml}
-
- ${artifactsHtml}
-
- `
- : ''
- }
-
- function generateFailuresHtml(failures) {
- if (!failures || failures.length === 0) {
- return 'No failures.
'
- }
-
- return failures
- .map((failure, index) => {
- // Helper function to safely extract string values
- const safeString = value => {
- if (!value) return ''
- if (typeof value === 'string') return value
- if (typeof value === 'object' && value.toString) {
- const str = value.toString()
- return str === '[object Object]' ? '' : str
- }
- return String(value)
- }
-
- if (typeof failure === 'object' && failure !== null) {
- // Enhanced failure object with test details
- console.log('this is failure', failure)
- const testName = safeString(failure.testName) || 'Unknown Test'
- const featureName = safeString(failure.featureName) || 'Unknown Feature'
- let message = safeString(failure.message) || 'Test failed'
- const stack = safeString(failure.stack) || ''
- const filePath = safeString(failure.filePath) || ''
-
- // If message is still "[object Object]", try to extract from the failure object itself
- if (message === '[object Object]' || message === '') {
- if (failure.err && failure.err.message) {
- message = safeString(failure.err.message)
- } else if (failure.error && failure.error.message) {
- message = safeString(failure.error.message)
- } else if (failure.toString && typeof failure.toString === 'function') {
- const str = failure.toString()
- message = str === '[object Object]' ? 'Test failed' : str
- } else {
- message = 'Test failed'
- }
- }
-
- return `
-
-
Failure ${index + 1}: ${escapeHtml(testName)}
-
-
- Error: ${escapeHtml(message)}
-
- ${stack ? `
${escapeHtml(stack.replace(/\x1b\[[0-9;]*m/g, ''))}` : ''}
-
-
Failure ${index + 1}
-
${escapeHtml(failureText)}
-
No retried tests.
'
- }
-
- return retries
- .map(
- retry => `
-
-
${retry.testTitle}
-
- Attempts: ${retry.attempts}
- Final State: ${retry.finalState}
- Duration: ${formatDuration(retry.duration)}
-
-
${key}: ${escapeHtml(value[1])}
`
- } else if (typeof value === 'string' && value !== 'N/A' && value !== 'undefined') {
- return `${key}: ${escapeHtml(value)}
`
- }
- return ''
- }
-
- const infoItems = [
- formatInfo('Node.js', systemInfo.nodeInfo),
- formatInfo('OS', systemInfo.osInfo),
- formatInfo('CPU', systemInfo.cpuInfo),
- formatInfo('Chrome', systemInfo.chromeInfo),
- formatInfo('Edge', systemInfo.edgeInfo),
- formatInfo('Firefox', systemInfo.firefoxInfo),
- formatInfo('Safari', systemInfo.safariInfo),
- formatInfo('Playwright Browsers', systemInfo.playwrightBrowsers),
- ]
- .filter(item => item)
- .join('')
-
- if (!infoItems) return ''
-
- return `
-
- `
- }
-
- function getHtmlTemplate() {
- return `
-
-
-
-
-
- {{title}}
-
-
-
-
-
-
- {{systemInfoHtml}}
-
-
- Test Statistics
- {{statsHtml}}
-
-
-
-
-
- Test Execution History
-
-
-
-
-
-
-
-
- Filters
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Test Results
-
- {{testsHtml}}
-
-
-
-
- Test Retries (Moved to Test Details)
-
-
Retry information is now shown in each test's details section.
-
-
![Enlarged screenshot]()
-
- \${index + 1}
- \${test.title.length > 60 ? test.title.substring(0, 60) + '...' : test.title}
- \${test.durationText}
-
- \`).join('');
- } else if (longestContainer) {
- longestContainer.innerHTML = 'No test data available
';
- }
-
- // Render fastest tests
- const fastestContainer = document.getElementById('fastestTests');
- if (fastestContainer && fastest.length > 0) {
- fastestContainer.innerHTML = fastest.map((test, index) => \`
-
- \${index + 1}
- \${test.title.length > 60 ? test.title.substring(0, 60) + '...' : test.title}
- \${test.durationText}
-
- \`).join('');
- } else if (fastestContainer) {
- fastestContainer.innerHTML = 'No test data available
';
- }
-}
-
-// Render history timeline
-function renderHistoryTimeline() {
- if (!window.testData || !window.testData.history || window.testData.history.length === 0) {
- return;
- }
-
- const history = window.testData.history.slice().reverse(); // Most recent last
-
- // Render stats
- const statsContainer = document.getElementById('historyStats');
- if (statsContainer) {
- const totalRuns = history.length;
- const avgDuration = history.reduce((sum, run) => sum + (run.duration || 0), 0) / totalRuns;
- const avgTests = Math.round(history.reduce((sum, run) => sum + (run.stats.tests || 0), 0) / totalRuns);
- const avgPassRate = history.reduce((sum, run) => {
- const total = run.stats.tests || 0;
- const passed = run.stats.passes || 0;
- return sum + (total > 0 ? (passed / total) * 100 : 0);
- }, 0) / totalRuns;
-
- statsContainer.innerHTML = \`
-
-
-
Total Runs
-
\${totalRuns}
-
-
-
Avg Duration
-
\${formatDuration(avgDuration)}
-
-
-
Avg Tests
-
\${avgTests}
-
-
-
Avg Pass Rate
-
\${avgPassRate.toFixed(1)}%
-
-
Recent Execution Timeline
' +
- recentHistory.map(run => {
- const timestamp = new Date(run.timestamp);
- const timeStr = timestamp.toLocaleString();
- const total = run.stats.tests || 0;
- const passed = run.stats.passes || 0;
- const failed = run.stats.failures || 0;
- const badgeClass = failed > 0 ? 'failure' : 'success';
- const badgeText = failed > 0 ? \`\${failed} Failed\` : \`All Passed\`;
-
- return \`
-
-
\${timeStr}
-
- \${badgeText}
- \${passed}/\${total} passed
- ·
- \${formatDuration(run.duration || 0)}
-
-