codeceptjs 3.7.6-beta.2 → 3.7.6-beta.4

package/lib/plugin/htmlReporter.js

@@ -1,3 +1,7 @@
+// @ts-nocheck
+// TypeScript: Import Node.js types for process, fs, path, etc.
+/// <reference types="node" />
+
 const fs = require('fs')
 const path = require('path')
 const mkdirp = require('mkdirp')
@@ -11,7 +15,7 @@ const output = require('../output')
 const Codecept = require('../codecept')
 
 const defaultConfig = {
-  output: global.output_dir || './output',
+  output: typeof global !== 'undefined' && global.output_dir ? global.output_dir : './output',
   reportFileName: 'report.html',
   includeArtifacts: true,
   showSteps: true,
@@ -60,6 +64,9 @@ const defaultConfig = {
  */
 module.exports = function (config) {
   const options = { ...defaultConfig, ...config }
+  /**
+   * TypeScript: Explicitly type reportData arrays as any[] to avoid 'never' errors
+   */
   let reportData = {
     stats: {},
     tests: [],
@@ -82,8 +89,8 @@ module.exports = function (config) {
 
   // Track overall test execution
   event.dispatcher.on(event.all.before, () => {
-    reportData.startTime = new Date()
-    output.plugin('htmlReporter', 'Starting HTML report generation...')
+    reportData.startTime = new Date().toISOString()
+    output.print('HTML Reporter: Starting HTML report generation...')
   })
 
   // Track test start to initialize steps and hooks collection
@@ -103,12 +110,12 @@ module.exports = function (config) {
       // Method 1: Check retryNum property (most reliable)
       if (test.retryNum && test.retryNum > 0) {
         testRetryAttempts.set(testId, test.retryNum)
-        output.print(`HTML Reporter: Retry count detected (retryNum) for ${test.title}, attempts: ${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.print(`HTML Reporter: Retry count detected (currentRetry) for ${test.title}, attempts: ${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()) {
@@ -119,12 +126,12 @@ module.exports = function (config) {
         } else {
           testRetryAttempts.set(originalTestId, testRetryAttempts.get(originalTestId) + 1)
         }
-        output.print(`HTML Reporter: Retry detected (retriedTest) for ${originalTest.title}, attempts: ${testRetryAttempts.get(originalTestId)}`)
+        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.print(`HTML Reporter: Retry detected (duplicate test) for ${test.title}, attempts: 1`)
+        output.debug(`HTML Reporter: Retry detected (duplicate test) for ${test.title}, attempts: 1`)
       }
     }
   })
@@ -138,10 +145,30 @@ module.exports = function (config) {
     if (step.htmlReporterStartTime) {
       step.duration = 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: step.args || [],
+      args: serializedArgs,
       status: step.failed ? 'failed' : 'success',
       duration: step.duration || 0,
     })
@@ -196,33 +223,39 @@ module.exports = function (config) {
       if (test.retryNum && test.retryNum > 0) {
         retryAttempts = test.retryNum
         testRetryAttempts.set(testId, retryAttempts)
-        output.print(`HTML Reporter: Late retry detection (retryNum) for ${test.title}, attempts: ${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.print(`HTML Reporter: Late retry detection (currentRetry) for ${test.title}, attempts: ${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.print(`HTML Reporter: Late retry detection (_retries) for ${test.title}, attempts: ${retryAttempts}`)
+        output.debug(`HTML Reporter: Late retry detection (_retries) for ${test.title}, attempts: ${retryAttempts}`)
       }
     }
 
     // Debug logging
-    output.print(`HTML Reporter: Test finished - ${test.title}, State: ${test.state}, Retries: ${retryAttempts}`)
+    output.debug(`HTML Reporter: Test finished - ${test.title}, State: ${test.state}, Retries: ${retryAttempts}`)
 
-    // Detect if this is a BDD/Gherkin test
-    const isBddTest = isBddGherkinTest(test, currentSuite)
+    // 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, currentSuite) : null
+    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].state === 'failed'
+    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.print(`HTML Reporter: Test ${test.title} artifacts at test.finished: ${JSON.stringify(test.artifacts)}`)
+    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,
@@ -239,16 +272,19 @@ module.exports = function (config) {
       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)
-      reportData.tests[existingTestIndex] = testData
-      output.print(`HTML Reporter: Updated existing test - ${test.title}, Final state: ${test.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.print(`HTML Reporter: Added new test - ${test.title}, State: ${test.state}`)
+      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
@@ -262,7 +298,7 @@ module.exports = function (config) {
       if (retryAttempts === 0 && existingRetryIndex >= 0) {
         retryAttempts = reportData.retries[existingRetryIndex].attempts + 1
         testRetryAttempts.set(testId, retryAttempts)
-        output.print(`HTML Reporter: Incremented retry count for duplicate test ${test.title}, attempts: ${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
@@ -274,7 +310,7 @@ module.exports = function (config) {
         finalState: test.state,
         duration: test.duration || 0,
       })
-      output.print(`HTML Reporter: Added retry info for ${test.title}, attempts: ${retryAttempts}, state: ${test.state}`)
+      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
@@ -288,50 +324,50 @@ module.exports = function (config) {
         finalState: test.state,
         duration: test.duration || 0,
       })
-      output.print(`HTML Reporter: Fallback retry detection for failed test ${test.title}, attempts: ${fallbackAttempts}`)
+      output.debug(`HTML Reporter: Fallback retry detection for failed test ${test.title}, attempts: ${fallbackAttempts}`)
     }
   })
 
   // Generate final report
-  event.dispatcher.on(event.all.result, result => {
-    reportData.endTime = new Date()
-    reportData.duration = reportData.endTime - reportData.startTime
+  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.print(`HTML Reporter: Processing artifacts for ${reportData.tests.length} tests after all async tasks 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.print(`HTML Reporter: Processing test "${test.title}" (ID: ${test.id})`)
-      output.print(`HTML Reporter: Test ${test.title} final artifacts: ${JSON.stringify(originalArtifacts)}`)
+      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.print(`HTML Reporter: Using array artifacts: ${collectedArtifacts.length} items`)
+          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.print(`HTML Reporter: Converted artifacts object to array: ${collectedArtifacts.length} items`)
-          output.print(`HTML Reporter: Converted artifacts: ${JSON.stringify(collectedArtifacts)}`)
+          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.print(`HTML Reporter: No artifacts from plugin, trying filesystem for test "${test.title}"`)
+        output.debug(`HTML Reporter: No artifacts from plugin, trying filesystem for test "${test.title}"`)
         collectedArtifacts = collectScreenshotsFromFilesystem(test, test.id)
-        output.print(`HTML Reporter: Collected ${collectedArtifacts.length} screenshots from filesystem for failed test "${test.title}"`)
+        output.debug(`HTML Reporter: Collected ${collectedArtifacts.length} screenshots from filesystem for failed test "${test.title}"`)
         if (collectedArtifacts.length > 0) {
-          output.print(`HTML Reporter: Filesystem screenshots for "${test.title}": ${JSON.stringify(collectedArtifacts)}`)
+          output.debug(`HTML Reporter: Filesystem screenshots for "${test.title}": ${JSON.stringify(collectedArtifacts)}`)
         }
       }
 
       // Update test with processed artifacts
       test.artifacts = collectedArtifacts
-      output.print(`HTML Reporter: Final artifacts for "${test.title}": ${JSON.stringify(test.artifacts)}`)
+      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
@@ -345,7 +381,11 @@ module.exports = function (config) {
       .filter(t => t.state === 'failed')
       .map(t => {
         const testName = t.title || 'Unknown Test'
-        const featureName = t.parent?.title || 'Unknown Feature'
+        // 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'
@@ -384,19 +424,19 @@ module.exports = function (config) {
     }
 
     // Debug logging for final stats
-    output.print(`HTML Reporter: Calculated stats - Tests: ${reportData.stats.tests}, Passes: ${reportData.stats.passes}, Failures: ${reportData.stats.failures}`)
-    output.print(`HTML Reporter: Collected ${reportData.tests.length} tests in reportData`)
-    output.print(`HTML Reporter: Failures array has ${reportData.failures.length} items`)
-    output.print(`HTML Reporter: Retries array has ${reportData.retries.length} items`)
-    output.print(`HTML Reporter: testRetryAttempts Map size: ${testRetryAttempts.size}`)
+    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.print(`HTML Reporter: testRetryAttempts - ${testId}: ${attempts} attempts`)
+      output.debug(`HTML Reporter: testRetryAttempts - ${testId}: ${attempts} attempts`)
     }
 
     reportData.tests.forEach(test => {
-      output.print(`HTML Reporter: Test in reportData - ${test.title}, State: ${test.state}, Retries: ${test.retryAttempts}`)
+      output.debug(`HTML Reporter: Test in reportData - ${test.title}, State: ${test.state}, Retries: ${test.retryAttempts}`)
     })
 
     // Check if running with workers
@@ -410,15 +450,20 @@ module.exports = function (config) {
         // 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.print(`HTML Reporter: Generated worker JSON results: ${jsonFileName}`)
+        output.debug(`HTML Reporter: Generated worker JSON results: ${jsonFileName}`)
       } catch (error) {
-        output.print(`HTML Reporter: Failed to write worker JSON: ${error.message}`)
+        output.debug(`HTML Reporter: Failed to write worker JSON: ${error.message}`)
       }
       return
     }
 
     // Single process mode - generate report normally
-    generateHtmlReport(reportData, options)
+    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) {
@@ -542,8 +587,8 @@ module.exports = function (config) {
       const testName = replicateTestToFileName(originalTestName)
       const featureName = replicateTestToFileName(originalFeatureName)
 
-      output.print(`HTML Reporter: Original test title: "${originalTestName}"`)
-      output.print(`HTML Reporter: CodeceptJS filename: "${testName}"`)
+      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 = [
@@ -567,19 +612,19 @@ module.exports = function (config) {
         'failure.jpg',
       ]
 
-      output.print(`HTML Reporter: Checking ${possibleNames.length} possible screenshot names for "${testName}"`)
+      output.debug(`HTML Reporter: Checking ${possibleNames.length} possible screenshot names for "${testName}"`)
 
       // Search for screenshots in possible directories
       for (const dir of possibleDirs) {
-        output.print(`HTML Reporter: Checking directory: ${dir}`)
+        output.debug(`HTML Reporter: Checking directory: ${dir}`)
         if (!fs.existsSync(dir)) {
-          output.print(`HTML Reporter: Directory does not exist: ${dir}`)
+          output.debug(`HTML Reporter: Directory does not exist: ${dir}`)
           continue
         }
 
         try {
           const files = fs.readdirSync(dir)
-          output.print(`HTML Reporter: Found ${files.length} files in ${dir}`)
+          output.debug(`HTML Reporter: Found ${files.length} files in ${dir}`)
 
           // Look for exact matches first
           for (const name of possibleNames) {
@@ -587,7 +632,7 @@ module.exports = function (config) {
               const fullPath = path.join(dir, name)
               if (!screenshots.includes(fullPath)) {
                 screenshots.push(fullPath)
-                output.print(`HTML Reporter: Found screenshot: ${fullPath}`)
+                output.debug(`HTML Reporter: Found screenshot: ${fullPath}`)
               }
             }
           }
@@ -618,16 +663,16 @@ module.exports = function (config) {
             const fullPath = path.join(dir, file)
             if (!screenshots.includes(fullPath)) {
               screenshots.push(fullPath)
-              output.print(`HTML Reporter: Found related screenshot: ${fullPath}`)
+              output.debug(`HTML Reporter: Found related screenshot: ${fullPath}`)
             }
           }
         } catch (error) {
           // Ignore directory read errors
-          output.print(`HTML Reporter: Could not read directory ${dir}: ${error.message}`)
+          output.debug(`HTML Reporter: Could not read directory ${dir}: ${error.message}`)
         }
       }
     } catch (error) {
-      output.print(`HTML Reporter: Error collecting screenshots: ${error.message}`)
+      output.debug(`HTML Reporter: Error collecting screenshots: ${error.message}`)
     }
 
     return screenshots
@@ -654,7 +699,7 @@ module.exports = function (config) {
     const statsPath = path.resolve(reportDir, config.exportStatsPath)
 
     const exportData = {
-      timestamp: data.endTime.toISOString(),
+      timestamp: data.endTime, // Already an ISO string
       duration: data.duration,
       stats: data.stats,
       retries: data.retries,
@@ -698,7 +743,7 @@ module.exports = function (config) {
 
     // Add current run to history
     history.unshift({
-      timestamp: data.endTime.toISOString(),
+      timestamp: data.endTime, // Already an ISO string
       duration: data.duration,
       stats: data.stats,
       retries: data.retries.length,
@@ -725,11 +770,11 @@ module.exports = function (config) {
     const jsonFiles = fs.readdirSync(reportDir).filter(file => file.startsWith('worker-') && file.endsWith('-results.json'))
 
     if (jsonFiles.length === 0) {
-      output.print('HTML Reporter: No worker JSON results found to consolidate')
+      output.debug('HTML Reporter: No worker JSON results found to consolidate')
       return
     }
 
-    output.print(`HTML Reporter: Found ${jsonFiles.length} worker JSON files to consolidate`)
+    output.debug(`HTML Reporter: Found ${jsonFiles.length} worker JSON files to consolidate`)
 
     // Initialize consolidated data structure
     const consolidatedData = {
@@ -821,9 +866,9 @@ module.exports = function (config) {
         saveTestHistory(consolidatedData, config)
       }
 
-      output.print(`HTML Reporter: Successfully consolidated ${jsonFiles.length} worker reports`)
+      output.debug(`HTML Reporter: Successfully consolidated ${jsonFiles.length} worker reports`)
     } catch (error) {
-      output.print(`HTML Reporter: Failed to consolidate worker reports: ${error.message}`)
+      output.debug(`HTML Reporter: Failed to consolidate worker reports: ${error.message}`)
     }
   }
 
@@ -844,7 +889,7 @@ module.exports = function (config) {
 
       // Add current run to history for chart display (before saving to file)
       const currentRun = {
-        timestamp: data.endTime.toISOString(),
+        timestamp: data.endTime, // Already an ISO string
         duration: data.duration,
         stats: data.stats,
         retries: data.retries.length,
@@ -863,7 +908,7 @@ module.exports = function (config) {
 
     const html = template(getHtmlTemplate(), {
       title: `CodeceptJS Test Report v${Codecept.version()}`,
-      timestamp: data.endTime.toISOString(),
+      timestamp: data.endTime, // Already an ISO string
       duration: formatDuration(data.duration),
       stats: JSON.stringify(data.stats),
       history: JSON.stringify(history),
@@ -929,7 +974,9 @@ module.exports = function (config) {
     return tests
       .map(test => {
         const statusClass = test.state || 'unknown'
-        const feature = test.isBdd && test.feature ? test.feature.name : test.parent?.title || 'Unknown Feature'
+        // Use preserved parent/suite titles (for worker mode) or fallback to direct access
+        const feature = test.isBdd && test.feature ? test.feature.name : test.parentTitle || test.suiteTitle || test.parent?.title || test.suite?.title || 'Unknown Feature'
+        // Always try to show steps if available, even for unknown feature
         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) : ''
@@ -1135,19 +1182,19 @@ module.exports = function (config) {
 
   function generateArtifactsHtml(artifacts, isFailedTest = false) {
     if (!artifacts || artifacts.length === 0) {
-      output.print(`HTML Reporter: No artifacts found for test`)
+      output.debug(`HTML Reporter: No artifacts found for test`)
       return ''
     }
 
-    output.print(`HTML Reporter: Processing ${artifacts.length} artifacts, isFailedTest: ${isFailedTest}`)
-    output.print(`HTML Reporter: Artifacts: ${JSON.stringify(artifacts)}`)
+    output.debug(`HTML Reporter: Processing ${artifacts.length} artifacts, isFailedTest: ${isFailedTest}`)
+    output.debug(`HTML Reporter: Artifacts: ${JSON.stringify(artifacts)}`)
 
     // Separate screenshots from other artifacts
     const screenshots = []
     const otherArtifacts = []
 
     artifacts.forEach(artifact => {
-      output.print(`HTML Reporter: Processing artifact: ${artifact} (type: ${typeof artifact})`)
+      output.debug(`HTML Reporter: Processing artifact: ${artifact} (type: ${typeof artifact})`)
 
       // Handle different artifact formats
       let artifactPath = artifact
@@ -1162,14 +1209,14 @@ module.exports = function (config) {
       // Check if it's a screenshot file
       if (typeof artifactPath === 'string' && artifactPath.match(/\.(png|jpg|jpeg|gif|webp|bmp|svg)$/i)) {
         screenshots.push(artifactPath)
-        output.print(`HTML Reporter: Found screenshot: ${artifactPath}`)
+        output.debug(`HTML Reporter: Found screenshot: ${artifactPath}`)
       } else {
         otherArtifacts.push(artifact)
-        output.print(`HTML Reporter: Found other artifact: ${artifact}`)
+        output.debug(`HTML Reporter: Found other artifact: ${artifact}`)
       }
     })
 
-    output.print(`HTML Reporter: Found ${screenshots.length} screenshots and ${otherArtifacts.length} other artifacts`)
+    output.debug(`HTML Reporter: Found ${screenshots.length} screenshots and ${otherArtifacts.length} other artifacts`)
 
     let artifactsHtml = ''
 
@@ -1198,7 +1245,7 @@ module.exports = function (config) {
             }
           }
 
-          output.print(`HTML Reporter: Screenshot ${filename} -> ${relativePath}`)
+          output.debug(`HTML Reporter: Screenshot ${filename} -> ${relativePath}`)
 
           return `
               <div class="screenshot-container">
@@ -1242,7 +1289,7 @@ module.exports = function (config) {
             }
           }
 
-          output.print(`HTML Reporter: Screenshot ${filename} -> ${relativePath}`)
+          output.debug(`HTML Reporter: Screenshot ${filename} -> ${relativePath}`)
           return `<img src="${relativePath}" alt="Screenshot" class="artifact-image" onclick="openImageModal(this.src)"/>`
         })
         .join('')
@@ -1556,7 +1603,7 @@ module.exports = function (config) {
         <section class="history-section" style="display: {{showHistory}};">
             <h2>Test History</h2>
             <div class="history-chart-container">
-                <canvas id="historyChart" width="800" height="300"></canvas>
+                <canvas id="historyChart" width="1600" height="600"></canvas>
             </div>
         </section>
 
@@ -2457,6 +2504,10 @@ body {
 
   function getJsScripts() {
     return `
+// Go to Top button
+function scrollToTop() {
+  window.scrollTo({ top: 0, behavior: 'smooth' });
+}
 function toggleTestDetails(testId) {
     const details = document.getElementById('details-' + testId);
     if (details.style.display === 'none' || details.style.display === '') {
@@ -2939,9 +2990,26 @@ function drawHistoryChart() {
 // Initialize charts and filters
 document.addEventListener('DOMContentLoaded', function() {
     
-    // Draw charts
-    drawPieChart();
-    drawHistoryChart();
+  // Draw charts
+  drawPieChart();
+  drawHistoryChart();
+  // Add Go to Top button
+  const goTopBtn = document.createElement('button');
+  goTopBtn.innerText = '↑ Top';
+  goTopBtn.id = 'goTopBtn';
+  goTopBtn.style.position = 'fixed';
+  goTopBtn.style.bottom = '30px';
+  goTopBtn.style.right = '30px';
+  goTopBtn.style.zIndex = '9999';
+  goTopBtn.style.padding = '12px 18px';
+  goTopBtn.style.borderRadius = '50%';
+  goTopBtn.style.background = '#27ae60';
+  goTopBtn.style.color = '#fff';
+  goTopBtn.style.fontSize = '20px';
+  goTopBtn.style.boxShadow = '0 2px 8px rgba(0,0,0,0.2)';
+  goTopBtn.style.cursor = 'pointer';
+  goTopBtn.onclick = scrollToTop;
+  document.body.appendChild(goTopBtn);
     
     // Set up filter event listeners
     document.getElementById('statusFilter').addEventListener('change', applyFilters);