codeceptjs 3.6.6 → 4.0.0-beta.1

package/lib/plugin/stepByStepReport.js

@@ -1,17 +1,15 @@
-const colors = require('chalk')
-const crypto = require('crypto')
-const figures = require('figures')
-const fs = require('fs')
-const mkdirp = require('mkdirp')
-const path = require('path')
-
-const Container = require('../container')
-const recorder = require('../recorder')
-const event = require('../event')
-const output = require('../output')
-const { template, deleteDir } = require('../utils')
-
-const supportedHelpers = require('./standardActingHelpers')
+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';
 
 const defaultConfig = {
   deleteSuccessful: true,
@@ -21,9 +19,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)
@@ -62,152 +60,135 @@ const templates = {}
  * @param {*} config
  */
 
-module.exports = function (config) {
-  const helpers = Container.helpers()
-  let helper
+export default function (config) {
+  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
+  if (!helper) return; // no helpers for screenshot
 
-  const recordedTests = {}
-  const pad = '0000'
-  const reportDir = config.output ? path.resolve(global.codecept_dir, config.output) : defaultConfig.output
+  let dir;
+  let stepNum;
+  let slides = {};
+  let error;
+  let savedStep = null;
+  let currentTest = null;
+  let scenarioFailed = false;
 
-  event.dispatcher.on(event.suite.before, (suite) => {
-    stepNum = -1
-  })
+  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
-  })
+    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)
-  })
+    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.step.after, persistStep);
 
   event.dispatcher.on(event.test.passed, (test) => {
-    if (!config.deleteSuccessful) return persist(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.plugin(
-        'stepByStepReport',
-        'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.',
-      )
-      return
+      output.output.plugin('stepByStepReport', 'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.');
+      return;
     }
-    persist(test, err)
-  })
+  });
 
   event.dispatcher.on(event.all.result, () => {
-    if (Object.keys(recordedTests).length === 0 || !Object.keys(slides).length) return
+    if (!Object.keys(slides).length) return;
 
-    let links = ''
+    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 (stepNum === -1) return // Ignore steps from BeforeSuite function
-    if (isStepIgnored(step)) return
-    if (savedStep === step) return // already saved
+    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 (!step.test) return // Ignore steps from AfterSuite
+    if (scenarioFailed && config.disableScreenshotOnFail) return;
+    if (step.metaStep && step.metaStep.name === 'BeforeSuite') return;
 
-    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.join(dir, fileName), config.fullPageScreenshots)
+      await helper.saveScreenshot(path.relative(reportDir, path.join(dir, fileName)), config.fullPageScreenshots);
     } catch (err) {
-      output.plugin(`Can't save step screenshot: ${err}`)
-      error = err
-      return
+      output.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.plugin('stepByStepReport', 'Adding screenshot to Allure')
-      allureReporter.addAttachment(`Screenshot of step ${step}`, fs.readFileSync(path.join(dir, fileName)), 'image/png')
+      output.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, {
@@ -216,19 +197,19 @@ module.exports = 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;
   }
 }
 
@@ -242,11 +223,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>
@@ -275,7 +256,7 @@ templates.index = `
 
 </body>
 </html>
-`
+`;
 
 templates.global = `
 <!DOCTYPE html>
@@ -385,4 +366,4 @@ templates.global = `
 </body>
 
 </html>
-`
+`;

package/lib/plugin/stepTimeout.js

@@ -1,12 +1,15 @@
-const event = require('../event')
-const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER
+import * as event from '../event.js';
+import { Step } from '../step.js';
 
 const defaultConfig = {
   timeout: 150,
   overrideStepLimits: false,
-  noTimeoutSteps: ['amOnPage', 'wait*'],
+  noTimeoutSteps: [
+    'amOnPage',
+    'wait*',
+  ],
   customTimeoutSteps: [],
-}
+};
 
 /**
  * Set timeout for test steps globally.
@@ -61,32 +64,28 @@ const defaultConfig = {
  * ```
  *
  */
