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

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/PlaywrightRestartOpts.js

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

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,77 +1,68 @@
-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.recording || !this.recordedAtLeastOnce) {
-    throw new Error('Failure in test automation. You use "I.seeTraffic", but "I.startRecordingTraffic" was never called before.');
+    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)}`)
   }
 }
 
 async function grabRecordedNetworkTraffics() {
   if (!this.recording || !this.recordedAtLeastOnce) {
-    throw new Error('Failure in test automation. You use "I.grabRecordedNetworkTraffics", but "I.startRecordingTraffic" was never called before.');
+    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,25 +90,19 @@ async function grabRecordedNetworkTraffics() {
         statusText: resp.statusText(),
         body,
       },
-    };
-  });
-  return Promise.all(promises);
+    }
+  })
+  return Promise.all(promises)
 }
 
 function stopRecordingTraffic() {
   // @ts-ignore
-  this.page.removeAllListeners('request');
-  this.recording = false;
+  this.page.removeAllListeners('request')
+  this.recording = false
 }
 
 function flushNetworkTraffics() {
-  this.requests = [];
+  this.requests = []
 }
 
-module.exports = {
-  dontSeeTraffic,
-  seeTraffic,
-  grabRecordedNetworkTraffics,
-  stopRecordingTraffic,
-  flushNetworkTraffics,
-};
+export { dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics }