codeceptjs 3.6.4 → 3.6.5-beta.1

package/lib/plugin/allure.js

@@ -1,15 +1,15 @@
 module.exports = () => {
-  console.log('Allure plugin was moved to @codeceptjs/allure-legacy. Please install it and update your config');
-  console.log();
-  console.log('npm install @codeceptjs/allure-legacy --save-dev');
-  console.log();
-  console.log('Then update your config to use it:');
-  console.log();
-  console.log('plugins: {');
-  console.log('  allure: {');
-  console.log('    enabled: true,');
-  console.log('    require: \'@codeceptjs/allure-legacy\',');
-  console.log('  }');
-  console.log('}');
-  console.log();
-};
+  console.log('Allure plugin was moved to @codeceptjs/allure-legacy. Please install it and update your config')
+  console.log()
+  console.log('npm install @codeceptjs/allure-legacy --save-dev')
+  console.log()
+  console.log('Then update your config to use it:')
+  console.log()
+  console.log('plugins: {')
+  console.log('  allure: {')
+  console.log('    enabled: true,')
+  console.log("    require: '@codeceptjs/allure-legacy',")
+  console.log('  }')
+  console.log('}')
+  console.log()
+}

package/lib/plugin/autoDelay.js

@@ -1,24 +1,17 @@
-const Container = require('../container');
-const store = require('../store');
-const recorder = require('../recorder');
-const event = require('../event');
-const log = require('../output').log;
-const supportedHelpers = require('./standardActingHelpers').slice();
+const Container = require('../container')
+const store = require('../store')
+const recorder = require('../recorder')
+const event = require('../event')
+const log = require('../output').log
+const supportedHelpers = require('./standardActingHelpers').slice()
 
-const methodsToDelay = [
-  'click',
-  'fillField',
-  'checkOption',
-  'pressKey',
-  'doubleClick',
-  'rightClick',
-];
+const methodsToDelay = ['click', 'fillField', 'checkOption', 'pressKey', 'doubleClick', 'rightClick']
 
 const defaultConfig = {
   methods: methodsToDelay,
   delayBefore: 100,
   delayAfter: 200,
-};
+}
 
 /**
  *
@@ -59,41 +52,41 @@ const defaultConfig = {
  *
  */
 module.exports = function (config) {
-  supportedHelpers.push('REST');
-  const helpers = Container.helpers();
-  let helper;
+  supportedHelpers.push('REST')
+  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 auto-delay
+  if (!helper) return // no helpers for auto-delay
 
   event.dispatcher.on(event.step.before, (step) => {
-    if (config.methods.indexOf(step.helperMethod) < 0) return; // skip non-actions
+    if (config.methods.indexOf(step.helperMethod) < 0) return // skip non-actions
 
     recorder.add('auto-delay', async () => {
-      if (store.debugMode) return; // no need to delay in debug
-      log(`Delaying for ${config.delayBefore}ms`);
+      if (store.debugMode) return // no need to delay in debug
+      log(`Delaying for ${config.delayBefore}ms`)
       return new Promise((resolve) => {
-        setTimeout(resolve, config.delayBefore);
-      });
-    });
-  });
+        setTimeout(resolve, config.delayBefore)
+      })
+    })
+  })
 
   event.dispatcher.on(event.step.after, (step) => {
-    if (config.methods.indexOf(step.helperMethod) < 0) return; // skip non-actions
+    if (config.methods.indexOf(step.helperMethod) < 0) return // skip non-actions
 
     recorder.add('auto-delay', async () => {
-      if (store.debugMode) return; // no need to delay in debug
-      log(`Delaying for ${config.delayAfter}ms`);
+      if (store.debugMode) return // no need to delay in debug
+      log(`Delaying for ${config.delayAfter}ms`)
       return new Promise((resolve) => {
-        setTimeout(resolve, config.delayAfter);
-      });
-    });
-  });
-};
+        setTimeout(resolve, config.delayAfter)
+      })
+    })
+  })
+}

package/lib/plugin/autoLogin.js

