codeceptjs 4.0.0-beta.2 → 4.0.0-beta.21

package/lib/plugin/stepByStepReport.js

@@ -1,15 +1,18 @@
-import colors from 'chalk';
-import crypto from 'crypto';
-import figures from 'figures';
-import fs from 'fs';
-import mkdirp from 'mkdirp';
-import path from 'path';
-import Container from '../container.js';
-import recorder from '../recorder.js';
-import * as event from '../event.js';
-import * as output from '../output.js';
-import { template, deleteDir } from '../utils.js';
-import supportedHelpers from './standardActingHelpers.js';
+import colors from 'chalk'
+import crypto from 'crypto'
+import figures from 'figures'
+import fs from 'fs'
+import { mkdirp } from 'mkdirp'
+import path from 'path'
+import cheerio from 'cheerio'
+
+import Container from '../container.js'
+import recorder from '../recorder.js'
+import event from '../event.js'
+import output from '../output.js'
+import { template, deleteDir } from '../utils.js'
+
+const supportedHelpers = Container.STANDARD_ACTING_HELPERS
 
 const defaultConfig = {
   deleteSuccessful: true,
@@ -19,9 +22,9 @@ const defaultConfig = {
   output: global.output_dir,
   screenshotsForAllureReport: false,
   disableScreenshotOnFail: true,
-};
+}
 
-const templates = {};
+const templates = {}
 
 /**
  * ![step-by-step-report](https://codecept.io/img/codeceptjs-slideshow.gif)
@@ -61,134 +64,189 @@ const templates = {};
  */
 
 export default function (config) {
-  const helpers = Container.helpers();
-  let helper;
+  const helpers = Container.helpers()
+  let helper
 
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
 
   for (const helperName of supportedHelpers) {
     if (Object.keys(helpers).indexOf(helperName) > -1) {
-      helper = helpers[helperName];
+      helper = helpers[helperName]
     }
   }
 
-  if (!helper) return; // no helpers for screenshot
-
-  let dir;
-  let stepNum;
-  let slides = {};
-  let error;
-  let savedStep = null;
-  let currentTest = null;
-  let scenarioFailed = false;
-
-  const recordedTests = {};
-  const pad = '0000';
-  const reportDir = config.output ? path.resolve(global.codecept_dir, config.output) : defaultConfig.output;
-
-  event.dispatcher.on(event.test.before, (test) => {
-    const sha256hash = crypto.createHash('sha256').update(test.file + test.title).digest('hex');
-    dir = path.join(reportDir, `record_${sha256hash}`);
-    mkdirp.sync(dir);
-    stepNum = 0;
-    error = null;
-    slides = {};
-    savedStep = null;
-    currentTest = test;
-  });
-
-  event.dispatcher.on(event.step.failed, (step) => {
-    recorder.add('screenshot of failed test', async () => persistStep(step), true);
-  });
-
-  event.dispatcher.on(event.step.after, persistStep);
-
-  event.dispatcher.on(event.test.passed, (test) => {
-    if (!config.deleteSuccessful) return persist(test);
+  if (!helper) return // no helpers for screenshot
+
+  let dir
+  let stepNum
+  let slides = {}
+  let error
+  let savedStep = null
+  let currentTest = null
+  let scenarioFailed = false
+
+  const recordedTests = {}
+  const pad = '0000'
+  const reportDir = config.output ? path.resolve(global.codecept_dir, config.output) : defaultConfig.output
+
+  event.dispatcher.on(event.suite.before, suite => {
+    stepNum = -1
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    const sha256hash = crypto
+      .createHash('sha256')
+      .update(test.file + test.title)
+      .digest('hex')
+    dir = path.join(reportDir, `record_${sha256hash}`)
+    mkdirp.sync(dir)
+    stepNum = 0
+    error = null
+    slides = {}
+    savedStep = null
+    currentTest = test
+  })
+
+  event.dispatcher.on(event.step.failed, step => {
+    recorder.add('screenshot of failed test', async () => persistStep(step), true)
+  })
+
+  event.dispatcher.on(event.step.after, step => {
+    recorder.add('screenshot of step of test', async () => persistStep(step), true)
+  })
+
+  event.dispatcher.on(event.test.passed, test => {
+    if (!config.deleteSuccessful) return persist(test)
     // cleanup
-    deleteDir(dir);
-  });
+    deleteDir(dir)
+  })
 
-  event.dispatcher.on(event.test.failed, (test, err) => {
-    if (test.ctx._runnable.title.includes('hook: ')) {
-      output.output.plugin('stepByStepReport', 'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.');
-      return;
+  event.dispatcher.on(event.test.failed, (test, _err, hookName) => {
+    if (hookName === 'BeforeSuite' || hookName === 'AfterSuite') {
+      // no browser here
+      return
     }
-  });
+
+    persist(test)
+  })
 
   event.dispatcher.on(event.all.result, () => {
-    if (!Object.keys(slides).length) return;
+    if (Object.keys(recordedTests).length === 0 || !Object.keys(slides).length) return
+    generateRecordsHtml(recordedTests)
+  })
+
+  event.dispatcher.on(event.workers.result, async () => {
+    await recorder.add(() => {
+      const recordedTests = getRecordFoldersWithDetails(reportDir)
+      generateRecordsHtml(recordedTests)
+    })
+  })
+
+  function getRecordFoldersWithDetails(dirPath) {
+    let results = {}
+
+    try {
+      const items = fs.readdirSync(dirPath, { withFileTypes: true })
+
+      items.forEach(item => {
+        if (item.isDirectory() && item.name.startsWith('record_')) {
+          const recordFolderPath = path.join(dirPath, item.name)
+          const indexPath = path.join(recordFolderPath, 'index.html')
+
+          let name = ''
+          if (fs.existsSync(indexPath)) {
+            try {
+              const htmlContent = fs.readFileSync(indexPath, 'utf-8')
+              const $ = cheerio.load(htmlContent)
+              name = $('.navbar-brand').text().trim()
+            } catch (err) {
+              console.error(`Error reading index.html in ${recordFolderPath}:`, err.message)
+            }
+          }
+
+          results[name || 'Unkown'] = `${item.name}/index.html`
+        }
+      })
+    } catch (err) {
+      console.error(`Error reading directory ${dirPath}:`, err.message)
+    }
+
+    return results
+  }
 
-    let links = '';
+  function generateRecordsHtml(recordedTests) {
+    let links = ''
 
     for (const link in recordedTests) {
-      links += `<li><a href="${recordedTests[link]}">${link}</a></li>\n`;
+      links += `<li><a href="${recordedTests[link]}">${link}</a></li>\n`
     }
 
     const indexHTML = template(templates.index, {
       time: Date().toString(),
       records: links,
-    });
+    })
 
-    fs.writeFileSync(path.join(reportDir, 'records.html'), indexHTML);
+    fs.writeFileSync(path.join(reportDir, 'records.html'), indexHTML)
 
-    output.print(`${figures.circleFilled} Step-by-step preview: ${colors.white.bold(`file://${reportDir}/records.html`)}`);
-  });
+    output.print(`${figures.circleFilled} Step-by-step preview: ${colors.white.bold(`file://${reportDir}/records.html`)}`)
+  }
 
   async function persistStep(step) {
-    if (isStepIgnored(step)) return;
-    if (savedStep === step) return; // already saved
+    if (stepNum === -1) return // Ignore steps from BeforeSuite function
+    if (isStepIgnored(step)) return
+    if (savedStep === step) return // already saved
     // Ignore steps from BeforeSuite function
-    if (scenarioFailed && config.disableScreenshotOnFail) return;
-    if (step.metaStep && step.metaStep.name === 'BeforeSuite') return;
+    if (scenarioFailed && config.disableScreenshotOnFail) return
+    if (step.metaStep && step.metaStep.name === 'BeforeSuite') return
+    if (!step.test) return // Ignore steps from AfterSuite
 
-    const fileName = `${pad.substring(0, pad.length - stepNum.toString().length) + stepNum.toString()}.png`;
+    const fileName = `${pad.substring(0, pad.length - stepNum.toString().length) + stepNum.toString()}.png`
     if (step.status === 'failed') {
-      scenarioFailed = true;
+      scenarioFailed = true
     }
-    stepNum++;
-    slides[fileName] = step;
+    stepNum++
+    slides[fileName] = step
     try {
-      await helper.saveScreenshot(path.relative(reportDir, path.join(dir, fileName)), config.fullPageScreenshots);
+      await helper.saveScreenshot(path.join(dir, fileName), config.fullPageScreenshots)
     } catch (err) {
-      output.output.plugin(`Can't save step screenshot: ${err}`);
-      error = err;
-      return;
+      output.plugin(`Can't save step screenshot: ${err}`)
+      error = err
+      return
     } finally {
-      savedStep = step;
+      savedStep = step
     }
 
-    if (!currentTest.artifacts.screenshots) currentTest.artifacts.screenshots = [];
+    if (!currentTest.artifacts.screenshots) currentTest.artifacts.screenshots = []
     // added attachments to test
-    currentTest.artifacts.screenshots.push(path.join(dir, fileName));
+    currentTest.artifacts.screenshots.push(path.join(dir, fileName))
 
-    const allureReporter = Container.plugins('allure');
+    const allureReporter = Container.plugins('allure')
     if (allureReporter && config.screenshotsForAllureReport) {
-      output.output.plugin('stepByStepReport', 'Adding screenshot to Allure');
-      allureReporter.addAttachment(`Screenshot of step ${step}`, fs.readFileSync(path.join(dir, fileName)), 'image/png');
+      output.plugin('stepByStepReport', 'Adding screenshot to Allure')
+      allureReporter.addAttachment(`Screenshot of step ${step}`, fs.readFileSync(path.join(dir, fileName)), 'image/png')
     }
   }
 
   function persist(test) {
-    if (error) return;
+    if (error) return
 
-    let indicatorHtml = '';
-    let slideHtml = '';
+    let indicatorHtml = ''
+    let slideHtml = ''
 
     for (const i in slides) {
-      const step = slides[i];
-      const stepNum = parseInt(i, 10);
+      const step = slides[i]
+      const stepNum = parseInt(i, 10)
       indicatorHtml += template(templates.indicator, {
         step: stepNum,
         isActive: stepNum ? '' : 'class="active"',
-      });
+      })
 
       slideHtml += template(templates.slides, {
         image: i,
         caption: step.toString().replace(/\[\d{2}m/g, ''), // remove ANSI escape sequence
         isActive: stepNum ? '' : 'active',
         isError: step.status === 'failed' ? 'error' : '',
-      });
+      })
     }
 
     const html = template(templates.global, {
@@ -197,19 +255,19 @@ export default function (config) {
       feature: test.parent && test.parent.title,
       test: test.title,
       carousel_class: config.animateSlides ? ' slide' : '',
-    });
+    })
 
