codeceptjs 3.6.7 → 4.0.0-beta.2

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')
+import debug from 'debug';
+import { CoverageReport } from 'monocart-coverage-reports';
+import container from '../container.js';
+import recorder from '../recorder.js';
+import * as event from '../event.js';
+import * as output from '../output.js';
+import { deepMerge } from '../utils.js';
 
 const defaultConfig = {
   name: 'CodeceptJS Coverage Report',
   outputDir: 'output/coverage',
-}
+};
 
-const supportedHelpers = ['Puppeteer', 'Playwright', 'WebDriver']
+const supportedHelpers = ['Puppeteer', 'Playwright'];
 
 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,57 +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: {
-    startCoverage: async (page) => {
-      await Promise.all([
-        page.coverage.startJSCoverage({
-          resetOnNavigation: false,
-          includeRawScriptCoverage: true,
-        }),
-        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)
-    },
-  },
-}
+};
 
 /**
  * Dumps code coverage from Playwright/Puppeteer after every test.
@@ -122,82 +89,67 @@ const v8CoverageHelpers = {
  * * `sourcePath`: option to resolve a custom path.
  *
  */
-module.exports = function (config) {
-  config = deepMerge(defaultConfig, config)
 
-  if (config.debug) config.logging = 'debug'
+export default function (config) {
+  config = deepMerge(defaultConfig, config);
+  if (config.debug) config.logging = 'debug';
+  const helpers = container.helpers();
+  console.log(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`)
-
-  const helper = helpers[helperName]
-
-  if (helperName === 'WebDriver' && !helper.config.devtoolsProtocol)
-    throw Error('Coverage is currently supporting the WebDriver running with Devtools protocol.')
+  config.name = `${config.name} - in ${helperName}`;
+  const logger = debug(`codeceptjs:plugin:${helperName.toLowerCase()}Coverage`);
 
-  const v8Helper = v8CoverageHelpers[helperName]
+  const helper = helpers[helperName];
+  const v8Helper = v8CoverageHelpers[helperName];
 
   const coverageOptions = {
     ...config,
-  }
-
-  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;
+      logger('--> 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;
+      logger('--> stopping coverage <--');
+      await v8Helper.takeCoverage(helper.page, coverageReport);
+    }, true);
+  });
 }

package/lib/plugin/customLocator.js

@@ -1,12 +1,12 @@
-const Locator = require('../locator')
-const { xpathLocator } = require('../utils')
+import Locator from '../locator.js';
+import { xpathLocator } from '../utils.js';
 
 const defaultConfig = {
   prefix: '$',
   attribute: 'data-test-id',
   strategy: 'xpath',
   showActual: false,
-}
+};
 
 /**
  * Creates a [custom locator](https://codecept.io/locators#custom-locators) by using special attributes in HTML.
@@ -111,35 +111,34 @@ const defaultConfig = {
  * I.click('=sign-up'); // matches => [data-qa=sign-up],[data-test=sign-up]
  * ```
  */
-module.exports = (config) => {
-  config = { ...defaultConfig, ...config }
+export default (config) => {
+  config = { ...defaultConfig, ...config };
 
   Locator.addFilter((value, locatorObj) => {
-    if (typeof value !== 'string') return
-    if (!value.startsWith(config.prefix)) return
+    if (typeof value !== 'string') return;
+    if (!value.startsWith(config.prefix)) return;
 
-    if (!['String', 'Array'].includes(config.attribute.constructor.name)) return
+    if (!['String', 'Array'].includes(config.attribute.constructor.name)) return;
 
-    const val = value.substr(config.prefix.length)
+    const val = value.substr(config.prefix.length);
 
     if (config.strategy.toLowerCase() === 'xpath') {
-      locatorObj.value = `.//*[${[]
-        .concat(config.attribute)
-        .map((attr) => `@${attr}=${xpathLocator.literal(val)}`)
-        .join(' or ')}]`
-      locatorObj.type = 'xpath'
+      locatorObj.value = `.//*[${
+        [].concat(config.attribute)
+          .map((attr) => `@${attr}=${xpathLocator.literal(val)}`)
+          .join(' or ')}]`;
+      locatorObj.type = 'xpath';
     }
 
     if (config.strategy.toLowerCase() === 'css') {
-      locatorObj.value = []
-        .concat(config.attribute)
+      locatorObj.value = [].concat(config.attribute)
         .map((attr) => `[${attr}=${val}]`)
-        .join(',')
-      locatorObj.type = 'css'
+        .join(',');
+      locatorObj.type = 'css';
     }
 
     if (config.showActual) {
-      locatorObj.output = locatorObj.value
+      locatorObj.output = locatorObj.value;
     }
-  })
-}
+  });
+};

package/lib/plugin/debugErrors.js

@@ -1,13 +1,13 @@
-const Container = require('../container')
-const recorder = require('../recorder')
-const event = require('../event')
-const supportedHelpers = require('./standardActingHelpers')
-const { scanForErrorMessages } = require('../html')
-const { output } = require('..')
+import Container from '../container.js';
+import recorder from '../recorder.js';
+import * as event from '../event.js';
+import supportedHelpers from './standardActingHelpers.js';
+import { scanForErrorMessages } from '../html';
+import { output } from '..';
 
 const defaultConfig = {
   errorClasses: ['error', 'warning', 'alert', 'danger'],
-}
+};
 
 /**
  * Prints errors found in HTML code after each failed test.
@@ -29,39 +29,39 @@ const defaultConfig = {
  * * `errorClasses` - list of classes to search for errors (default: `['error', 'warning', 'alert', 'danger']`)
  *
  */