@@ -1,25 +1,25 @@
-const fs = require('fs');
-const path = require('path');
-const { fileExists } = require('../utils');
-const container = require('../container');
-const store = require('../store');
-const recorder = require('../recorder');
-const { debug } = require('../output');
-const isAsyncFunction = require('../utils').isAsyncFunction;
+const fs = require('fs')
+const path = require('path')
+const { fileExists } = require('../utils')
+const container = require('../container')
+const store = require('../store')
+const recorder = require('../recorder')
+const { debug } = require('../output')
+const isAsyncFunction = require('../utils').isAsyncFunction
 
 const defaultUser = {
-  fetch: I => I.grabCookie(),
+  fetch: (I) => I.grabCookie(),
   check: () => {},
   restore: (I, cookies) => {
-    I.amOnPage('/'); // open a page
-    I.setCookie(cookies);
+    I.amOnPage('/') // open a page
+    I.setCookie(cookies)
   },
-};
+}
 
 const defaultConfig = {
   saveToFile: false,
   inject: 'login',
-};
+}
 
 /**
  * Logs user in for the first test and reuses session for next tests.
@@ -249,88 +249,92 @@ const defaultConfig = {
  * })
  *
  *
-*/
+ */
 module.exports = function (config) {
-  config = Object.assign(defaultConfig, config);
-  Object.keys(config.users).map(u => config.users[u] = {
-    ...defaultUser,
-    ...config.users[u],
-  });
+  config = Object.assign(defaultConfig, config)
+  Object.keys(config.users).map(
+    (u) =>
+      (config.users[u] = {
+        ...defaultUser,
+        ...config.users[u],
+      }),
+  )
 
   if (config.saveToFile) {
     // loading from file
     for (const name in config.users) {
-      const fileName = path.join(global.output_dir, `${name}_session.json`);
-      if (!fileExists(fileName)) continue;
-      const data = fs.readFileSync(fileName).toString();
+      const fileName = path.join(global.output_dir, `${name}_session.json`)
+      if (!fileExists(fileName)) continue
+      const data = fs.readFileSync(fileName).toString()
       try {
-        store[`${name}_session`] = JSON.parse(data);
+        store[`${name}_session`] = JSON.parse(data)
       } catch (err) {
-        throw new Error(`Could not load session from ${fileName}\n${err}`);
+        throw new Error(`Could not load session from ${fileName}\n${err}`)
       }
-      debug(`Loaded user session for ${name}`);
+      debug(`Loaded user session for ${name}`)
     }
   }
 
   const loginFunction = async (name) => {
-    const userSession = config.users[name];
-    const I = container.support('I');
-    const cookies = store[`${name}_session`];
-    const shouldAwait = isAsyncFunction(userSession.login)
-      || isAsyncFunction(userSession.restore)
-      || isAsyncFunction(userSession.check);
+    const userSession = config.users[name]
+    const I = container.support('I')
+    const cookies = store[`${name}_session`]
+    const shouldAwait =
+      isAsyncFunction(userSession.login) || isAsyncFunction(userSession.restore) || isAsyncFunction(userSession.check)
 
     const loginAndSave = async () => {
       if (shouldAwait) {
-        await userSession.login(I);
+        await userSession.login(I)
       } else {
-        userSession.login(I);
+        userSession.login(I)
       }
 
-      const cookies = await userSession.fetch(I);
+      const cookies = await userSession.fetch(I)
       if (!cookies) {
-        debug('Cannot save user session with empty cookies from auto login\'s fetch method');
-        return;
+        debug("Cannot save user session with empty cookies from auto login's fetch method")
+        return
       }
       if (config.saveToFile) {
-        debug(`Saved user session into file for ${name}`);
-        fs.writeFileSync(path.join(global.output_dir, `${name}_session.json`), JSON.stringify(cookies));
+        debug(`Saved user session into file for ${name}`)
+        fs.writeFileSync(path.join(global.output_dir, `${name}_session.json`), JSON.stringify(cookies))
       }
-      store[`${name}_session`] = cookies;
-    };
+      store[`${name}_session`] = cookies
+    }
 
-    if (!cookies) return loginAndSave();
+    if (!cookies) return loginAndSave()
 
-    recorder.session.start('check login');
+    recorder.session.start('check login')
     if (shouldAwait) {
-      await userSession.restore(I, cookies);
-      await userSession.check(I, cookies);
+      await userSession.restore(I, cookies)
+      await userSession.check(I, cookies)
     } else {
-      userSession.restore(I, cookies);
-      userSession.check(I, cookies);
+      userSession.restore(I, cookies)
+      userSession.check(I, cookies)
     }
     recorder.session.catch((err) => {
-      debug(`Failed auto login for ${name} due to ${err}`);
-      debug('Logging in again');
-      recorder.session.start('auto login');
-      return loginAndSave().then(() => {
-        recorder.add(() => recorder.session.restore('auto login'));
-        recorder.catch(() => debug('continue'));
-      }).catch((err) => {
-        recorder.session.restore('auto login');
-        recorder.session.restore('check login');
-        recorder.throw(err);
-      });
-    });
+      debug(`Failed auto login for ${name} due to ${err}`)
+      debug('Logging in again')
+      recorder.session.start('auto login')
+      return loginAndSave()
+        .then(() => {
+          recorder.add(() => recorder.session.restore('auto login'))
+          recorder.catch(() => debug('continue'))
+        })
+        .catch((err) => {
+          recorder.session.restore('auto login')
+          recorder.session.restore('check login')
+          recorder.throw(err)
+        })
+    })
     recorder.add(() => {
-      recorder.session.restore('check login');
-    });
+      recorder.session.restore('check login')
+    })
 
