codeceptjs 3.7.6-beta.4 → 4.0.0-beta.10.esm-aria

package/lib/helper/errors/ElementNotFound.js

@@ -1,19 +1,15 @@
-const Locator = require('../../locator');
+import Locator from '../../locator.js'
 /**
  * Uses to throw readable element not found error
  * Stringify object's locators
  */
 class ElementNotFound {
-  constructor(
-    locator,
-    prefixMessage = 'Element',
-    postfixMessage = 'was not found by text|CSS|XPath',
-  ) {
+  constructor(locator, prefixMessage = 'Element', postfixMessage = 'was not found by text|CSS|XPath') {
     if (typeof locator === 'object') {
-      locator = JSON.stringify(locator);
+      locator = JSON.stringify(locator)
     }
-    throw new Error(`${prefixMessage} "${(new Locator(locator))}" ${postfixMessage}`);
+    throw new Error(`${prefixMessage} "${new Locator(locator)}" ${postfixMessage}`)
   }
 }
 
-module.exports = ElementNotFound;
+export default ElementNotFound

package/lib/helper/errors/RemoteBrowserConnectionRefused.js

@@ -1,9 +1,9 @@
 function RemoteBrowserConnectionRefused(err) {
-  this.message = 'Cannot connect to websocket endpoint.\n\n';
-  this.message += 'Please make sure remote browser is running and accessible.';
-  this.stack = err.error || err;
+  this.message = 'Cannot connect to websocket endpoint.\n\n'
+  this.message += 'Please make sure remote browser is running and accessible.'
+  this.stack = err.error || err
 }
 
-RemoteBrowserConnectionRefused.prototype = Object.create(Error.prototype);
+RemoteBrowserConnectionRefused.prototype = Object.create(Error.prototype)
 
-module.exports = RemoteBrowserConnectionRefused;
+export default RemoteBrowserConnectionRefused

package/lib/helper/extras/Console.js

@@ -3,31 +3,31 @@
  */
 class Console {
   constructor() {
-    this._logEntries = [];
+    this._logEntries = []
   }
 
   get entries() {
-    return this._logEntries;
+    return this._logEntries
   }
 
   clear() {
-    this._logEntries = [];
+    this._logEntries = []
   }
 
   includes(msg) {
-    const prev = this._logEntries[this._logEntries.length - 1];
-    if (!prev) return false;
-    const text = msg.text && msg.text() || msg._text || '';
-    const prevText = prev.text && prev.text() || prev._text || '';
-    return text === prevText;
+    const prev = this._logEntries[this._logEntries.length - 1]
+    if (!prev) return false
+    const text = (msg.text && msg.text()) || msg._text || ''
+    const prevText = (prev.text && prev.text()) || prev._text || ''
+    return text === prevText
   }
 
   add(entry) {
     if (Array.isArray(entry)) {
-      this._logEntries = this._logEntries.concat(entry);
+      this._logEntries = this._logEntries.concat(entry)
     }
-    this._logEntries.push(entry);
+    this._logEntries.push(entry)
   }
 }
 
-module.exports = Console;
+export default Console

package/lib/helper/extras/PlaywrightLocator.js

@@ -0,0 +1,110 @@
+import Locator from '../../locator.js'
+
+function buildLocatorString(locator) {
+  if (locator.isCustom()) {
+    return `${locator.type}=${locator.value}`
+  }
+  if (locator.isXPath()) {
+    return `xpath=${locator.value}`
+  }
+  return locator.simplify()
+}
+
+async function findElements(matcher, locator) {
+  const matchedLocator = new Locator(locator, 'css')
+
+  if (matchedLocator.type === 'react') return findReact(matcher, matchedLocator)
+  if (matchedLocator.type === 'vue') return findVue(matcher, matchedLocator)
+  if (matchedLocator.type === 'pw') return findByPlaywrightLocator(matcher, matchedLocator)
+  if (matchedLocator.isRole()) return findByRole(matcher, matchedLocator)
+
+  return matcher.locator(buildLocatorString(matchedLocator)).all()
+}
+
+async function findElement(matcher, locator) {
+  const matchedLocator = new Locator(locator, 'css')
+
+  if (matchedLocator.type === 'react') return findReact(matcher, matchedLocator)
+  if (matchedLocator.type === 'vue') return findVue(matcher, matchedLocator)
+  if (matchedLocator.type === 'pw') return findByPlaywrightLocator(matcher, matchedLocator, { first: true })
+  if (matchedLocator.isRole()) return findByRole(matcher, matchedLocator, { first: true })
+
+  return matcher.locator(buildLocatorString(matchedLocator)).first()
+}
+
+async function getVisibleElements(elements) {
+  const visibleElements = []
+  for (const element of elements) {
+    if (await element.isVisible()) {
+      visibleElements.push(element)
+    }
+  }
+  if (visibleElements.length === 0) {
+    return elements
+  }
+  return visibleElements
+}
+
+async function findReact(matcher, locator) {
+  const details = locator.locator ?? { react: locator.value }
+  let locatorString = `_react=${details.react}`
+
+  if (details.props) {
+    locatorString += propBuilder(details.props)
+  }
+
+  return matcher.locator(locatorString).all()
+}
+
+async function findVue(matcher, locator) {
+  const details = locator.locator ?? { vue: locator.value }
+  let locatorString = `_vue=${details.vue}`
+
+  if (details.props) {
+    locatorString += propBuilder(details.props)
+  }
+
+  return matcher.locator(locatorString).all()
+}
+
+async function findByPlaywrightLocator(matcher, locator, { first = false } = {}) {
+  const details = locator.locator ?? { pw: locator.value }
+  const locatorValue = details.pw
+
+  const handle = matcher.locator(locatorValue)
+  return first ? handle.first() : handle.all()
+}
+
+async function findByRole(matcher, locator, { first = false } = {}) {
+  const details = locator.locator ?? { role: locator.value }
+  const { role, text, name, exact, includeHidden, ...rest } = details
+  const options = { ...rest }
+
+  if (includeHidden !== undefined) options.includeHidden = includeHidden
+
+  const accessibleName = name ?? text
+  if (accessibleName !== undefined) {
+    options.name = accessibleName
+    if (exact === true) options.exact = true
+  }
+
+  const roleLocator = matcher.getByRole(role, options)
+  return first ? roleLocator.first() : roleLocator.all()
+}
+
+function propBuilder(props) {
+  let _props = ''
+
+  for (const [key, value] of Object.entries(props)) {
+    if (typeof value === 'object') {
+      for (const [k, v] of Object.entries(value)) {
+        _props += `[${key}.${k} = "${v}"]`
+      }
+    } else {
+      _props += `[${key} = "${value}"]`
+    }
+  }
+  return _props
+}
+
+export { buildLocatorString, findElements, findElement, getVisibleElements, findReact, findVue, findByPlaywrightLocator, findByRole }

package/lib/helper/extras/PlaywrightPropEngine.js

@@ -1,55 +1,55 @@
-module.exports.createValueEngine = () => {
+export const createValueEngine = () => {
   return {
     // Creates a selector that matches given target when queried at the root.
     // Can return undefined if unable to create one.
 
     create(root, target) {
-      return null;
+      return null
     },
 
     // Returns the first element matching given selector in the root's subtree.
     query(root, selector) {
       if (!root) {
-        return null;
+        return null
       }
-      return `${root.value}`.includes(selector) ? root : null;
+      return `${root.value}`.includes(selector) ? root : null
     },
 
     // Returns all elements matching given selector in the root's subtree.
     queryAll(root, selector) {
       if (!root) {
-        return null;
+        return null
       }
-      return `${root.value}`.includes(selector) ? root : null;
+      return `${root.value}`.includes(selector) ? root : null
     },
-  };
-};
+  }
+}
 