-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
+  if (!helper) return; // no helpers for screenshot
 
   event.dispatcher.on(event.test.failed, (test) => {
     recorder.add('HTML snapshot failed test', async () => {
       try {
-        const currentOutputLevel = output.level()
-        output.level(0)
-        const html = await helper.grabHTMLFrom('body')
-        output.level(currentOutputLevel)
+        const currentOutputLevel = output.level();
+        output.level(0);
+        const html = await helper.grabHTMLFrom('body');
+        output.level(currentOutputLevel);
 
-        if (!html) return
+        if (!html) return;
 
-        const errors = scanForErrorMessages(html, config.errorClasses)
+        const errors = scanForErrorMessages(html, config.errorClasses);
         if (errors.length) {
-          output.debug('Detected errors in HTML code')
-          errors.forEach((error) => output.debug(error))
-          test.artifacts.errors = errors
+          output.debug('Detected errors in HTML code');
+          errors.forEach((error) => output.debug(error));
+          test.artifacts.errors = errors;
         }
       } catch (err) {
         // not really needed
       }
-    })
-  })
+    });
+  });
 }

package/lib/plugin/eachElement.js

@@ -1,20 +1,20 @@
-const output = require('../output')
-const store = require('../store')
-const recorder = require('../recorder')
-const container = require('../container')
-const event = require('../event')
-const Step = require('../step')
-const { isAsyncFunction } = require('../utils')
+import * as output from '../output.js';
+import { store } from '../store.js';
+import recorder from '../recorder.js';
+import container from '../container.js';
+import * as event from '../event.js';
+import { Step } from '../step.js';
+import { isAsyncFunction } from '../utils.js';
 
 const defaultConfig = {
   registerGlobal: true,
-}
+};
 
 /**
  * Provides `eachElement` global function to iterate over found elements to perform actions on them.
  *
  * `eachElement` takes following args:
- * * `purpose` - the goal of an action. A comment text that will be displayed in output.
+ * * `purpose` - the goal of an action. A comment text that will be displayed in output.output.
  * * `locator` - a CSS/XPath locator to match elements
  * * `fn(element, index)` - **asynchronous** function which will be executed for each matched element.
  *
@@ -69,59 +69,59 @@ const defaultConfig = {
  * @return {Promise<*> | undefined}
  */
 function eachElement(purpose, locator, fn) {
-  if (store.dryRun) return
-  const helpers = Object.values(container.helpers())
+  if (store.dryRun) return;
+  const helpers = Object.values(container.helpers());
 
-  const helper = helpers.filter((h) => !!h._locate)[0]
+  const helper = helpers.filter(h => !!h._locate)[0];
 
   if (!helper) {
-    throw new Error('No helper enabled with _locate method with returns a list of elements.')
+    throw new Error('No helper enabled with _locate method with returns a list of elements.');
   }
 
   if (!isAsyncFunction(fn)) {
-    throw new Error('Async function should be passed into each element')
+    throw new Error('Async function should be passed into each element');
   }
 
-  const step = new Step(helper, `${purpose || 'each element'} within "${locator}"`)
-  step.helperMethod = '_locate'
+  const step = new Step(helper, `${purpose || 'each element'} within "${locator}"`);
+  step.helperMethod = '_locate';
   // eachElement('select all users', 'locator', async (el) => {
-  event.dispatcher.emit(event.step.before, step)
+  event.dispatcher.emit(event.step.before, step);
 
   return recorder.add('register each element wrapper', async () => {
-    event.emit(event.step.started, step)
-    const els = await helper._locate(locator)
-    output.debug(`Found ${els.length} elements for each elements to iterate`)
+    event.emit(event.step.started, step);
+    const els = await helper._locate(locator);
+    output.output.debug(`Found ${els.length} elements for each elements to iterate`);
 
-    const errs = []
-    let i = 0
+    const errs = [];
+    let i = 0;
     for (const el of els) {
       try {
-        await fn(el, i)
+        await fn(el, i);
       } catch (err) {
-        output.error(`eachElement: failed operation on element #${i} ${el}`)
-        errs.push(err)
+        output.output.error(`eachElement: failed operation on element #${i} ${el}`);
+        errs.push(err);
       }
-      i++
+      i++;
     }
 
     if (errs.length) {
-      event.dispatcher.emit(event.step.after, step)
-      event.emit(event.step.failed, step, errs[0])
-      event.emit(event.step.finished, step)
-      throw errs[0]
+      event.dispatcher.emit(event.step.after, step);
+      event.emit(event.step.failed, step, errs[0]);
+      event.emit(event.step.finished, step);
+      throw errs[0];
     }
 
-    event.dispatcher.emit(event.step.after, step)
-    event.emit(event.step.passed, step, null)
-    event.emit(event.step.finished, step)
-  })
+    event.dispatcher.emit(event.step.after, step);
+    event.emit(event.step.passed, step, null);
+    event.emit(event.step.finished, step);
+  });
 }
 
-module.exports = function (config) {
-  config = Object.assign(defaultConfig, config)
+export default function (config) {
+  config = Object.assign(defaultConfig, config);
 
   if (config.registerGlobal) {
-    global.eachElement = eachElement
+    global.eachElement = eachElement;
   }
-  return eachElement
+  return eachElement;
 }

package/lib/plugin/fakerTransform.js

@@ -1,5 +1,5 @@
-const { faker } = require('@faker-js/faker')
-const transform = require('../transform')
+import { faker } from '@faker-js/faker';
+import transform from '../transform';
 
 /**
  * Use the `@faker-js/faker` package to generate fake data inside examples on your gherkin tests
@@ -39,11 +39,11 @@ const transform = require('../transform')
  * ```
  *
  */
-module.exports = function (config) {
+export default function (config) {
   transform.addTransformerBeforeAll('gherkin.examples', (value) => {
     if (typeof value === 'string' && value.length > 0) {
-      return faker.helpers.fake(value)
+      return faker.helpers.fake(value);
     }
-    return value
-  })
+    return value;
+  });
 }