codeceptjs 4.0.0-beta.1 → 4.0.0-beta.10.esm-aria

package/lib/helper/network/actions.js

@@ -1,77 +1,68 @@
 import assert from 'assert'
-import { isInTraffic, createAdvancedTestResults, getTrafficDump } from './utils.js';
+import { isInTraffic, createAdvancedTestResults, getTrafficDump } from './utils.js'
 
-export function dontSeeTraffic({ name, url }) {
+function dontSeeTraffic({ name, url }) {
   if (!this.recordedAtLeastOnce) {
-    throw new Error('Failure in test automation. You use "I.dontSeeTraffic", but "I.startRecordingTraffic" was never called before.');
+    throw new Error('Failure in test automation. You use "I.dontSeeTraffic", but "I.startRecordingTraffic" was never called before.')
   }
 
   if (!name) {
-    throw new Error('Missing required key "name" in object given to "I.dontSeeTraffic".');
+    throw new Error('Missing required key "name" in object given to "I.dontSeeTraffic".')
   }
 
   if (!url) {
-    throw new Error('Missing required key "url" in object given to "I.dontSeeTraffic".');
+    throw new Error('Missing required key "url" in object given to "I.dontSeeTraffic".')
   }
 
   if (isInTraffic.call(this, url)) {
-    assert.fail(`Traffic with name "${name}" (URL: "${url}') found, but was not expected to be found.`);
+    assert.fail(`Traffic with name "${name}" (URL: "${url}') found, but was not expected to be found.`)
   }
 }
 
-export async function seeTraffic({
-  name, url, parameters, requestPostData, timeout = 10,
-}) {
+async function seeTraffic({ name, url, parameters, requestPostData, timeout = 10 }) {
   if (!name) {
-    throw new Error('Missing required key "name" in object given to "I.seeTraffic".');
+    throw new Error('Missing required key "name" in object given to "I.seeTraffic".')
   }
 
   if (!url) {
-    throw new Error('Missing required key "url" in object given to "I.seeTraffic".');
+    throw new Error('Missing required key "url" in object given to "I.seeTraffic".')
   }
 
-  if (!this.recording || !this.recordedAtLeastOnce) {
+  if (!this.recordedAtLeastOnce) {
     throw new Error('Failure in test automation. You use "I.seeTraffic", but "I.startRecordingTraffic" was never called before.');
   }
 
   for (let i = 0; i <= timeout * 2; i++) {
-    const found = isInTraffic.call(this, url, parameters);
+    const found = isInTraffic.call(this, url, parameters)
     if (found) {
-      return true;
+      return true
     }
-    await new Promise((done) => {
-      setTimeout(done, 1000);
-    });
+    await new Promise(done => {
+      setTimeout(done, 1000)
+    })
   }
 
   // check request post data
   if (requestPostData && isInTraffic.call(this, url)) {
-    const advancedTestResults = createAdvancedTestResults(url, requestPostData, this.requests);
+    const advancedTestResults = createAdvancedTestResults(url, requestPostData, this.requests)
 
-    assert.equal(advancedTestResults, true, `Traffic named "${name}" found correct URL ${url}, BUT the post data did not match:\n ${advancedTestResults}`);
+    assert.equal(advancedTestResults, true, `Traffic named "${name}" found correct URL ${url}, BUT the post data did not match:\n ${advancedTestResults}`)
   } else if (parameters && isInTraffic.call(this, url)) {
-    const advancedTestResults = createAdvancedTestResults(url, parameters, this.requests);
+    const advancedTestResults = createAdvancedTestResults(url, parameters, this.requests)
 
-    assert.fail(
-      `Traffic named "${name}" found correct URL ${url}, BUT the query parameters did not match:\n`
-      + `${advancedTestResults}`,
-    );
+    assert.fail(`Traffic named "${name}" found correct URL ${url}, BUT the query parameters did not match:\n` + `${advancedTestResults}`)
   } else {
-    assert.fail(
-      `Traffic named "${name}" not found in recorded traffic within ${timeout} seconds.\n`
-      + `Expected url: ${url}.\n`
-      + `Recorded traffic:\n${getTrafficDump.call(this)}`,
-    );
+    assert.fail(`Traffic named "${name}" not found in recorded traffic within ${timeout} seconds.\n` + `Expected url: ${url}.\n` + `Recorded traffic:\n${getTrafficDump.call(this)}`)
   }
 }
 
-export async function grabRecordedNetworkTraffics() {
-  if (!this.recording || !this.recordedAtLeastOnce) {
+async function grabRecordedNetworkTraffics() {
+  if (!this.recordedAtLeastOnce) {
     throw new Error('Failure in test automation. You use "I.grabRecordedNetworkTraffics", but "I.startRecordingTraffic" was never called before.');
   }
 
-  const promises = this.requests.map(async (request) => {
-    const resp = await request.response;
+  const promises = this.requests.map(async request => {
+    const resp = await request.response
 
     if (!resp) {
       return {
@@ -81,13 +72,13 @@ export async function grabRecordedNetworkTraffics() {
           statusText: '',
           body: '',
         },
-      };
+      }
     }
 
-    let body;
+    let body
     try {
       // There's no 'body' for some requests (redirect etc...)
-      body = JSON.parse((await resp.body()).toString());
+      body = JSON.parse((await resp.body()).toString())
     } catch (e) {
       // only interested in JSON, not HTML responses.
     }
@@ -99,18 +90,21 @@ export async function grabRecordedNetworkTraffics() {
         statusText: resp.statusText(),
         body,
       },
-    };
-  });
-  return Promise.all(promises);
+    }
+  })
+  return Promise.all(promises)
 }
 
-export function stopRecordingTraffic() {
+function stopRecordingTraffic() {
   // @ts-ignore
   this.page.removeAllListeners('request');
+   // @ts-ignore
+  this.page.removeAllListeners('requestfinished');
   this.recording = false;
 }
 
-export function flushNetworkTraffics() {
-  this.requests = [];
+function flushNetworkTraffics() {
+  this.requests = []
 }
 
+export { dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics }

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 = {};
-    // eslint-disable-next-line prefer-destructuring
-    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.
@@ -135,12 +135,12 @@ const allRequestPostDataValuePairsMatchExtreme = (RequestPostDataObject, advance
  * @return {string} List of URLs recorded as a string, separated by new lines after each URL
  * @private
  */
-export function getTrafficDump() {
-  let dumpedTraffic = '';
-  this.requests.forEach((request) => {
-    dumpedTraffic += `${request.method} - ${request.url}\n`;
-  });
-  return dumpedTraffic;
+function getTrafficDump() {
+  let dumpedTraffic = ''
+  this.requests.forEach(request => {
+    dumpedTraffic += `${request.method} - ${request.url}\n`
+  })
+  return dumpedTraffic
 }
 
 /**
@@ -152,35 +152,29 @@ export 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
 }
 
-export {
-  createAdvancedTestResults,
-  extractQueryObjects,
-  allParameterValuePairsMatchExtreme,
-  allRequestPostDataValuePairsMatchExtreme,
-  isInTraffic,
-};
+export { createAdvancedTestResults, extractQueryObjects, allParameterValuePairsMatchExtreme, allRequestPostDataValuePairsMatchExtreme, getTrafficDump, isInTraffic }

package/lib/helper/scripts/blurElement.js

@@ -1,17 +1,17 @@
 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 @@
 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 @@
 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)
 }
 
-export default isElementClickable;
+export default isElementClickable

package/lib/helper.js

@@ -1,4 +1,3 @@
 // helper class was moved out from this repository to allow extending from base class
-import generated from '@codeceptjs/helper';
-
-export default generated;
+import Helper from '@codeceptjs/helper'
+export default Helper