-    const index = path.join(dir, 'index.html');
-    fs.writeFileSync(index, html);
-    recordedTests[`${test.parent.title}: ${test.title}`] = path.relative(reportDir, index);
+    const index = path.join(dir, 'index.html')
+    fs.writeFileSync(index, html)
+    recordedTests[`${test.parent.title}: ${test.title}`] = path.relative(reportDir, index)
   }
 
   function isStepIgnored(step) {
-    if (!config.ignoreSteps) return;
+    if (!config.ignoreSteps) return
     for (const pattern of config.ignoreSteps || []) {
-      if (step.name.match(pattern)) return true;
+      if (step.name.match(pattern)) return true
     }
-    return false;
+    return false
   }
 }
 
@@ -223,11 +281,11 @@ templates.slides = `
         <small>scroll up and down to see the full page</small>
     </div>
 </div>
-`;
+`
 
 templates.indicator = `
 <li data-target="#steps" data-slide-to="{{step}}" {{isActive}}></li>
-`;
+`
 
 templates.index = `
 <!DOCTYPE html>
@@ -256,7 +314,7 @@ templates.index = `
 
 </body>
 </html>
-`;
+`
 
 templates.global = `
 <!DOCTYPE html>
@@ -366,4 +424,4 @@ templates.global = `
 </body>
 
 </html>