-module.exports.createDisabledEngine = () => {
+export const createDisabledEngine = () => {
   return {
     // Creates a selector that matches given target when queried at the root.
     // Can return undefined if unable to create one.
 
     create(root, target) {
-      return null;
+      return null
     },
 
     // Returns the first element matching given selector in the root's subtree.
     query(root, value) {
-      const bool = value === 'true';
+      const bool = value === 'true'
       if (!root) {
-        return null;
+        return null
       }
-      return root.disabled === bool ? root : null;
+      return root.disabled === bool ? root : null
     },
 
     // Returns all elements matching given selector in the root's subtree.
     queryAll(root, value) {
-      const bool = value === 'true';
+      const bool = value === 'true'
       if (!root) {
-        return null;
+        return null
       }
-      return root.disabled === bool ? root : null;
+      return root.disabled === bool ? root : null
     },
-  };
-};
+  }
+}

package/lib/helper/extras/PlaywrightReactVueLocator.js

@@ -1,28 +1,37 @@
 async function findReact(matcher, locator) {
-  let _locator = `_react=${locator.react}`;
+  // Handle both Locator objects and raw locator objects
+  const reactLocator = locator.locator || locator
+  let _locator = `_react=${reactLocator.react}`;
   let props = '';
 
-  if (locator.props) {
-    props += propBuilder(locator.props);
+  if (reactLocator.props) {
+    props += propBuilder(reactLocator.props);
     _locator += props;
   }
   return matcher.locator(_locator).all();
 }
 
 async function findVue(matcher, locator) {
-  let _locator = `_vue=${locator.vue}`;
+  // Handle both Locator objects and raw locator objects
+  const vueLocator = locator.locator || locator
+  let _locator = `_vue=${vueLocator.vue}`;
   let props = '';
 
-  if (locator.props) {
-    props += propBuilder(locator.props);
+  if (vueLocator.props) {
+    props += propBuilder(vueLocator.props);
     _locator += props;
   }
   return matcher.locator(_locator).all();
 }
 
 async function findByPlaywrightLocator(matcher, locator) {
-  if (locator && locator.toString().includes(process.env.testIdAttribute)) return matcher.getByTestId(locator.pw.value.split('=')[1]);
-  return matcher.locator(locator.pw).all();
+  // Handle both Locator objects and raw locator objects
+  const pwLocator = locator.locator || locator
+  if (pwLocator && pwLocator.toString && pwLocator.toString().includes(process.env.testIdAttribute)) {
+    return matcher.getByTestId(pwLocator.pw.value.split('=')[1]);
+  }
+  const pwValue = typeof pwLocator.pw === 'string' ? pwLocator.pw : pwLocator.pw
+  return matcher.locator(pwValue).all();
 }
 
 function propBuilder(props) {
@@ -40,4 +49,4 @@ function propBuilder(props) {
   return _props;
 }
 
-module.exports = { findReact, findVue, findByPlaywrightLocator };
+export { findReact, findVue, findByPlaywrightLocator };

package/lib/helper/extras/PlaywrightRestartOpts.js

@@ -1,33 +1,44 @@
 const RESTART_OPTS = {
   session: 'keep',
-  browser: true,
   context: false,
-};
+  browser: true,
+}
+
+let restarts = null
+
+export function setRestartStrategy(options) {
+  const { restart } = options
+  const stringOpts = Object.keys(RESTART_OPTS)
+
+  if (stringOpts.includes(restart)) {
+    return (restarts = restart)
+  }
 
-let restarts = null;
+  // When restart is false, don't restart anything
+  if (restart === false) {
+    restarts = null
+    return
+  }
 
-module.exports = {
+  // When restart is true, map to 'browser' restart
+  if (restart === true) {
+    restarts = 'browser'
+    return
+  }
 
-  setRestartStrategy(options) {
-    const { restart } = options;
-    const stringOpts = Object.keys(RESTART_OPTS);
+  restarts = Object.keys(RESTART_OPTS).find(key => RESTART_OPTS[key] === restart)
 
-    if (stringOpts.includes(restart)) {
-      return restarts = restart;
-    }
+  if (restarts === null || restarts === undefined) throw new Error('No restart strategy set, use the following values for restart: session, context, browser')
+}
 
-    restarts = Object.keys(RESTART_OPTS).find(key => RESTART_OPTS[key] === restart);
+export function restartsSession() {
+  return restarts === 'session'
+}
 
-    if (restarts === null || restarts === undefined) throw new Error('No restart strategy set, use the following values for restart: session, context, browser');
-  },
+export function restartsContext() {
+  return restarts === 'context'
+}
 
-  restartsSession() {
-    return restarts === 'session';
-  },
-  restartsContext() {
-    return restarts === 'context';
-  },
-  restartsBrowser() {
-    return restarts === 'browser';
-  },
-};
+export function restartsBrowser() {
+  return restarts === 'browser'
+}

package/lib/helper/extras/Popup.js

@@ -64,4 +64,4 @@ class Popup {
   }
 }
 
-module.exports = Popup
+export default Popup

package/lib/helper/extras/React.js

@@ -1,66 +1,65 @@
-const fs = require('fs');
+import fs from 'fs'
 
-let resqScript;
+let resqScript
 
-module.exports = async function findReact(matcher, locator) {
-  if (!resqScript) resqScript = fs.readFileSync(require.resolve('resq'));
-  await matcher.evaluate(resqScript.toString());
-  await matcher
-    .evaluate(() => window.resq.waitToLoadReact());
+export default async function findReact(matcher, locator) {
+  if (!resqScript) resqScript = fs.readFileSync(new URL('resq', import.meta.resolve('resq')).pathname)
+  await matcher.evaluate(resqScript.toString())
+  await matcher.evaluate(() => window.resq.waitToLoadReact())
   const arrayHandle = await matcher.evaluateHandle(
-    (obj) => {
-      const { selector, props, state } = obj;
+    obj => {
+      const { selector, props, state } = obj
 
-      let elements = window.resq.resq$$(selector);
+      let elements = window.resq.resq$$(selector)
       if (Object.keys(props).length) {
-        elements = elements.byProps(props);
+        elements = elements.byProps(props)
       }
       if (Object.keys(state).length) {
-        elements = elements.byState(state);
+        elements = elements.byState(state)
       }
 
       if (!elements.length) {
-        return [];
+        return []
       }
 
       // resq returns an array of HTMLElements if the React component is a fragment
       // this avoids having nested arrays of nodes which the driver does not understand
       // [[div, div], [div, div]] => [div, div, div, div]
-      let nodes = [];
+      let nodes = []
 
-      elements.forEach((element) => {
-        let { node, isFragment } = element;
+      elements.forEach(element => {
+        let { node, isFragment } = element
 
         if (!node) {
-          isFragment = true;
-          node = element.children;
+          isFragment = true
+          node = element.children
         }
 
         if (isFragment) {
-          nodes = nodes.concat(node);
+          nodes = nodes.concat(node)
         } else {
-          nodes.push(node);
+          nodes.push(node)
         }
-      });
+      })
 
-      return [...nodes];
+      return [...nodes]
     },
     {
       selector: locator.react,
       props: locator.props || {},
       state: locator.state || {},
     },
-  );
+  )
 
-  const properties = await arrayHandle.getProperties();
-  await arrayHandle.dispose();
-  const result = [];
+  const properties = await arrayHandle.getProperties()
+  await arrayHandle.dispose()
+  const result = []
   for (const property of properties.values()) {
-    const elementHandle = property.asElement();
+    const elementHandle = property.asElement()
     if (elementHandle) {
-      result.push(elementHandle);
+      result.push(elementHandle)
     }
   }
 
-  return result;
-};
+  return result
+}

package/lib/helper/network/actions.js

@@ -1,33 +1,31 @@
-const assert = require('assert');
-const { isInTraffic, createAdvancedTestResults, getTrafficDump } = require('./utils');
+import assert from 'assert'
+import { isInTraffic, createAdvancedTestResults, getTrafficDump } from './utils.js'
 
 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.`)
   }
 }
 
-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.recordedAtLeastOnce) {
@@ -35,33 +33,26 @@ async function seeTraffic({
   }
 
   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)}`)
   }
 }
 
@@ -70,8 +61,8 @@ async function grabRecordedNetworkTraffics() {
     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 @@ 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,9 +90,9 @@ async function grabRecordedNetworkTraffics() {
         statusText: resp.statusText(),
         body,
       },
-    };
-  });
-  return Promise.all(promises);
+    }
+  })
+  return Promise.all(promises)
 }
 
 function stopRecordingTraffic() {
@@ -113,13 +104,7 @@ function stopRecordingTraffic() {
 }
 
 function flushNetworkTraffics() {
-  this.requests = [];
+  this.requests = []
 }
 
-module.exports = {
-  dontSeeTraffic,
-  seeTraffic,
-  grabRecordedNetworkTraffics,
-  stopRecordingTraffic,
-  flushNetworkTraffics,
-};
+export { dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics }