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

package/lib/helper/errors/ConnectionRefused.js

@@ -1,10 +1,10 @@
 function ConnectionRefused(err) {
-  this.message = "Can't connect to WebDriver.\n";
-  this.message += `${err}\n\n`;
-  this.message += 'Please make sure Selenium Server is running and accessible';
-  this.stack = err.stack;
+  this.message = "Can't connect to WebDriver.\n"
+  this.message += `${err}\n\n`
+  this.message += 'Please make sure Selenium Server is running and accessible'
+  this.stack = err.stack
 }
 
-ConnectionRefused.prototype = Object.create(Error.prototype);
+ConnectionRefused.prototype = Object.create(Error.prototype)
 
-export default ConnectionRefused;
+export default ConnectionRefused

package/lib/helper/errors/ElementAssertion.js

@@ -1,38 +1,33 @@
-import Locator from '../../locator.js';
+import Locator from '../../locator.js'
 
-const prefixMessage = 'Element';
+const prefixMessage = 'Element'
 
 function seeElementError(locator) {
   if (typeof locator === 'object') {
-    locator = JSON.stringify(locator);
+    locator = JSON.stringify(locator)
   }
-  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is still visible on page.`);
+  throw new Error(`${prefixMessage} "${new Locator(locator)}" is still visible on page.`)
 }
 
 function seeElementInDOMError(locator) {
   if (typeof locator === 'object') {
-    locator = JSON.stringify(locator);
+    locator = JSON.stringify(locator)
   }
-  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is still seen in DOM.`);
+  throw new Error(`${prefixMessage} "${new Locator(locator)}" is still seen in DOM.`)
 }
 
 function dontSeeElementError(locator) {
   if (typeof locator === 'object') {
-    locator = JSON.stringify(locator);
+    locator = JSON.stringify(locator)
   }
-  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is not visible on page.`);
+  throw new Error(`${prefixMessage} "${new Locator(locator)}" is not visible on page.`)
 }
 
 function dontSeeElementInDOMError(locator) {
   if (typeof locator === 'object') {
-    locator = JSON.stringify(locator);
+    locator = JSON.stringify(locator)
   }
-  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is not seen in DOM.`);
+  throw new Error(`${prefixMessage} "${new Locator(locator)}" is not seen in DOM.`)
 }
 
-export {
-  seeElementError,
-  dontSeeElementError,
-  seeElementInDOMError,
-  dontSeeElementInDOMError,
-};
+export { seeElementError, dontSeeElementError, seeElementInDOMError, dontSeeElementInDOMError }

package/lib/helper/errors/ElementNotFound.js

@@ -1,19 +1,15 @@
-import Locator from '../../locator.js';
+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}`)
   }
 }
 
-export default 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)
 
-export default 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)
   }
 }
 
-export default 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

@@ -2,54 +2,54 @@ export const createValueEngine = () => {
   return {
     // Creates a selector that matches given target when queried at the root.
     // Can return undefined if unable to create one.
-    // eslint-disable-next-line no-unused-vars
+
     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
     },
-  };
-};
+  }
+}
 
 export const createDisabledEngine = () => {
   return {
     // Creates a selector that matches given target when queried at the root.
     // Can return undefined if unable to create one.
-    // eslint-disable-next-line no-unused-vars
+
     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) {

package/lib/helper/extras/PlaywrightRestartOpts.js

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

package/lib/helper/extras/Popup.js

@@ -2,66 +2,66 @@
  * Class to handle the interaction with the Dialog (Popup) Class from Puppeteer
  */
 class Popup {
-  constructor(popup, defaultAction) {
-    this._popup = popup || null;
-    this._actionType = '';
-    this._defaultAction = defaultAction || '';
+  constructor(popup = null, defaultAction = '') {
+    this._popup = popup
+    this._actionType = ''
+    this._defaultAction = defaultAction
   }
 
   _assertValidActionType(action) {
     if (['accept', 'cancel'].indexOf(action) === -1) {
-      throw new Error('Invalid Popup action type. Only "accept" or "cancel" actions are accepted');
+      throw new Error('Invalid Popup action type. Only "accept" or "cancel" actions are accepted')
     }
   }
 
   set defaultAction(action) {
-    this._assertValidActionType(action);
-    this._defaultAction = action;
+    this._assertValidActionType(action)
+    this._defaultAction = action
   }
 
   get defaultAction() {
-    return this._defaultAction;
+    return this._defaultAction
   }
 
   get popup() {
-    return this._popup;
+    return this._popup
   }
 
   set popup(popup) {
     if (this._popup) {
-      console.error('Popup already exists and was not closed. Popups must always be closed by calling either I.acceptPopup() or I.cancelPopup()');
+      return
     }
-    this._popup = popup;
+    this._popup = popup
   }
 
   get actionType() {
-    return this._actionType;
+    return this._actionType
   }
 
   set actionType(action) {
-    this._assertValidActionType(action);
-    this._actionType = action;
+    this._assertValidActionType(action)
+    this._actionType = action
   }
 
   clear() {
-    this._popup = null;
-    this._actionType = '';
+    this._popup = null
+    this._actionType = ''
   }
 
   assertPopupVisible() {
     if (!this._popup) {
-      throw new Error('There is no Popup visible');
+      throw new Error('There is no Popup visible')
     }
   }
 
   assertPopupActionType(type) {
-    this.assertPopupVisible();
-    const expectedAction = this._actionType || this._defaultAction;
+    this.assertPopupVisible()
+    const expectedAction = this._actionType || this._defaultAction
     if (expectedAction !== type) {
-      throw new Error(`Popup action does not fit the expected action type. Expected popup action to be '${expectedAction}' not '${type}`);
+      throw new Error(`Popup action does not fit the expected action type. Expected popup action to be '${expectedAction}' not '${type}`)
     }
-    this.clear();
+    this.clear()
   }
 }
 
-export default Popup;
+export default Popup

package/lib/helper/extras/React.js

@@ -1,66 +1,65 @@
-import fs from 'fs';
+import fs from 'fs'
 
-let resqScript;
+let resqScript
 
 export default async function findReact(matcher, locator) {
-  if (!resqScript) resqScript = fs.readFileSync(require.resolve('resq'));
-  await matcher.evaluate(resqScript.toString());
-  await matcher
-    .evaluate(() => window.resq.waitToLoadReact());
+  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
 }