codeceptjs 4.0.0-beta.5 → 4.0.0-beta.6.esm-aria

package/lib/helper/network/utils.js

@@ -1,133 +1,133 @@
 const createAdvancedTestResults = (url, dataToCheck, requests) => {
   // Creates advanced test results for a network traffic check.
   // Advanced test results only applies when expected parameters are set
-  if (!dataToCheck) return '';
+  if (!dataToCheck) return ''
 
-  let urlFound = false;
-  let advancedResults;
-  requests.forEach((request) => {
+  let urlFound = false
+  let advancedResults
+  requests.forEach(request => {
     // url not found in this request. continue with next request
-    if (urlFound || !request.url.match(new RegExp(url))) return;
-    urlFound = true;
+    if (urlFound || !request.url.match(new RegExp(url))) return
+    urlFound = true
 
     // Url found. Now we create advanced test report for that URL and show which parameters failed
     if (!request.requestPostData) {
-      advancedResults = allParameterValuePairsMatchExtreme(extractQueryObjects(request.url), dataToCheck);
+      advancedResults = allParameterValuePairsMatchExtreme(extractQueryObjects(request.url), dataToCheck)
     } else if (request.requestPostData) {
-      advancedResults = allRequestPostDataValuePairsMatchExtreme(request.requestPostData, dataToCheck);
+      advancedResults = allRequestPostDataValuePairsMatchExtreme(request.requestPostData, dataToCheck)
     }
-  });
-  return advancedResults;
-};
+  })
+  return advancedResults
+}
 
-const extractQueryObjects = (queryString) => {
+const extractQueryObjects = queryString => {
   // Converts a string of GET parameters into an array of parameter objects. Each parameter object contains the properties "name" and "value".
   if (queryString.indexOf('?') === -1) {
-    return [];
+    return []
   }
-  const queryObjects = [];
+  const queryObjects = []
 
-  const queryPart = queryString.split('?')[1];
+  const queryPart = queryString.split('?')[1]
 
-  const queryParameters = queryPart.split('&');
+  const queryParameters = queryPart.split('&')
 
-  queryParameters.forEach((queryParameter) => {
-    const keyValue = queryParameter.split('=');
-    const queryObject = {};
+  queryParameters.forEach(queryParameter => {
+    const keyValue = queryParameter.split('=')
+    const queryObject = {}
 
-    queryObject.name = keyValue[0];
-    queryObject.value = decodeURIComponent(keyValue[1]);
-    queryObjects.push(queryObject);
-  });
+    queryObject.name = keyValue[0]
+    queryObject.value = decodeURIComponent(keyValue[1])
+    queryObjects.push(queryObject)
+  })
 
-  return queryObjects;
-};
+  return queryObjects
+}
 
 const allParameterValuePairsMatchExtreme = (queryStringObject, advancedExpectedParameterValuePairs) => {
   // More advanced check if all request parameters match with the expectations
-  let littleReport = '\nQuery parameters:\n';
-  let success = true;
+  let littleReport = '\nQuery parameters:\n'
+  let success = true
 
   for (const expectedKey in advancedExpectedParameterValuePairs) {
     if (!Object.prototype.hasOwnProperty.call(advancedExpectedParameterValuePairs, expectedKey)) {
-      continue;
+      continue
     }
-    let parameterFound = false;
-    const expectedValue = advancedExpectedParameterValuePairs[expectedKey];
+    let parameterFound = false
+    const expectedValue = advancedExpectedParameterValuePairs[expectedKey]
 
     for (const queryParameter of queryStringObject) {
       if (queryParameter.name === expectedKey) {
-        parameterFound = true;
+        parameterFound = true
         if (expectedValue === undefined) {
-          littleReport += `   ${expectedKey.padStart(10, ' ')}\n`;
+          littleReport += `   ${expectedKey.padStart(10, ' ')}\n`
         } else if (typeof expectedValue === 'object' && expectedValue.base64) {
-          const decodedActualValue = Buffer.from(queryParameter.value, 'base64').toString('utf8');
+          const decodedActualValue = Buffer.from(queryParameter.value, 'base64').toString('utf8')
           if (decodedActualValue === expectedValue.base64) {
-            littleReport += `   ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})\n`;
+            littleReport += `   ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})\n`
           } else {
-            littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})     -> actual value: "base64(${decodedActualValue})"\n`;
-            success = false;
+            littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})     -> actual value: "base64(${decodedActualValue})"\n`
+            success = false
           }
         } else if (queryParameter.value === expectedValue) {
-          littleReport += `   ${expectedKey.padStart(10, ' ')} = ${expectedValue}\n`;
+          littleReport += `   ${expectedKey.padStart(10, ' ')} = ${expectedValue}\n`
         } else {
-          littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = ${expectedValue}      -> actual value: "${queryParameter.value}"\n`;
-          success = false;
+          littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = ${expectedValue}      -> actual value: "${queryParameter.value}"\n`
+          success = false
         }
       }
     }
 
     if (parameterFound === false) {
-      littleReport += ` ✖ ${expectedKey.padStart(10, ' ')}${expectedValue ? ` = ${JSON.stringify(expectedValue)}` : ''}      -> parameter not found in request\n`;
-      success = false;
+      littleReport += ` ✖ ${expectedKey.padStart(10, ' ')}${expectedValue ? ` = ${JSON.stringify(expectedValue)}` : ''}      -> parameter not found in request\n`
+      success = false
     }
   }
 