-    return recorder.promise();
-  };
+    return recorder.promise()
+  }
 
   // adding this to DI container
-  const support = {};
-  support[config.inject] = loginFunction;
-  container.append({ support });
-};
+  const support = {}
+  support[config.inject] = loginFunction
+  container.append({ support })
+}

package/lib/plugin/commentStep.js

@@ -1,10 +1,10 @@
-const event = require('../event');
-const recorder = require('../recorder');
-const { MetaStep } = require('../step');
+const event = require('../event')
+const recorder = require('../recorder')
+const { MetaStep } = require('../step')
 
-let currentCommentStep;
+let currentCommentStep
 
-const defaultGlobalName = '__';
+const defaultGlobalName = '__'
 
 /**
  * Add descriptive nested steps for your tests:
@@ -101,36 +101,36 @@ const defaultGlobalName = '__';
  */
 module.exports = function (config) {
   event.dispatcher.on(event.test.started, () => {
-    currentCommentStep = null;
-  });
+    currentCommentStep = null
+  })
 
   event.dispatcher.on(event.step.started, (step) => {
     if (currentCommentStep) {
-      const metaStep = getRootMetaStep(step);
+      const metaStep = getRootMetaStep(step)
 
       if (metaStep !== currentCommentStep) {
-        metaStep.metaStep = currentCommentStep;
+        metaStep.metaStep = currentCommentStep
       }
     }
-  });
+  })
 
   if (config.registerGlobal) {
     if (config.registerGlobal === true) {
-      config.registerGlobal = defaultGlobalName;
+      config.registerGlobal = defaultGlobalName
     }
-    global[config.registerGlobal] = setCommentString;
+    global[config.registerGlobal] = setCommentString
   }
 
-  return setCommentString;
-};
+  return setCommentString
+}
 
 function getRootMetaStep(step) {
-  if (step.metaStep) return getRootMetaStep(step.metaStep);
-  return step;
+  if (step.metaStep) return getRootMetaStep(step.metaStep)
+  return step
 }
 
 function setCommentString(string) {
   recorder.add('set comment metastep', () => {
-    currentCommentStep = new MetaStep(String.raw(string), '');
-  });
+    currentCommentStep = new MetaStep(String.raw(string), '')
+  })
 }

package/lib/plugin/coverage.js

