codeceptjs 4.0.0-beta.2 → 4.0.0-beta.4

package/lib/plugin/stepByStepReport.js

@@ -1,15 +1,17 @@
-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 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')
 
 const defaultConfig = {
   deleteSuccessful: true,
@@ -19,9 +21,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)
@@ -60,135 +62,152 @@ const templates = {};
  * @param {*} config
  */
 
-export default function (config) {
-  const helpers = Container.helpers();
-  let helper;
+module.exports = 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
+  if (!helper) return // no helpers for screenshot
+
+  let dir
+  let stepNum
+  let slides = {}
+  let error
+  let savedStep = null
+  let currentTest = null
+  let scenarioFailed = false
 
-  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
 
-  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;
-  });
+    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, persistStep);
+  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);
+    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;
+      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(slides).length) return;
+    if (Object.keys(recordedTests).length === 0 || !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 (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 +216,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 +242,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 +275,7 @@ templates.index = `
 
 </body>
 </html>
-`;
+`
 
 templates.global = `
 <!DOCTYPE html>
@@ -366,4 +385,4 @@ templates.global = `
 </body>
 
 </html>
-`;
+`

package/lib/plugin/stepTimeout.js

@@ -1,15 +1,12 @@
-import * as event from '../event.js';
-import { Step } from '../step.js';
+const event = require('../event')
+const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER
 
 const defaultConfig = {
   timeout: 150,
   overrideStepLimits: false,
-  noTimeoutSteps: [
-    'amOnPage',
-    'wait*',
-  ],
+  noTimeoutSteps: ['amOnPage', 'wait*'],
   customTimeoutSteps: [],
-};
+}
 
 /**
  * Set timeout for test steps globally.
@@ -64,28 +61,32 @@ const defaultConfig = {
  * ```
  *
  */
-export default (config) => {
-  config = Object.assign(defaultConfig, config);
+module.exports = (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 ? 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,21 @@
-import { v4 as uuidv4 } from 'uuid';
-import { promises as fsPromise } from 'fs';
-import path from 'path';
-import * as event from '../event.js';
+const { v4: uuidv4 } = require('uuid')
+const fsPromise = require('fs').promises
+const path = require('path')
+const event = require('../event')
 
 // 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
  *
@@ -29,42 +28,42 @@ let testStartedAt;
  * }
  * ```
  */
-export default function () {
+module.exports = 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:
       //
@@ -77,13 +76,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`
     }
-  });
+  })
 }

package/lib/plugin/tryTo.js

@@ -1,9 +1,9 @@
-import recorder from '../recorder.js';
-import * as output from '../output.js';
+const recorder = require('../recorder')
+const { debug } = require('../output')
 
 const defaultConfig = {
   registerGlobal: true,
-};
+}
 
 /**
  *
@@ -70,36 +70,46 @@ const defaultConfig = {
  * ```
  *
  */
-export default function (config) {
-  config = Object.assign(defaultConfig, config);
+module.exports = function (config) {
+  config = Object.assign(defaultConfig, config)
 
   if (config.registerGlobal) {
-    global.tryTo = tryTo;
+    global.tryTo = tryTo
   }
-  return tryTo;
+  return tryTo
 }
 
-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);
+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,
+  )
 }