codeceptjs 3.6.6 → 4.0.0-beta.1

package/lib/plugin/screenshotOnFail.js

@@ -1,20 +1,19 @@
-const fs = require('fs')
-const path = require('path')
+import fs from 'fs';
+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 { fileExists, clearString } from '../utils.js';
+import * as Codeceptjs from '../index.js';
 
-const Container = require('../container')
-const recorder = require('../recorder')
-const event = require('../event')
-const output = require('../output')
-const { fileExists, clearString } = require('../utils')
-const Codeceptjs = require('../index')
+import supportedHelpers from './standardActingHelpers.js';
 
 const defaultConfig = {
   uniqueScreenshotNames: false,
   disableScreenshots: false,
   fullPageScreenshots: false,
-}
-
-const supportedHelpers = require('./standardActingHelpers')
+};
 
 /**
  * Creates screenshot on failure. Screenshot is saved into `output` directory.
@@ -42,140 +41,119 @@ const supportedHelpers = require('./standardActingHelpers')
  *
  *
  */
-module.exports = function (config) {
-  const helpers = Container.helpers()
-  let helper
+export default function (config) {
+  const helpers = Container.helpers();
+  let helper;
 
   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
 
-  const options = Object.assign(defaultConfig, helper.options, config)
+  const options = Object.assign(defaultConfig, helper.options, config);
 
   if (helpers.Mochawesome) {
     if (helpers.Mochawesome.config) {
-      options.uniqueScreenshotNames = helpers.Mochawesome.config.uniqueScreenshotNames
+      options.uniqueScreenshotNames = helpers.Mochawesome.config.uniqueScreenshotNames;
     }
   }
 
-  if (Codeceptjs.container.mocha()) {
-    options.reportDir =
-      Codeceptjs.container.mocha().options.reporterOptions &&
-      Codeceptjs.container.mocha().options.reporterOptions.reportDir
+  if (Codeceptjs.container.mocha) {
+    options.reportDir = Codeceptjs.container.mocha.options.reporterOptions
+      && Codeceptjs.container.mocha.options.reporterOptions.reportDir;
   }
 
   if (options.disableScreenshots) {
     // old version of disabling screenshots
-    return
+    return;
   }
 
   event.dispatcher.on(event.test.failed, (test) => {
     if (test.ctx?._runnable.title.includes('hook: ')) {
-      output.plugin(
-        'screenshotOnFail',
-        'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.',
-      )
+      output.output.plugin('screenshotOnFail', 'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.');
       return
     }
-    recorder.add(
-      'screenshot of failed test',
-      async () => {
-        let fileName = clearString(test.title)
-        const dataType = 'image/png'
-        // This prevents data driven to be included in the failed screenshot file name
-        if (fileName.indexOf('{') !== -1) {
-          fileName = fileName.substr(0, fileName.indexOf('{') - 3).trim()
+
+    recorder.add('screenshot of failed test', async () => {
+      let fileName = clearString(test.title);
+      const dataType = 'image/png';
+      // This prevents data driven to be included in the failed screenshot file name
+      if (fileName.indexOf('{') !== -1) {
+        fileName = fileName.substr(0, (fileName.indexOf('{') - 3)).trim();
+      }
+      if (test.ctx && test.ctx.test && test.ctx.test.type === 'hook') fileName = clearString(`${test.title}_${test.ctx.test.title}`);
+      if (options.uniqueScreenshotNames && test) {
+        const uuid = _getUUID(test);
+        fileName = `${fileName.substring(0, 10)}_${uuid}.failed.png`;
+      } else {
+        fileName += '.failed.png';
+      }
+      output.output.plugin('screenshotOnFail', 'Test failed, try to save a screenshot');
+
+      try {
+        if (options.reportDir) {
+          fileName = path.join(options.reportDir, fileName);
+          const mochaReportDir = path.resolve(process.cwd(), options.reportDir);
+          if (!fileExists(mochaReportDir)) {
+            fs.mkdirSync(mochaReportDir);
+          }
         }
-        if (test.ctx && test.ctx.test && test.ctx.test.type === 'hook')
-          fileName = clearString(`${test.title}_${test.ctx.test.title}`)
-        if (options.uniqueScreenshotNames && test) {
-          const uuid = _getUUID(test)
-          fileName = `${fileName.substring(0, 10)}_${uuid}.failed.png`
-        } else {
-          fileName += '.failed.png'
+        await helper.saveScreenshot(fileName, options.fullPageScreenshots);
+
+        if (!test.artifacts) test.artifacts = {};
+        test.artifacts.screenshot = path.join(global.output_dir, fileName);
+        if (Container.mocha().options.reporterOptions['mocha-junit-reporter'] && Container.mocha().options.reporterOptions['mocha-junit-reporter'].options.attachments) {
+          test.attachments = [path.join(global.output_dir, fileName)];
         }
-        output.plugin('screenshotOnFail', 'Test failed, try to save a screenshot')
-
-        try {
-          if (options.reportDir) {
-            fileName = path.join(options.reportDir, fileName)
-            const mochaReportDir = path.resolve(process.cwd(), options.reportDir)
-            if (!fileExists(mochaReportDir)) {
-              fs.mkdirSync(mochaReportDir)
-            }
-          }
-          await helper.saveScreenshot(fileName, options.fullPageScreenshots)
-
-          if (!test.artifacts) test.artifacts = {}
-          test.artifacts.screenshot = path.join(global.output_dir, fileName)
-          if (
-            Container.mocha().options.reporterOptions['mocha-junit-reporter'] &&
-            Container.mocha().options.reporterOptions['mocha-junit-reporter'].options.attachments
-          ) {
-            test.attachments = [path.join(global.output_dir, fileName)]
-          }
 
-          const allureReporter = Container.plugins('allure')
-          if (allureReporter) {
-            allureReporter.addAttachment(
-              'Main session - Last Seen Screenshot',
-              fs.readFileSync(path.join(global.output_dir, fileName)),
-              dataType,
-            )
-
-            if (helper.activeSessionName) {
-              const sessions = helper.sessionPages || helper.sessionWindows
-              for (const sessionName in sessions) {
-                const screenshotFileName = `${sessionName}_${fileName}`
-                test.artifacts[`${sessionName.replace(/ /g, '_')}_screenshot`] = path.join(
-                  global.output_dir,
-                  screenshotFileName,
-                )
-                allureReporter.addAttachment(
-                  `${sessionName} - Last Seen Screenshot`,
-                  fs.readFileSync(path.join(global.output_dir, screenshotFileName)),
-                  dataType,
-                )
-              }
+        const allureReporter = Container.plugins('allure');
+        if (allureReporter) {
+          allureReporter.addAttachment('Main session - Last Seen Screenshot', fs.readFileSync(path.join(global.output_dir, fileName)), dataType);
+
+          if (helper.activeSessionName) {
+            for (const sessionName in helper.sessionPages) {
+              const screenshotFileName = `${sessionName}_${fileName}`;
+              test.artifacts[`${sessionName.replace(/ /g, '_')}_screenshot`] = path.join(global.output_dir, screenshotFileName);
+              allureReporter.addAttachment(`${sessionName} - Last Seen Screenshot`, fs.readFileSync(path.join(global.output_dir, screenshotFileName)), dataType);
             }
           }
+        }
 
-          const cucumberReporter = Container.plugins('cucumberJsonReporter')
-          if (cucumberReporter) {
-            cucumberReporter.addScreenshot(test.artifacts.screenshot)
-          }
-        } catch (err) {
-          output.plugin(err)
-          if (
-            err &&
-            err.type &&
-            err.type === 'RuntimeError' &&
-            err.message &&
-            (err.message.indexOf('was terminated due to') > -1 ||
-              err.message.indexOf('no such window: target window already closed') > -1)
-          ) {
-            output.log(`Can't make screenshot, ${err}`)
-            helper.isRunning = false
-          }
+        const cucumberReporter = Container.plugins('cucumberJsonReporter');
+        if (cucumberReporter) {
+          cucumberReporter.addScreenshot(test.artifacts.screenshot);
+        }
+      } catch (err) {
+        output.output.plugin(err);
+        if (
+          err
+          && err.type
+          && err.type === 'RuntimeError'
+          && err.message
+          && (
+            err.message.indexOf('was terminated due to') > -1
+            || err.message.indexOf('no such window: target window already closed') > -1
+          )
+        ) {
+          output.output.log(`Can't make screenshot, ${err}`);
+          helper.isRunning = false;
         }
-      },
-      true,
-    )
-  })
+      }
+    }, true);
+  });
 
   function _getUUID(test) {
     if (test.uuid) {
-      return test.uuid
+      return test.uuid;
     }
 
-    if (test.ctx && test.ctx.test.uuid) {
-      return test.ctx.test.uuid
+    if (test.ctx && test.ctx.test?.uuid) {
+      return test.ctx.test.uuid;
     }
 
-    return Math.floor(new Date().getTime() / 1000)
+    return Math.floor(new Date().getTime() / 1000);
   }
 }

package/lib/plugin/selenoid.js

@@ -1,10 +1,13 @@
-const util = require('util')
-const path = require('path')
-const fs = require('fs')
-const axios = require('axios').default
-const exec = util.promisify(require('child_process').exec)
-const { clearString, deepMerge } = require('../utils')
-const { container, event, recorder, output } = require('../index')
+import util from 'util';
+import path from 'path';
+import fs from 'fs';
+import { default as axios } from 'axios';
+import { clearString, deepMerge } from '../utils.js';
+import {
+  container, event, recorder, output,
+} from '../index.js';
+
+const exec = util.promisify(require('child_process').exec);
 
 const defaultBrowserConfig = {
   chrome: {
@@ -27,7 +30,7 @@ const defaultBrowserConfig = {
       },
     },
   },
-}
+};
 
 const dockerCreateScriptArr = [
   'docker create --rm --name $name$',
@@ -39,30 +42,29 @@ const dockerCreateScriptArr = [
   `-e OVERRIDE_VIDEO_OUTPUT_DIR=${global.output_dir}/video/`,
   '$additionalParams$',
   'aerokube/selenoid:latest-release -log-output-dir /opt/selenoid/logs',
-]
+];
 
 const dockerImageCheckScript = [
   'docker images',
-  "--filter reference='selenoid/video-recorder'",
-  "--filter reference='selenoid/chrome:latest'",
-  "--filter reference='selenoid/firefox:latest'",
-].join(' ')
-
-let dockerCreateScript = dockerCreateScriptArr.join(' ')
-let dockerStartScript = 'docker start $name$'
-let dockerStopScript = 'docker stop $name$'
-let seleniumUrl = 'http://localhost:$port$'
-
-const supportedHelpers = ['WebDriver']
-const SELENOID_START_TIMEOUT = 2000
-const SELENOID_STOP_TIMEOUT = 10000
-const wait = (time) =>
-  new Promise((res) => {
-    setTimeout(() => {
-      // @ts-ignore
-      res()
-    }, time)
-  })
+  '--filter reference=\'selenoid/video-recorder\'',
+  '--filter reference=\'selenoid/chrome:latest\'',
+  '--filter reference=\'selenoid/firefox:latest\'',
+].join(' ');
+
+let dockerCreateScript = dockerCreateScriptArr.join(' ');
+let dockerStartScript = 'docker start $name$';
+let dockerStopScript = 'docker stop $name$';
+let seleniumUrl = 'http://localhost:$port$';
+
+const supportedHelpers = ['WebDriver'];
+const SELENOID_START_TIMEOUT = 2000;
+const SELENOID_STOP_TIMEOUT = 10000;
+const wait = time => new Promise((res) => {
+  setTimeout(() => {
+    // @ts-ignore
+    res();
+  }, time);
+});
 
 /**
  * [Selenoid](https://aerokube.com/selenoid/) plugin automatically starts browsers and video recording.
@@ -180,18 +182,18 @@ const wait = (time) =>
  */
 
 const selenoid = (config) => {
-  const helpers = container.helpers()
-  let helperName
+  const helpers = container.helpers();
+  let helperName;
 
   for (const name of supportedHelpers) {
     if (Object.keys(helpers).indexOf(name) > -1) {
-      helperName = name
+      helperName = name;
     }
   }
 
   if (!helperName) {
-    output.print(`Selenoid plugin supported only for: ${supportedHelpers.toString()}`)
-    return // no helpers for Selenoid
+    output.print(`Selenoid plugin supported only for: ${supportedHelpers.toString()}`);
+    return; // no helpers for Selenoid
   }
 
   const {
@@ -201,184 +203,169 @@ const selenoid = (config) => {
     additionalParams = '',
     autoCreate = true,
     port = 4444,
-  } = config
-  const passedTests = []
+  } = config;
+  const passedTests = [];
 
-  recorder.startUnlessRunning()
-  replaceScriptConfig({ name, additionalParams, port })
+  recorder.startUnlessRunning();
+  replaceScriptConfig({ name, additionalParams, port });
 
   if (autoStart) {
     event.dispatcher.on(event.all.before, () => {
       recorder.add('Starting selenoid', () => {
-        output.debug('Staring Selenoid... ')
+        output.debug('Staring Selenoid... ');
         return createAndStart(autoCreate)
           .then(() => output.debug('Selenoid started'))
-          .catch((err) => {
-            throw new Error(err.stack)
-          })
-      })
-    })
+          .catch((err) => { throw new Error(err.stack); });
+      });
+    });
 
     event.dispatcher.on(event.all.after, () => {
       recorder.add('Stopping selenoid', () => {
-        output.debug('Stopping Selenoid...')
+        output.debug('Stopping Selenoid...');
         return wait(SELENOID_STOP_TIMEOUT)
           .then(() => deletePassedTests(passedTests))
           .then(stopSelenoid)
           .then(() => output.debug('Selenoid stopped'))
-          .catch((err) => {
-            throw new Error(err.stack)
-          })
-      })
-    })
+          .catch((err) => { throw new Error(err.stack); });
+      });
+    });
   }
 
   event.dispatcher.on(event.all.before, () => {
     switch (helperName) {
-      case 'WebDriver':
-        setOptionsForWebdriver(config)
-        break
+      case 'WebDriver': setOptionsForWebdriver(config); break;
     }
-  })
+  });
 
   event.dispatcher.on(event.test.before, (test) => {
     switch (helperName) {
-      case 'WebDriver':
-        setTestConfigForWebdriver(test)
-        break
+      case 'WebDriver': setTestConfigForWebdriver(test); break;
     }
-  })
+  });
 
   if (config.enableVideo) {
     event.dispatcher.on(event.test.passed, (test) => {
       if (deletePassed) {
-        passedTests.push(test.title)
+        passedTests.push(test.title);
       } else {
-        test.artifacts.video = videoSaved(test)
+        test.artifacts.video = videoSaved(test);
       }
-    })
+    });
 
     event.dispatcher.on(event.test.failed, (test) => {
-      test.artifacts.video = videoSaved(test)
-    })
+      test.artifacts.video = videoSaved(test);
+    });
   }
