codeceptjs 4.1.0 → 4.2.0-beta.1

package/lib/helper/Puppeteer.js

@@ -64,6 +64,7 @@ function wrapError(e) {
 let perfTiming
 const popupStore = new Popup()
 const consoleLogStore = new Console()
+const checkableRoles = ['checkbox', 'radio', 'switch']
 
 /**
  * ## Configuration
@@ -560,7 +561,7 @@ class Puppeteer extends Helper {
     page.setDefaultNavigationTimeout(this.options.getPageTimeout)
     this.context = await this.page.$('body')
     if (this.options.browser === 'chrome') {
-      await page.bringToFront()
+      await page.bringToFront().catch(err => this.debugSection('Page', `bringToFront not supported: ${err.message}`))
     }
   }
 
@@ -1714,6 +1715,10 @@ class Puppeteer extends Helper {
     els = await findByRole(comboboxSearchCtx, { role: 'listbox', name: matchedLocator.value })
     if (els?.length) return proceedSelect.call(this, pageContext, selectElement(els, select, this), option)
 
+    // Fuzzy: try radiogroup
+    els = await findByRole(comboboxSearchCtx, { role: 'radiogroup', name: matchedLocator.value })
+    if (els?.length) return proceedSelect.call(this, pageContext, selectElement(els, select, this), option)
+
     // Fuzzy: try native select
     const visibleEls = await findVisibleFields.call(this, select, context)
     assertElementExists(visibleEls, select, 'Selectable field')
@@ -1991,7 +1996,7 @@ class Puppeteer extends Helper {
     const els = await this._locate(locator)
     const texts = []
     for (const el of els) {
-      texts.push(await (await el.getProperty('innerText')).jsonValue())
+      texts.push(await el.evaluate(node => node.innerText))
     }
     return texts
   }
@@ -2501,7 +2506,6 @@ class Puppeteer extends Helper {
    */
   async waitInUrl(urlPart, sec = null) {
     const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
-    const expectedUrl = resolveUrl(urlPart, this.options.url)
 
     return this.page
       .waitForFunction(
@@ -2510,12 +2514,12 @@ class Puppeteer extends Helper {
           return currUrl.indexOf(urlPart) > -1
         },
         { timeout: waitTimeout },
-        expectedUrl,
+        urlPart,
       )
       .catch(async e => {
         const currUrl = await this._getPageUrl()
         if (/Waiting failed:/i.test(e.message) || /failed: timeout/i.test(e.message)) {
-          throw new Error(`expected url to include ${expectedUrl}, but found ${currUrl}`)
+          throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`)
         } else {
           throw e
         }
@@ -3159,14 +3163,14 @@ async function proceedSee(assertType, text, context, strict = false) {
       el = await this.context.$('body')
     }
 
-    allText = [await el.getProperty('innerText').then(p => p.jsonValue())]
+    allText = [await el.evaluate(node => node.innerText)]
     description = 'web application'
   } else {
     const locator = new Locator(context, 'css')
     description = `element ${locator.toString()}`
     const els = await this._locate(locator)
     assertElementExists(els, locator.toString())
-    allText = await Promise.all(els.map(el => el.getProperty('innerText').then(p => p.jsonValue())))
+    allText = await Promise.all(els.map(el => el.evaluate(node => node.innerText)))
   }
 
   if (store?.currentStep?.opts?.ignoreCase === true) {
@@ -3192,8 +3196,19 @@ async function findCheckable(locator, context) {
     return findElements.call(this, contextEl, matchedLocator)
   }
 
+  // Try ARIA selector for accessible name
+  let els
+  for (const role of checkableRoles) {
+    try {
+      els = await contextEl.$$(`::-p-aria([name="${matchedLocator.value}"][role="${role}"])`)
+      if (els.length) return els
+    } catch (err) {
+      // ARIA selector not supported or failed
+    }
+  }
+
   const literal = xpathLocator.literal(matchedLocator.value)
-  let els = await findElements.call(this, contextEl, Locator.checkable.byText(literal))
+  els = await findElements.call(this, contextEl, Locator.checkable.byText(literal))
   if (els.length) {
     return els
   }
@@ -3202,14 +3217,6 @@ async function findCheckable(locator, context) {
     return els
   }
 
-  // Try ARIA selector for accessible name
-  try {
-    els = await contextEl.$$(`::-p-aria(${matchedLocator.value})`)
-    if (els.length) return els
-  } catch (err) {
-    // ARIA selector not supported or failed
-  }
-
   return findElements.call(this, contextEl, matchedLocator.value)
 }
 
@@ -3456,6 +3463,14 @@ async function targetCreatedHandler(page) {
       .catch(() => null)
       .then(context => (this.context = context))
   })
+  page.on('framenavigated', frame => {
+    if (frame.parentFrame()) return
+    if (this.withinLocator) return
+    page
+      .$('body')
+      .catch(() => null)
+      .then(context => (this.context = context))
+  })
   page.on('console', msg => {
     this.debugSection(`Browser:${ucfirst(msg.type())}`, (msg._text || '') + msg.args().join(' '))
     consoleLogStore.add(msg)
@@ -3656,6 +3671,18 @@ async function proceedSelect(context, el, option) {
     return this._waitForAction()
   }
 
+  if (role === 'radiogroup') {
+    if (options.length > 1) throw new Error(`selectOption: a radio group holds one value, but ${options.length} options were passed: ${options.join(', ')}`)
+    const [opt] = options
+    let optEls = await findByRole.call(this, el, { role: 'radio', name: opt, exact: true })
+    if (!optEls?.length) optEls = await findByRole.call(this, el, { role: 'radio', name: opt })
+    if (!optEls?.length) throw new ElementNotFound(opt, 'Option', 'was not found in this radio group')
+    this.debugSection('SelectOption', `Clicking: "${opt}"`)
+    highlightActiveElement.call(this, optEls[0], context)
+    await optEls[0].click()
+    return this._waitForAction()
+  }
+
   // Native <select> element
   const tagName = await el.evaluate(e => e.tagName)
   if (tagName !== 'SELECT') {

package/lib/helper/WebDriver.js

@@ -1329,6 +1329,10 @@ class WebDriver extends Helper {
     els = await this._locateByRole({ role: 'listbox', text: matchedLocator.value })
     if (els?.length) return proceedSelectOption.call(this, selectElement(els, select, this), option)
 
+    // Fuzzy: try radiogroup
+    els = await this._locateByRole({ role: 'radiogroup', text: matchedLocator.value })
+    if (els?.length) return proceedSelectOption.call(this, selectElement(els, select, this), option)
+
     // Fuzzy: try native select
     const res = await findFields.call(this, select, context)
     assertElementExists(res, select, 'Selectable field')
@@ -2521,7 +2525,6 @@ class WebDriver extends Helper {
   async waitInUrl(urlPart, sec = null) {
     const client = this.browser
     const aSec = sec || this.options.waitForTimeoutInSeconds
-    const expectedUrl = resolveUrl(urlPart, this.options.url)
     let currUrl = ''
 
     return client
@@ -2529,7 +2532,7 @@ class WebDriver extends Helper {
         function () {
           return this.getUrl().then(res => {
             currUrl = decodeUrl(res)
-            return currUrl.indexOf(expectedUrl) > -1
+            return currUrl.indexOf(urlPart) > -1
           })
         },
         { timeout: aSec * 1000 },
@@ -2537,7 +2540,7 @@ class WebDriver extends Helper {
       .catch(e => {
         e = wrapError(e)
         if (e.message.indexOf('timeout')) {
-          throw new Error(`expected url to include ${expectedUrl}, but found ${currUrl}`)
+          throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`)
         }
         throw e
       })
@@ -3245,24 +3248,39 @@ async function findCheckable(locator, locateFn) {
   if (locator.isRole()) return locateFn(locator, true)
   if (!locator.isFuzzy()) return locateFn(locator, true)
 
-  const literal = xpathLocator.literal(locator.value)
-  els = await locateFn(Locator.checkable.byText(literal))
-  if (els.length) return els
-
   // Try ARIA selector for accessible name
   try {
-    els = await locateFn(`aria/${locator.value}`)
+    els = await keepCheckable.call(this, await locateFn(`aria/${locator.value}`))
     if (els.length) return els
   } catch (e) {
     // ARIA selector not supported or failed
   }
 
+  const literal = xpathLocator.literal(locator.value)
+  els = await locateFn(Locator.checkable.byText(literal))
+  if (els.length) return els
+
   els = await locateFn(Locator.checkable.byName(literal))
   if (els.length) return els
 
   return await locateFn(locator.value) // by css or xpath
 }
 
+async function keepCheckable(els) {
+  if (!els || !els.length) return []
+
+  const checkable = await this.browser.execute(function () {
+    return Array.prototype.slice.call(arguments).map(function (el) {
+      if (!el) return false
+      const role = el.getAttribute('role')
+      if (role) return ['checkbox', 'radio', 'switch'].indexOf(role) > -1
+      return el.tagName === 'INPUT' && (el.type === 'checkbox' || el.type === 'radio')
+    })
+  }, ...els)
+
+  return els.filter((el, index) => checkable[index])
+}
+
 function withStrictLocator(locator) {
   locator = new Locator(locator)
   return locator.simplify()
@@ -3562,6 +3580,23 @@ async function proceedSelectOption(elem, option) {
     return
   }
 
+  if (role === 'radiogroup') {
+    if (options.length > 1) throw new Error(`selectOption: a radio group holds one value, but ${options.length} options were passed: ${options.join(', ')}`)
+    const [opt] = options
+    const radios = await this.browser.findElementsFromElement(elementId, 'xpath', `.//*[@role="radio"]`)
+    const names = []
+    for (const radio of radios) {
+      names.push(await getElementTextAttributes.call(this, radio))
+    }
+    let index = names.findIndex(texts => texts.some(text => text && text.trim() === opt))
+    if (index === -1) index = names.findIndex(texts => texts.some(text => text && text.includes(opt)))
+    if (index === -1) throw new ElementNotFound(opt, 'Option', 'was not found in this radio group')
+    this.debugSection('SelectOption', `Clicking: "${opt}"`)
+    highlightActiveElement.call(this, radios[index])
+    await this.browser.elementClick(getElementId(radios[index]))
+    return
+  }
+
   // Native <select> element
   highlightActiveElement.call(this, elem)