-  return success ? true : littleReport;
-};
+  return success ? true : littleReport
+}
 
 const allRequestPostDataValuePairsMatchExtreme = (RequestPostDataObject, advancedExpectedRequestPostValuePairs) => {
   // More advanced check if all request post data match with the expectations
-  let littleReport = '\nRequest Post Data:\n';
-  let success = true;
+  let littleReport = '\nRequest Post Data:\n'
+  let success = true
 
   for (const expectedKey in advancedExpectedRequestPostValuePairs) {
     if (!Object.prototype.hasOwnProperty.call(advancedExpectedRequestPostValuePairs, expectedKey)) {
-      continue;
+      continue
     }
-    let keyFound = false;
-    const expectedValue = advancedExpectedRequestPostValuePairs[expectedKey];
+    let keyFound = false
+    const expectedValue = advancedExpectedRequestPostValuePairs[expectedKey]
 
     for (const [key, value] of Object.entries(RequestPostDataObject)) {
       if (key === expectedKey) {
-        keyFound = true;
+        keyFound = true
         if (expectedValue === undefined) {
-          littleReport += `   ${expectedKey.padStart(10, ' ')}\n`;
+          littleReport += `   ${expectedKey.padStart(10, ' ')}\n`
         } else if (typeof expectedValue === 'object' && expectedValue.base64) {
-          const decodedActualValue = Buffer.from(value, 'base64').toString('utf8');
+          const decodedActualValue = Buffer.from(value, 'base64').toString('utf8')
           if (decodedActualValue === expectedValue.base64) {
-            littleReport += `   ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})\n`;
+            littleReport += `   ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})\n`
           } else {
-            littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})     -> actual value: "base64(${decodedActualValue})"\n`;
-            success = false;
+            littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = base64(${expectedValue.base64})     -> actual value: "base64(${decodedActualValue})"\n`
+            success = false
           }
         } else if (value === expectedValue) {
-          littleReport += `   ${expectedKey.padStart(10, ' ')} = ${expectedValue}\n`;
+          littleReport += `   ${expectedKey.padStart(10, ' ')} = ${expectedValue}\n`
         } else {
-          littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = ${expectedValue}      -> actual value: "${value}"\n`;
-          success = false;
+          littleReport += ` ✖ ${expectedKey.padStart(10, ' ')} = ${expectedValue}      -> actual value: "${value}"\n`
+          success = false
         }
       }
     }
 
     if (keyFound === false) {
-      littleReport += ` ✖ ${expectedKey.padStart(10, ' ')}${expectedValue ? ` = ${JSON.stringify(expectedValue)}` : ''}      -> key not found in request\n`;
-      success = false;
+      littleReport += ` ✖ ${expectedKey.padStart(10, ' ')}${expectedValue ? ` = ${JSON.stringify(expectedValue)}` : ''}      -> key not found in request\n`
+      success = false
     }
   }
 
-  return success ? true : littleReport;
-};
+  return success ? true : littleReport
+}
 
 /**
  * Returns all URLs of all network requests recorded so far during execution of test scenario.
@@ -136,11 +136,11 @@ const allRequestPostDataValuePairsMatchExtreme = (RequestPostDataObject, advance
  * @private
  */
 function getTrafficDump() {
-  let dumpedTraffic = '';
-  this.requests.forEach((request) => {
-    dumpedTraffic += `${request.method} - ${request.url}\n`;
-  });
-  return dumpedTraffic;
+  let dumpedTraffic = ''
+  this.requests.forEach(request => {
+    dumpedTraffic += `${request.method} - ${request.url}\n`
+  })
+  return dumpedTraffic
 }
 
 /**
@@ -152,36 +152,29 @@ function getTrafficDump() {
  * @private
  */
 function isInTraffic(url, parameters) {
-  let isInTraffic = false;
-  this.requests.forEach((request) => {
+  let isInTraffic = false
+  this.requests.forEach(request => {
     if (isInTraffic) {
-      return; // We already found traffic. Continue with next request
+      return // We already found traffic. Continue with next request
     }
 
     if (!request.url.match(new RegExp(url))) {
-      return; // url not found in this request. continue with next request
+      return // url not found in this request. continue with next request
     }
 
     // URL has matched. Now we check the parameters
 
     if (parameters) {
-      const advancedReport = allParameterValuePairsMatchExtreme(extractQueryObjects(request.url), parameters);
+      const advancedReport = allParameterValuePairsMatchExtreme(extractQueryObjects(request.url), parameters)
       if (advancedReport === true) {
-        isInTraffic = true;
+        isInTraffic = true
       }
     } else {
-      isInTraffic = true;
+      isInTraffic = true
     }
-  });
+  })
 
-  return isInTraffic;
+  return isInTraffic
 }
 
-module.exports = {
-  createAdvancedTestResults,
-  extractQueryObjects,
-  allParameterValuePairsMatchExtreme,
-  allRequestPostDataValuePairsMatchExtreme,
-  getTrafficDump,
-  isInTraffic,
-};
+export { createAdvancedTestResults, extractQueryObjects, allParameterValuePairsMatchExtreme, allRequestPostDataValuePairsMatchExtreme, getTrafficDump, isInTraffic }

package/lib/helper/scripts/blurElement.js

@@ -1,17 +1,17 @@
-module.exports.blurElement = (element, context) => {
+export const blurElement = (element, context) => {
   const clientSideBlurFn = el => {
-    el.blur();
-  };
+    el.blur()
+  }
 
   try {
     // Puppeteer
-    context.evaluate(clientSideBlurFn, element);
+    context.evaluate(clientSideBlurFn, element)
   } catch (e) {
     // WebDriver
     try {
-      context.execute(clientSideBlurFn, element);
+      context.execute(clientSideBlurFn, element)
     } catch (err) {
       // ignore
     }
   }
-};
+}

package/lib/helper/scripts/focusElement.js

@@ -1,17 +1,17 @@
-module.exports.focusElement = (element, context) => {
+export const focusElement = (element, context) => {
   const clientSideFn = el => {
-    el.focus();
-  };
+    el.focus()
+  }
 
   try {
     // Puppeteer
-    context.evaluate(clientSideFn, element);
+    context.evaluate(clientSideFn, element)
   } catch (e) {
     // WebDriver
     try {
-      context.execute(clientSideFn, element);
+      context.execute(clientSideFn, element)
     } catch (err) {
       // ignore
     }
   }
-};
+}

package/lib/helper/scripts/highlightElement.js

@@ -1,20 +1,20 @@
-module.exports.highlightElement = (element, context) => {
+export const highlightElement = (element, context) => {
   const clientSideHighlightFn = el => {
-    const style = '0px 0px 4px 3px rgba(255, 0, 0, 0.7)';
-    const prevStyle = el.style.boxShadow;
-    el.style.boxShadow = style;
-    setTimeout(() => el.style.boxShadow = prevStyle, 2000);
-  };
+    const style = '0px 0px 4px 3px rgba(255, 0, 0, 0.7)'
+    const prevStyle = el.style.boxShadow
+    el.style.boxShadow = style
+    setTimeout(() => (el.style.boxShadow = prevStyle), 2000)
+  }
 
   try {
     // Puppeteer
-    context.evaluate(clientSideHighlightFn, element).catch(err => console.error(err));
+    context.evaluate(clientSideHighlightFn, element).catch(err => console.error(err))
   } catch (e) {
     // WebDriver
     try {
-      context.execute(clientSideHighlightFn, element);
+      context.execute(clientSideHighlightFn, element)
     } catch (err) {
       // ignore
     }
   }
-};
+}

package/lib/helper/scripts/isElementClickable.js

@@ -1,64 +1,64 @@
 function isElementClickable(element) {
   if (!element.getBoundingClientRect || !element.scrollIntoView || !element.contains || !element.getClientRects || !document.elementFromPoint) {
-    return false;
+    return false
   }
 
   const getOverlappingElement = (element, context = document) => {
-    const elemDimension = element.getBoundingClientRect();
-    const x = elemDimension.left + (element.clientWidth / 2);
-    const y = elemDimension.top + (element.clientHeight / 2);
+    const elemDimension = element.getBoundingClientRect()
+    const x = elemDimension.left + element.clientWidth / 2
+    const y = elemDimension.top + element.clientHeight / 2
 
-    return context.elementFromPoint(x, y);
-  };
+    return context.elementFromPoint(x, y)
+  }
 
   const getOverlappingRects = (element, context = document) => {
-    const rects = element.getClientRects();
-    const rect = rects[0];
-    const x = rect.left + (rect.width / 2);
-    const y = rect.top + (rect.height / 2);
+    const rects = element.getClientRects()
+    const rect = rects[0]
+    const x = rect.left + rect.width / 2
+    const y = rect.top + rect.height / 2
 
-    return context.elementFromPoint(x, y);
-  };
+    return context.elementFromPoint(x, y)
+  }
 
   const getOverlappingElements = (element, context) => {
-    return [getOverlappingElement(element, context), getOverlappingRects(element, context)];
-  };
+    return [getOverlappingElement(element, context), getOverlappingRects(element, context)]
+  }
 
   const isOverlappingElementMatch = (elementsFromPoint, element) => {
     if (elementsFromPoint.some(elementFromPoint => elementFromPoint === element || element.contains(elementFromPoint))) {
-      return true;
+      return true
     }
 
-    let elementsWithShadowRoot = [...new Set(elementsFromPoint)];
-    elementsWithShadowRoot = elementsWithShadowRoot.filter(elem => elem && elem.shadowRoot && elem.shadowRoot.elementFromPoint);
+    let elementsWithShadowRoot = [...new Set(elementsFromPoint)]
+    elementsWithShadowRoot = elementsWithShadowRoot.filter(elem => elem && elem.shadowRoot && elem.shadowRoot.elementFromPoint)
 
-    let shadowElementsFromPoint = [];
+    let shadowElementsFromPoint = []
     for (const shadowElement of elementsWithShadowRoot) {
-      shadowElementsFromPoint.push(...getOverlappingElements(element, shadowElement.shadowRoot));
+      shadowElementsFromPoint.push(...getOverlappingElements(element, shadowElement.shadowRoot))
     }
-    shadowElementsFromPoint = [...new Set(shadowElementsFromPoint)];
-    shadowElementsFromPoint = shadowElementsFromPoint.filter(element => !elementsFromPoint.includes(element));
+    shadowElementsFromPoint = [...new Set(shadowElementsFromPoint)]
+    shadowElementsFromPoint = shadowElementsFromPoint.filter(element => !elementsFromPoint.includes(element))
 
     if (shadowElementsFromPoint.length === 0) {
-      return false;
+      return false
     }
 
-    return isOverlappingElementMatch(shadowElementsFromPoint, element);
-  };
+    return isOverlappingElementMatch(shadowElementsFromPoint, element)
+  }
 
-  const isElementInViewport = (element) => {
-    const rect = element.getBoundingClientRect();
+  const isElementInViewport = element => {
+    const rect = element.getBoundingClientRect()
 
-    const windowHeight = (window.innerHeight || document.documentElement.clientHeight);
-    const windowWidth = (window.innerWidth || document.documentElement.clientWidth);
+    const windowHeight = window.innerHeight || document.documentElement.clientHeight
+    const windowWidth = window.innerWidth || document.documentElement.clientWidth
 
-    const vertInView = (rect.top <= windowHeight) && ((rect.top + rect.height) > 0);
-    const horInView = (rect.left <= windowWidth) && ((rect.left + rect.width) > 0);
+    const vertInView = rect.top <= windowHeight && rect.top + rect.height > 0
+    const horInView = rect.left <= windowWidth && rect.left + rect.width > 0
 
-    return (vertInView && horInView);
-  };
+    return vertInView && horInView
+  }
 
-  return element.disabled !== true && isElementInViewport(element) && isOverlappingElementMatch(getOverlappingElements(element), element);
+  return element.disabled !== true && isElementInViewport(element) && isOverlappingElementMatch(getOverlappingElements(element), element)
 }
 
-module.exports = isElementClickable;
+export default isElementClickable

package/lib/helper.js

@@ -1,2 +1,3 @@
 // helper class was moved out from this repository to allow extending from base class
-module.exports = require('@codeceptjs/helper');
+import Helper from '@codeceptjs/helper'
+export default Helper

package/lib/history.js

@@ -1,8 +1,7 @@
-const colors = require('chalk');
-const fs = require('fs');
-const path = require('path');
-
-const output = require('./output');
+import colors from 'chalk'
+import fs from 'fs'
+import path from 'path'
+import output from './output.js'
 
 /**
  * REPL history records REPL commands and stores them in
@@ -11,42 +10,46 @@ const output = require('./output');
 class ReplHistory {
   constructor() {
     if (global.output_dir) {
-      this.historyFile = path.join(global.output_dir, 'cli-history');
+      this.historyFile = path.join(global.output_dir, 'cli-history')
     }
-    this.commands = [];
+    this.commands = []
   }
 
   push(cmd) {
-    this.commands.push(cmd);
+    this.commands.push(cmd)
   }
 
   pop() {
-    this.commands.pop();
+    this.commands.pop()
   }
 
   load() {
-    if (!this.historyFile) return;
+    if (!this.historyFile) return
     if (!fs.existsSync(this.historyFile)) {
-      return;
+      return
     }
 
-    const history = fs.readFileSync(this.historyFile, 'utf-8');
-    return history.split('\n').reverse().filter(line => line.startsWith('I.')).map(line => line.slice(2));
+    const history = fs.readFileSync(this.historyFile, 'utf-8')
+    return history
+      .split('\n')
+      .reverse()
+      .filter(line => line.startsWith('I.'))
+      .map(line => line.slice(2))
   }
 
   save() {
-    if (!this.historyFile) return;
+    if (!this.historyFile) return
     if (this.commands.length === 0) {
-      return;
+      return
     }
 
-    const commandSnippet = `\n\n<<< Recorded commands on ${new Date()}\n${this.commands.join('\n')}`;
-    fs.appendFileSync(this.historyFile, commandSnippet);
+    const commandSnippet = `\n\n<<< Recorded commands on ${new Date()}\n${this.commands.join('\n')}`
+    fs.appendFileSync(this.historyFile, commandSnippet)
 
-    output.print(colors.yellow(` Commands have been saved to ${this.historyFile}`));
+    output.print(colors.yellow(` Commands have been saved to ${this.historyFile}`))
 
-    this.commands = [];
+    this.commands = []
   }
 }
 
-module.exports = new ReplHistory();
+export default new ReplHistory()

package/lib/hooks.js

@@ -1,17 +1,17 @@
-const { isFunction, isAsyncFunction } = require('./utils');
-const output = require('./output');
+import { isFunction, isAsyncFunction } from './utils.js'
+import output from './output.js'
 
-module.exports = async function (hook, stage) {
-  if (!hook) return;
+export default async function (hook, stage) {
+  if (!hook) return
   if (!isFunction(hook)) {
-    throw new Error('CodeceptJS 3 allows bootstrap/teardown hooks only as async functions. More info: https://bit.ly/codecept3Up');
+    throw new Error('CodeceptJS 3 allows bootstrap/teardown hooks only as async functions. More info: https://bit.ly/codecept3Up')
   }
 
-  if (stage) output.log(`started ${stage} hook`);
+  if (stage) output.log(`started ${stage} hook`)
   if (isAsyncFunction(hook)) {
-    await hook();
+    await hook()
   } else {
-    hook();
+    hook()
   }
-  if (stage) output.log(`finished ${stage} hook`);
-};
+  if (stage) output.log(`finished ${stage} hook`)
+}