-}
+};
 
-module.exports = selenoid
+export default selenoid;
 
 function videoSaved(test) {
-  const fileName = `${clearString(test.title)}.mp4`
-  const videoFile = path.join(global.output_dir, 'video', fileName)
-  output.debug(`Video has been saved to file://${videoFile}`)
-  const allureReporter = container.plugins('allure')
+  const fileName = `${clearString(test.title)}.mp4`;
+  const videoFile = path.join(global.output_dir, 'video', fileName);
+  output.debug(`Video has been saved to file://${videoFile}`);
+  const allureReporter = container.plugins('allure');
   if (allureReporter) {
-    allureReporter.addAttachment('Video', fs.readFileSync(videoFile), 'video/mp4')
+    allureReporter.addAttachment('Video', fs.readFileSync(videoFile), 'video/mp4');
   }
-  return videoFile
+  return videoFile;
 }
 
 const createSelenoidConfig = () => {
-  const configPath = path.join(global.codecept_dir, 'browsers.json')
+  const configPath = path.join(global.codecept_dir, 'browsers.json');
   return new Promise((res, rej) => {
     try {
       if (fs.existsSync(configPath)) {
-        res(true)
+        res(true);
       } else {
-        const data = new Uint8Array(Buffer.from(JSON.stringify(defaultBrowserConfig)))
-        fs.writeFileSync(configPath, data)
-        res(true)
+        const data = new Uint8Array(Buffer.from(JSON.stringify(defaultBrowserConfig)));
+        fs.writeFileSync(configPath, data);
+        res(true);
       }
     } catch (err) {
-      rej(err.stack)
+      rej(err.stack);
     }
-  })
-}
+  });
+};
 