-`;
+`

package/lib/plugin/stepTimeout.js

@@ -1,15 +1,13 @@
-import * as event from '../event.js';
-import { Step } from '../step.js';
+import event from '../event.js'
+
+import { TIMEOUT_ORDER } from '../timeout.js'
 
 const defaultConfig = {
   timeout: 150,
   overrideStepLimits: false,
-  noTimeoutSteps: [
-    'amOnPage',
-    'wait*',
-  ],
+  noTimeoutSteps: ['amOnPage', 'wait*'],
   customTimeoutSteps: [],
-};
+}
 
 /**
  * Set timeout for test steps globally.
@@ -64,28 +62,25 @@ const defaultConfig = {
  * ```
  *
  */
-export default (config) => {
-  config = Object.assign(defaultConfig, config);
+export default function(config) {
+  config = Object.assign(defaultConfig, config)
   // below override rule makes sure customTimeoutSteps go first but then they override noTimeoutSteps in case of exact pattern match
-  config.customTimeoutSteps = config.customTimeoutSteps.concat(config.noTimeoutSteps).concat(config.customTimeoutSteps);
+  config.customTimeoutSteps = config.customTimeoutSteps.concat(config.noTimeoutSteps).concat(config.customTimeoutSteps)
 
-  event.dispatcher.on(event.step.before, (step) => {
-    let stepTimeout;
+  event.dispatcher.on(event.step.before, step => {
+    let stepTimeout
     for (let stepRule of config.customTimeoutSteps) {
-      let customTimeout = 0;
+      let customTimeout = 0
       if (Array.isArray(stepRule)) {
-        if (stepRule.length > 1) customTimeout = stepRule[1];
-        stepRule = stepRule[0];
+        if (stepRule.length > 1) customTimeout = stepRule[1]
+        stepRule = stepRule[0]
       }
-      if (stepRule instanceof RegExp
-        ? step.name.match(stepRule)
-        : (step.name === stepRule || stepRule.indexOf('*') && step.name.startsWith(stepRule.slice(0, -1)))
-      ) {
-        stepTimeout = customTimeout;
-        break;
+      if (stepRule instanceof RegExp ? step.name.match(stepRule) : step.name === stepRule || (stepRule.indexOf('*') && step.name.startsWith(stepRule.slice(0, -1)))) {
+        stepTimeout = customTimeout
+        break
       }
     }
-    stepTimeout = stepTimeout === undefined ? config.timeout : stepTimeout;
-    step.setTimeout(stepTimeout * 1000, config.overrideStepLimits ? Step.TIMEOUT_ORDER.stepTimeoutHard : Step.TIMEOUT_ORDER.stepTimeoutSoft);
-  });
-};
+    stepTimeout = stepTimeout === undefined ? config.timeout : stepTimeout
+    step.setTimeout(stepTimeout * 1000, config.overrideStepLimits ? TIMEOUT_ORDER.stepTimeoutHard : TIMEOUT_ORDER.stepTimeoutSoft)
+  })
+}

package/lib/plugin/subtitles.js

@@ -1,22 +1,22 @@
-import { v4 as uuidv4 } from 'uuid';
-import { promises as fsPromise } from 'fs';
-import path from 'path';
-import * as event from '../event.js';
+import { v4 as uuidv4 } from 'uuid'
+import fs from 'fs'
+const fsPromise = fs.promises
+import path from 'path'
+import event from '../event.js'
 
 // This will convert a given timestamp in milliseconds to
 // an SRT recognized timestamp, ie HH:mm:ss,SSS
 function formatTimestamp(timestampInMs) {
-  const date = new Date(0, 0, 0, 0, 0, 0, timestampInMs);
-  const hours = date.getHours();
-  const minutes = date.getMinutes();
-  const seconds = date.getSeconds();
-  const ms = timestampInMs - (hours * 3600000 + minutes * 60000 + seconds * 1000);
-  return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')},${ms.toString().padStart(3, '0')}`;
+  const date = new Date(0, 0, 0, 0, 0, 0, timestampInMs)
+  const hours = date.getHours()
+  const minutes = date.getMinutes()
+  const seconds = date.getSeconds()
+  const ms = timestampInMs - (hours * 3600000 + minutes * 60000 + seconds * 1000)
+  return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')},${ms.toString().padStart(3, '0')}`
 }
 
-let steps = {};
-let testStartedAt;
-
+let steps = {}
+let testStartedAt
 /**
  * Automatically captures steps as subtitle, and saves it as an artifact when a video is found for a failed test
  *
@@ -30,41 +30,41 @@ let testStartedAt;
  * ```
  */
 export default function () {
-  event.dispatcher.on(event.test.before, (_) => {
-    testStartedAt = Date.now();
-    steps = {};
-  });
+  event.dispatcher.on(event.test.before, _ => {
+    testStartedAt = Date.now()
+    steps = {}
+  })
 
-  event.dispatcher.on(event.step.started, (step) => {
-    const stepStartedAt = Date.now();
-    step.id = uuidv4();
+  event.dispatcher.on(event.step.started, step => {
+    const stepStartedAt = Date.now()
+    step.id = uuidv4()
 
-    let title = `${step.actor}.${step.name}(${step.args ? step.args.join(',') : ''})`;
+    let title = `${step.actor}.${step.name}(${step.args ? step.args.join(',') : ''})`
     if (title.length > 100) {
-      title = `${title.substring(0, 100)}...`;
+      title = `${title.substring(0, 100)}...`
     }
 
     steps[step.id] = {
       start: formatTimestamp(stepStartedAt - testStartedAt),
       startedAt: stepStartedAt,
       title,
-    };
-  });
+    }
+  })
 
-  event.dispatcher.on(event.step.finished, (step) => {
+  event.dispatcher.on(event.step.finished, step => {
     if (step && step.id && steps[step.id]) {
-      steps[step.id].end = formatTimestamp(Date.now() - testStartedAt);
+      steps[step.id].end = formatTimestamp(Date.now() - testStartedAt)
     }
-  });
+  })
 
-  event.dispatcher.on(event.test.after, async (test) => {
+  event.dispatcher.on(event.test.after, async test => {
     if (test && test.artifacts && test.artifacts.video) {
-      const stepsSortedByStartTime = Object.values(steps);
+      const stepsSortedByStartTime = Object.values(steps)
       stepsSortedByStartTime.sort((stepA, stepB) => {
-        return stepA.startedAt - stepB.startedAt;
-      });
+        return stepA.startedAt - stepB.startedAt
+      })
 
-      let subtitle = '';
+      let subtitle = ''
 
       // For an SRT file, every subtitle has to be in the format as mentioned below:
       //
@@ -77,13 +77,13 @@ export default function () {
 ${step.start} --> ${step.end}
 ${step.title}
 
-`;
+`
         }
-      });
+      })
 
-      const { dir: artifactsDirectory, name: fileName } = path.parse(test.artifacts.video);
-      await fsPromise.writeFile(`${artifactsDirectory}/${fileName}.srt`, subtitle);
-      test.artifacts.subtitle = `${artifactsDirectory}/${fileName}.srt`;
+      const { dir: artifactsDirectory, name: fileName } = path.parse(test.artifacts.video)
+      await fsPromise.writeFile(`${artifactsDirectory}/${fileName}.srt`, subtitle)
+      test.artifacts.subtitle = `${artifactsDirectory}/${fileName}.srt`
     }
-  });
+  })
 }