-module.exports = (config) => {
-  config = Object.assign(defaultConfig, config)
+export default (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
+    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)))
+      if (stepRule instanceof RegExp
+        ? step.name.match(stepRule)
+        : (step.name === stepRule || stepRule.indexOf('*') && step.name.startsWith(stepRule.slice(0, -1)))
       ) {
-        stepTimeout = customTimeout
-        break
+        stepTimeout = customTimeout;
+        break;
       }
     }
-    stepTimeout = stepTimeout === undefined ? config.timeout : stepTimeout
-    step.setTimeout(
-      stepTimeout * 1000,
-      config.overrideStepLimits ? TIMEOUT_ORDER.stepTimeoutHard : TIMEOUT_ORDER.stepTimeoutSoft,
-    )
-  })
-}
+    stepTimeout = stepTimeout === undefined ? config.timeout : stepTimeout;
+    step.setTimeout(stepTimeout * 1000, config.overrideStepLimits ? Step.TIMEOUT_ORDER.stepTimeoutHard : Step.TIMEOUT_ORDER.stepTimeoutSoft);
+  });
+};

package/lib/plugin/subtitles.js

@@ -1,21 +1,22 @@
-const { v4: uuidv4 } = require('uuid')
-const fsPromise = require('fs').promises
-const path = require('path')
-const event = require('../event')
+import { v4 as uuidv4 } from 'uuid';
+import { promises as fsPromise } from 'fs';
+import path from 'path';
+import * as 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
  *
@@ -28,42 +29,42 @@ let testStartedAt
  * }
  * ```
  */
-module.exports = function () {
+export default function () {
   event.dispatcher.on(event.test.before, (_) => {
-    testStartedAt = Date.now()
-    steps = {}
-  })
+    testStartedAt = Date.now();
+    steps = {};
+  });
 
   event.dispatcher.on(event.step.started, (step) => {
-    const stepStartedAt = Date.now()
-    step.id = uuidv4()
+    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) => {
     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) => {
     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:
       //
@@ -76,13 +77,13 @@ module.exports = 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`;
     }
-  })
+  });
 }

package/lib/plugin/tryTo.js

@@ -1,9 +1,9 @@
-const recorder = require('../recorder')
-const { debug } = require('../output')
+import recorder from '../recorder.js';
+import * as output from '../output.js';
 
 const defaultConfig = {
   registerGlobal: true,
-}
+};
 
 /**
  *
@@ -70,46 +70,36 @@ const defaultConfig = {
  * ```
  *
  */
-module.exports = function (config) {
-  config = Object.assign(defaultConfig, config)
+export default function (config) {
+  config = Object.assign(defaultConfig, config);
 
   if (config.registerGlobal) {
-    global.tryTo = tryTo
+    global.tryTo = tryTo;
   }
-  return tryTo
+  return tryTo;
 }
 
-function tryTo(callback) {
-  let result = false
-  return recorder.add(
-    'tryTo',
-    () => {
-      recorder.session.start('tryTo')
-      process.env.TRY_TO = 'true'
-      callback()
-      recorder.add(() => {
-        result = true
-        recorder.session.restore('tryTo')
-        return result
-      })
-      recorder.session.catch((err) => {
-        result = false
-        const msg = err.inspect ? err.inspect() : err.toString()
-        debug(`Unsuccessful try > ${msg}`)
-        recorder.session.restore('tryTo')
-        return result
-      })
-      return recorder.add(
-        'result',
-        () => {
-          process.env.TRY_TO = undefined
-          return result
-        },
-        true,
-        false,
-      )
-    },
-    false,
-    false,
-  )
+export function tryTo(callback) {
+  let result = false;
+  return recorder.add('tryTo', () => {
+    recorder.session.start('tryTo');
+    process.env.TRY_TO = 'true';
+    callback();
+    recorder.add(() => {
+      result = true;
+      recorder.session.restore('tryTo');
+      return result;
+    });
+    recorder.session.catch((err) => {
+      result = false;
+      const msg = err.inspect ? err.inspect() : err.toString();
+      output.output.debug(`Unsuccessful try > ${msg}`);
+      recorder.session.restore('tryTo');
+      return result;
+    });
+    return recorder.add('result', () => {
+      process.env.TRY_TO = undefined;
+      return result;
+    }, true, false);
+  }, false, false);
 }