-const createSelenoid = () => exec(dockerCreateScript)
+const createSelenoid = () => exec(dockerCreateScript);
 
-const startSelenoid = () => exec(dockerStartScript)
+const startSelenoid = () => exec(dockerStartScript);
 
-const stopSelenoid = () => exec(dockerStopScript)
+const stopSelenoid = () => exec(dockerStopScript);
 
-const checkDockerImage = () => exec(dockerImageCheckScript)
+const checkDockerImage = () => exec(dockerImageCheckScript);
 
 const pullImage = async () => {
-  const { stdout } = await checkDockerImage()
-  const pulls = []
-  let resultPromise
+  const { stdout } = await checkDockerImage();
+  const pulls = [];
+  let resultPromise;
 
-  output.print('Pulling in Selenoid containers. This may take a while when running the first time...')
+  output.print('Pulling in Selenoid containers. This may take a while when running the first time...');
 
-  console.time('Pulled containers')
+  console.time('Pulled containers');
   if (!stdout.includes('selenoid/video-recorder')) {
-    output.debug('Pulling selenoid/video-recorder...')
-    resultPromise = exec('docker pull selenoid/video-recorder:latest-release').then(() =>
-      output.debug('Pulled in selenoid/video-recorder'),
-    )
-    pulls.push(resultPromise)
+    output.debug('Pulling selenoid/video-recorder...');
+    resultPromise = exec('docker pull selenoid/video-recorder:latest-release')
+      .then(() => output.debug('Pulled in selenoid/video-recorder'));
+    pulls.push(resultPromise);
   }
   if (!stdout.includes('selenoid/chrome')) {
-    output.debug('Pulling selenoid/chrome...')
-    resultPromise = exec('docker pull selenoid/chrome:latest').then(() =>
-      output.debug('Pulled in selenoid/video-recorder'),
-    )
-    pulls.push(resultPromise)
+    output.debug('Pulling selenoid/chrome...');
+    resultPromise = exec('docker pull selenoid/chrome:latest')
+      .then(() => output.debug('Pulled in selenoid/video-recorder'));
+    pulls.push(resultPromise);
   }
   if (!stdout.includes('selenoid/firefox')) {
-    output.debug('Pulling selenoid/firefox...')
-    resultPromise = exec('docker pull selenoid/firefox:latest').then(() => output.debug('Pulled in selenoid/chrome'))
-    pulls.push(resultPromise)
+    output.debug('Pulling selenoid/firefox...');
+    resultPromise = exec('docker pull selenoid/firefox:latest')
+      .then(() => output.debug('Pulled in selenoid/chrome'));
+    pulls.push(resultPromise);
   }
 
   return Promise.all(pulls).then(() => {
-    console.timeEnd('Pulled containers')
-  })
-}
+    console.timeEnd('Pulled containers');
+  });
+};
 
 function createAndStart(autoCreate) {
-  const selenoidCreated = autoCreate ? createSelenoidConfig().then(createSelenoid).then(pullImage) : Promise.resolve()
-  return selenoidCreated.then(startSelenoid).then(() => wait(SELENOID_START_TIMEOUT))
+  const selenoidCreated = autoCreate ? createSelenoidConfig().then(createSelenoid).then(pullImage) : Promise.resolve();
+  return selenoidCreated.then(startSelenoid).then(() => wait(SELENOID_START_TIMEOUT));
 }
 
 function deletePassedTests(passedTests) {
-  const deleteVideoPromiseList = passedTests
-    .map(clearString)
-    .map((test) => axios.delete(`${seleniumUrl}/video/${test}.mp4`))
-  const deleteLogPromiseList = passedTests
-    .map(clearString)
-    .map((test) => axios.delete(`${seleniumUrl}/logs/${test}.log`))
+  const deleteVideoPromiseList = passedTests.map(clearString).map(test => axios.delete(`${seleniumUrl}/video/${test}.mp4`));
+  const deleteLogPromiseList = passedTests.map(clearString).map(test => axios.delete(`${seleniumUrl}/logs/${test}.log`));
 
   return Promise.all(deleteVideoPromiseList.concat(deleteLogPromiseList))
     .then(() => output.debug('Deleted videos and logs for all passed tests'))
-    .catch((err) => output.error(`Error while deleting video and log files ${err.stack}`))
+    .catch(err => output.output.error(`Error while deleting video and log files ${err.stack}`));
 }
 
 function setOptionsForWebdriver(config) {
-  const WebDriver = container.helpers('WebDriver')
-  WebDriver._setConfig(
-    deepMerge(WebDriver.options, {
-      capabilities: { 'selenoid:options': config },
-    }),
-  )
+  const WebDriver = container.helpers('WebDriver');
+  WebDriver._setConfig(deepMerge(WebDriver.options, {
+    capabilities: { 'selenoid:options': config },
+  }));
 }
 
 function setTestConfigForWebdriver(test) {
-  const WebDriver = container.helpers('WebDriver')
-  const fileName = clearString(test.title)
-  const { options } = WebDriver
+  const WebDriver = container.helpers('WebDriver');
+  const fileName = clearString(test.title);
+  const { options } = WebDriver;
   recorder.add('setting selenoid capabilities', () => {
-    options.capabilities['selenoid:options'].name = test.title
-    options.capabilities['selenoid:options'].videoName = `${fileName}.mp4`
-    options.capabilities['selenoid:options'].logName = `${fileName}.log`
-    WebDriver._setConfig(options)
-  })
+    options.capabilities['selenoid:options'].name = test.title;
+    options.capabilities['selenoid:options'].videoName = `${fileName}.mp4`;
+    options.capabilities['selenoid:options'].logName = `${fileName}.log`;
+    WebDriver._setConfig(options);
+  });
 }
 
 function replaceScriptConfig(config) {
   for (const key of Object.keys(config)) {
-    dockerCreateScript = dockerCreateScript.replace(new RegExp(`\\$${key}\\$`, 'g'), config[key])
+    dockerCreateScript = dockerCreateScript.replace(new RegExp(`\\$${key}\\$`, 'g'), config[key]);
   }
-  dockerStartScript = dockerStartScript.replace('$name$', config.name)
-  dockerStopScript = dockerStopScript.replace('$name$', config.name)
-  seleniumUrl = seleniumUrl.replace('$port$', config.port)
+  dockerStartScript = dockerStartScript.replace('$name$', config.name);
+  dockerStopScript = dockerStopScript.replace('$name$', config.name);
+  seleniumUrl = seleniumUrl.replace('$port$', config.port);
 }

package/lib/plugin/standardActingHelpers.js

@@ -1,3 +1,9 @@
-const standardActingHelpers = ['Playwright', 'WebDriver', 'Puppeteer', 'Appium', 'TestCafe']
+const standardActingHelpers = [
+  'Playwright',
+  'WebDriver',
+  'Puppeteer',
+  'Appium',
+  'TestCafe',
+];
 
-module.exports = standardActingHelpers
+export default standardActingHelpers;