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

package/lib/plugin/commentStep.js

@@ -1,10 +1,10 @@
-import * as event from '../event.js';
-import recorder from '../recorder.js';
-import { MetaStep } from '../step.js';
+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:
@@ -99,38 +99,38 @@ const defaultGlobalName = '__';
  * });
  * ```
  */
-export default function commentStep(config) {
+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 @@
-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 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'];
+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,24 +44,57 @@ 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)
+    },
+  },
+  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);
+      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.
@@ -89,67 +122,79 @@ 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 logger = debug(`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];
-  const v8Helper = v8CoverageHelpers[helperName];
+  const v8Helper = v8CoverageHelpers[helperName]
 
   const coverageOptions = {
     ...config,
-  };
-  const coverageReport = new CoverageReport(coverageOptions);
-  coverageReport.cleanCache();
+  }
+
+  if (helperName === 'WebDriver') coverageOptions.coverageProvider = 'v8'
+
+  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;
-      logger('--> 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;
-      logger('--> 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,
+    )
+  })
 }

package/lib/plugin/customLocator.js

@@ -1,12 +1,12 @@
-import Locator from '../locator.js';
-import { xpathLocator } from '../utils.js';
+const Locator = require('../locator')
+const { xpathLocator } = require('../utils')
 
 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,34 +111,35 @@ const defaultConfig = {
  * I.click('=sign-up'); // matches => [data-qa=sign-up],[data-test=sign-up]
  * ```
  */
-export default (config) => {
-  config = { ...defaultConfig, ...config };
+module.exports = (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 @@
-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 Container = require('../container')
+const recorder = require('../recorder')
+const event = require('../event')
+const supportedHelpers = require('./standardActingHelpers')
+const { scanForErrorMessages } = require('../html')
+const { output } = require('..')
 
 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']`)
  *
  */
-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
 
   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 @@
-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 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')
 
 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.output.
+ * * `purpose` - the goal of an action. A comment text that will be displayed in 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.output.debug(`Found ${els.length} elements for each elements to iterate`);
+    event.emit(event.step.started, step)
+    const els = await helper._locate(locator)
+    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.output.error(`eachElement: failed operation on element #${i} ${el}`);
-        errs.push(err);
+        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)
+  })
 }
 
-export default function (config) {
-  config = Object.assign(defaultConfig, config);
+module.exports = 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 @@
-import { faker } from '@faker-js/faker';
-import transform from '../transform';
+const { faker } = require('@faker-js/faker')
+const transform = require('../transform')
 
 /**
  * Use the `@faker-js/faker` package to generate fake data inside examples on your gherkin tests
@@ -39,11 +39,11 @@ import transform from '../transform';
  * ```
  *
  */
-export default function (config) {
+module.exports = 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
+  })
 }