@@ -1,17 +1,17 @@
-const debugModule = require('debug');
-const { CoverageReport } = require('monocart-coverage-reports');
-const Container = require('../container');
-const recorder = require('../recorder');
-const event = require('../event');
-const output = require('../output');
-const { deepMerge } = require('../utils');
+const debugModule = require('debug')
+const { CoverageReport } = require('monocart-coverage-reports')
+const Container = require('../container')
+const recorder = require('../recorder')
+const event = require('../event')
+const output = require('../output')
+const { deepMerge } = require('../utils')
 
 const defaultConfig = {
   name: 'CodeceptJS Coverage Report',
   outputDir: 'output/coverage',
-};
+}
 
-const supportedHelpers = ['Puppeteer', 'Playwright', 'WebDriver'];
+const supportedHelpers = ['Puppeteer', 'Playwright', 'WebDriver']
 
 const v8CoverageHelpers = {
   Playwright: {
@@ -23,15 +23,15 @@ const v8CoverageHelpers = {
         page.coverage.startCSSCoverage({
           resetOnNavigation: false,
         }),
-      ]);
+      ])
     },
     takeCoverage: async (page, coverageReport) => {
       const [jsCoverage, cssCoverage] = await Promise.all([
         page.coverage.stopJSCoverage(),
         page.coverage.stopCSSCoverage(),
-      ]);
-      const coverageList = [...jsCoverage, ...cssCoverage];
-      await coverageReport.add(coverageList);
+      ])
+      const coverageList = [...jsCoverage, ...cssCoverage]
+      await coverageReport.add(coverageList)
     },
   },
   Puppeteer: {
@@ -44,21 +44,24 @@ const v8CoverageHelpers = {
         page.coverage.startCSSCoverage({
           resetOnNavigation: false,
         }),
-      ]);
+      ])
     },
     takeCoverage: async (page, coverageReport) => {
       const [jsCoverage, cssCoverage] = await Promise.all([
         page.coverage.stopJSCoverage(),
         page.coverage.stopCSSCoverage(),
-      ]);
+      ])
       // to raw V8 script coverage
-      const coverageList = [...jsCoverage.map((it) => {
-        return {
-          source: it.text,
-          ...it.rawScriptCoverage,
-        };
-      }), ...cssCoverage];
-      await coverageReport.add(coverageList);
+      const coverageList = [
+        ...jsCoverage.map((it) => {
+          return {
+            source: it.text,
+            ...it.rawScriptCoverage,
+          }
+        }),
+        ...cssCoverage,
+      ]
+      await coverageReport.add(coverageList)
     },
   },
   WebDriver: {
@@ -71,24 +74,27 @@ const v8CoverageHelpers = {
         page.coverage.startCSSCoverage({
           resetOnNavigation: false,
         }),
-      ]);
+      ])
     },
     takeCoverage: async (page, coverageReport) => {
       const [jsCoverage, cssCoverage] = await Promise.all([
         page.coverage.stopJSCoverage(),
         page.coverage.stopCSSCoverage(),
-      ]);
+      ])
       // to raw V8 script coverage
-      const coverageList = [...jsCoverage.map((it) => {
-        return {
-          source: it.text,
-          ...it.rawScriptCoverage,
-        };
-      }), ...cssCoverage];
-      await coverageReport.add(coverageList);
+      const coverageList = [
+        ...jsCoverage.map((it) => {
+          return {
+            source: it.text,
+            ...it.rawScriptCoverage,
+          }
+        }),
+        ...cssCoverage,
+      ]
+      await coverageReport.add(coverageList)
     },
   },
-};
+}
 
 /**
  * Dumps code coverage from Playwright/Puppeteer after every test.
@@ -117,72 +123,81 @@ const v8CoverageHelpers = {
  *
  */
 module.exports = function (config) {
-  config = deepMerge(defaultConfig, config);
+  config = deepMerge(defaultConfig, config)
 
-  if (config.debug) config.logging = 'debug';
+  if (config.debug) config.logging = 'debug'
 
-  const helpers = Container.helpers();
-  let coverageRunning = false;
+  const helpers = Container.helpers()
+  let coverageRunning = false
 
-  const v8Names = Object.keys(v8CoverageHelpers);
-  const helperName = Object.keys(helpers).find((it) => v8Names.includes(it));
+  const v8Names = Object.keys(v8CoverageHelpers)
+  const helperName = Object.keys(helpers).find((it) => v8Names.includes(it))
   if (!helperName) {
-    console.error(`Coverage is only supported in ${supportedHelpers.join(' or ')}`);
+    console.error(`Coverage is only supported in ${supportedHelpers.join(' or ')}`)
     // no helpers for screenshot
-    return;
+    return
   }
 
-  config.name = `${config.name} - in ${helperName}`;
-  const debug = debugModule(`codeceptjs:plugin:${helperName.toLowerCase()}Coverage`);
+  config.name = `${config.name} - in ${helperName}`
+  const debug = debugModule(`codeceptjs:plugin:${helperName.toLowerCase()}Coverage`)
 
-  const helper = helpers[helperName];
+  const helper = helpers[helperName]
 
-  if (helperName === 'WebDriver' && !helper.config.devtoolsProtocol) throw Error('Coverage is currently supporting the WebDriver running with Devtools protocol.');
+  if (helperName === 'WebDriver' && !helper.config.devtoolsProtocol)
+    throw Error('Coverage is currently supporting the WebDriver running with Devtools protocol.')
 
-  const v8Helper = v8CoverageHelpers[helperName];
+  const v8Helper = v8CoverageHelpers[helperName]
 
   const coverageOptions = {
     ...config,
-  };
+  }
 
-  if (helperName === 'WebDriver') coverageOptions.coverageProvider = 'v8';
+  if (helperName === 'WebDriver') coverageOptions.coverageProvider = 'v8'
 
-  const coverageReport = new CoverageReport(coverageOptions);
-  coverageReport.cleanCache();
+  const coverageReport = new CoverageReport(coverageOptions)
+  coverageReport.cleanCache()
 
   event.dispatcher.on(event.all.after, async () => {
-    output.print(`writing ${coverageOptions.outputDir}`);
-    await coverageReport.generate();
-  });
+    output.print(`writing ${coverageOptions.outputDir}`)
+    await coverageReport.generate()
+  })
 
   //  we're going to try to "start" coverage before each step because this is
   //  when the browser is already up and is ready to start coverage.
   event.dispatcher.on(event.step.before, () => {
-    recorder.add('start coverage', async () => {
-      if (coverageRunning) {
-        return;
-      }
-      if (!helper.page || !helper.page.coverage) {
-        return;
-      }
-      coverageRunning = true;
-      debug('--> starting coverage <--');
-      await v8Helper.startCoverage(helper.page);
-    }, true);
-  });
+    recorder.add(
+      'start coverage',
+      async () => {
+        if (coverageRunning) {
+          return
+        }
+        if (!helper.page || !helper.page.coverage) {
+          return
+        }
+        coverageRunning = true
+        debug('--> starting coverage <--')
+        await v8Helper.startCoverage(helper.page)
+      },
+      true,
+    )
+  })
 
   // Save coverage data after every test run
   event.dispatcher.on(event.test.after, (test) => {
-    recorder.add('take coverage', async () => {
-      if (!coverageRunning) {
-        return;
-      }
-      if (!helper.page || !helper.page.coverage) {
-        return;
-      }
-      coverageRunning = false;
-      debug('--> stopping coverage <--');
-      await v8Helper.takeCoverage(helper.page, coverageReport);
-    }, true);
-  });
-};
+    recorder.add(
+      'take coverage',
+      async () => {
+        if (!coverageRunning) {
+          return
+        }
+        if (!helper.page || !helper.page.coverage) {
+          return
+        }
+        coverageRunning = false
+        debug('--> stopping coverage <--')
+        await v8Helper.takeCoverage(helper.page, coverageReport)
+      },
+      true,
+    )
+  })
+}