codeceptjs 4.0.0-rc.2 → 4.0.0-rc.7

package/lib/helper/WebDriver.js

@@ -1,5 +1,6 @@
 let webdriverio
 
+import fs from 'fs'
 import assert from 'assert'
 import path from 'path'
 import crypto from 'crypto'
@@ -13,7 +14,20 @@ import output from '../output.js'
 const { debug } = output
 import { empty } from '../assert/empty.js'
 import { truth } from '../assert/truth.js'
-import { xpathLocator, fileExists, decodeUrl, chunkArray, convertCssPropertiesToCamelCase, screenshotOutputFolder, getNormalizedKeyAttributeValue, modifierKeys } from '../utils.js'
+import {
+  xpathLocator,
+  fileExists,
+  decodeUrl,
+  chunkArray,
+  convertCssPropertiesToCamelCase,
+  screenshotOutputFolder,
+  getNormalizedKeyAttributeValue,
+  modifierKeys,
+  normalizePath,
+  resolveUrl,
+  getMimeType,
+  base64EncodeFile,
+} from '../utils.js'
 import { isColorProperty, convertColorToRGBA } from '../colorUtils.js'
 import ElementNotFound from './errors/ElementNotFound.js'
 import ConnectionRefused from './errors/ConnectionRefused.js'
@@ -1255,8 +1269,8 @@ class WebDriver extends Helper {
    * {{ custom }}
    *
    */
-  async fillField(field, value) {
-    const res = await findFields.call(this, field)
+  async fillField(field, value, context = null) {
+    const res = await findFields.call(this, field, context)
     assertElementExists(res, field, 'Field')
     const elem = usingFirstElement(res)
     highlightActiveElement.call(this, elem)
@@ -1278,8 +1292,8 @@ class WebDriver extends Helper {
    * {{> appendField }}
    * {{ react }}
    */
-  async appendField(field, value) {
-    const res = await findFields.call(this, field)
+  async appendField(field, value, context = null) {
+    const res = await findFields.call(this, field, context)
     assertElementExists(res, field, 'Field')
     const elem = usingFirstElement(res)
     highlightActiveElement.call(this, elem)
@@ -1290,8 +1304,8 @@ class WebDriver extends Helper {
    * {{> clearField }}
    *
    */
-  async clearField(field) {
-    const res = await findFields.call(this, field)
+  async clearField(field, context = null) {
+    const res = await findFields.call(this, field, context)
     assertElementExists(res, field, 'Field')
     const elem = usingFirstElement(res)
     highlightActiveElement.call(this, elem)
@@ -1301,13 +1315,14 @@ class WebDriver extends Helper {
   /**
    * {{> selectOption }}
    */
-  async selectOption(select, option) {
+  async selectOption(select, option, context = null) {
+    const locateFn = prepareLocateFn.call(this, context)
     const matchedLocator = new Locator(select)
 
     // Strict locator
     if (!matchedLocator.isFuzzy()) {
       this.debugSection('SelectOption', `Strict: ${JSON.stringify(select)}`)
-      const els = await this._locate(select)
+      const els = await locateFn(select)
       assertElementExists(els, select, 'Selectable element')
       return proceedSelectOption.call(this, usingFirstElement(els), option)
     }
@@ -1322,7 +1337,7 @@ class WebDriver extends Helper {
     if (els?.length) return proceedSelectOption.call(this, usingFirstElement(els), option)
 
     // Fuzzy: try native select
-    const res = await findFields.call(this, select)
+    const res = await findFields.call(this, select, context)
     assertElementExists(res, select, 'Selectable field')
     return proceedSelectOption.call(this, usingFirstElement(res), option)
   }
@@ -1332,28 +1347,49 @@ class WebDriver extends Helper {
    *
    * {{> attachFile }}
    */
-  async attachFile(locator, pathToFile) {
+  async attachFile(locator, pathToFile, context = null) {
     let file = path.join(global.codecept_dir, pathToFile)
     if (!fileExists(file)) {
       throw new Error(`File at ${file} can not be found on local system`)
     }
 
-    const res = await findFields.call(this, locator)
+    const res = await findFields.call(this, locator, context)
     this.debug(`Uploading ${file}`)
-    assertElementExists(res, locator, 'File field')
-    const el = usingFirstElement(res)
 
-    // Remote Upload (when running Selenium Server)
-    if (this.options.remoteFileUpload) {
-      try {
-        this.debugSection('File', 'Uploading file to remote server')
-        file = await this.browser.uploadFile(file)
-      } catch (err) {
-        throw new Error(`File can't be transferred to remote server. Set \`remoteFileUpload: false\` in config to upload file locally.\n${err.message}`)
+    if (res.length) {
+      const el = usingFirstElement(res)
+      const tag = await this.browser.execute(function (elem) { return elem.tagName }, el)
+      const type = await this.browser.execute(function (elem) { return elem.type }, el)
+      if (tag === 'INPUT' && type === 'file') {
+        if (this.options.remoteFileUpload) {
+          try {
+            this.debugSection('File', 'Uploading file to remote server')
+            file = await this.browser.uploadFile(file)
+          } catch (err) {
+            throw new Error(`File can't be transferred to remote server. Set \`remoteFileUpload: false\` in config to upload file locally.\n${err.message}`)
+          }
+        }
+        return el.addValue(file)
       }
     }
 
-    return el.addValue(file)
+    const targetRes = res.length ? res : await this._locate(locator)
+    assertElementExists(targetRes, locator, 'Element')
+    const targetEl = usingFirstElement(targetRes)
+    const base64Content = base64EncodeFile(file)
+    const fileName = path.basename(file)
+    const mimeType = getMimeType(fileName)
+    return this.browser.execute(function (el, data) {
+      var binaryStr = atob(data.base64Content)
+      var bytes = new Uint8Array(binaryStr.length)
+      for (var i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i)
+      var fileObj = new File([bytes], data.fileName, { type: data.mimeType })
+      var dataTransfer = new DataTransfer()
+      dataTransfer.items.add(fileObj)
+      el.dispatchEvent(new DragEvent('dragenter', { dataTransfer: dataTransfer, bubbles: true }))
+      el.dispatchEvent(new DragEvent('dragover', { dataTransfer: dataTransfer, bubbles: true }))
+      el.dispatchEvent(new DragEvent('drop', { dataTransfer: dataTransfer, bubbles: true }))
+    }, targetEl, { base64Content, fileName, mimeType })
   }
 
   /**
@@ -1586,18 +1622,18 @@ class WebDriver extends Helper {
    * {{> seeInField }}
    *
    */
-  async seeInField(field, value) {
+  async seeInField(field, value, context = null) {
     const _value = typeof value === 'boolean' ? value : value.toString()
-    return proceedSeeField.call(this, 'assert', field, _value)
+    return proceedSeeField.call(this, 'assert', field, _value, context)
   }
 
   /**
    * {{> dontSeeInField }}
    *
    */
-  async dontSeeInField(field, value) {
+  async dontSeeInField(field, value, context = null) {
     const _value = typeof value === 'boolean' ? value : value.toString()
-    return proceedSeeField.call(this, 'negate', field, _value)
+    return proceedSeeField.call(this, 'negate', field, _value, context)
   }
 
   /**
@@ -1621,8 +1657,9 @@ class WebDriver extends Helper {
    * {{ react }}
    *
    */
-  async seeElement(locator) {
-    const res = await this._locate(locator, true)
+  async seeElement(locator, context = null) {
+    const locateFn = prepareLocateFn.call(this, context)
+    const res = context ? await locateFn(locator) : await this._locate(locator, true)
     assertElementExists(res, locator)
     const selected = await forEachAsync(res, async el => el.isDisplayed())
     try {
@@ -1636,8 +1673,9 @@ class WebDriver extends Helper {
    * {{> dontSeeElement }}
    * {{ react }}
    */
-  async dontSeeElement(locator) {
-    const res = await this._locate(locator, false)
+  async dontSeeElement(locator, context = null) {
+    const locateFn = prepareLocateFn.call(this, context)
+    const res = context ? await locateFn(locator) : await this._locate(locator, false)
     if (!res || res.length === 0) {
       return truth(`elements of ${new Locator(locator)}`, 'to be seen').negate(false)
     }
@@ -1851,7 +1889,7 @@ class WebDriver extends Helper {
     const currentUrl = await this.browser.getUrl()
     const baseUrl = this.options.url || 'http://localhost'
     const actualPath = new URL(currentUrl, baseUrl).pathname
-    return equals('url path').assert(path, actualPath)
+    return equals('url path').assert(normalizePath(path), normalizePath(actualPath))
   }
 
   /**
@@ -1861,7 +1899,7 @@ class WebDriver extends Helper {
     const currentUrl = await this.browser.getUrl()
     const baseUrl = this.options.url || 'http://localhost'
     const actualPath = new URL(currentUrl, baseUrl).pathname
-    return equals('url path').negate(path, actualPath)
+    return equals('url path').negate(normalizePath(path), normalizePath(actualPath))
   }
 
   /**
@@ -2487,6 +2525,7 @@ 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
@@ -2494,7 +2533,7 @@ class WebDriver extends Helper {
         function () {
           return this.getUrl().then(res => {
             currUrl = decodeUrl(res)
-            return currUrl.indexOf(urlPart) > -1
+            return currUrl.indexOf(expectedUrl) > -1
           })
         },
         { timeout: aSec * 1000 },
@@ -2502,7 +2541,7 @@ class WebDriver extends Helper {
       .catch(e => {
         e = wrapError(e)
         if (e.message.indexOf('timeout')) {
-          throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`)
+          throw new Error(`expected url to include ${expectedUrl}, but found ${currUrl}`)
         }
         throw e
       })
@@ -2513,22 +2552,47 @@ class WebDriver extends Helper {
    */
   async waitUrlEquals(urlPart, sec = null) {
     const aSec = sec || this.options.waitForTimeoutInSeconds
-    const baseUrl = this.options.url
-    if (urlPart.indexOf('http') < 0) {
-      urlPart = baseUrl + urlPart
-    }
+    const expectedUrl = resolveUrl(urlPart, this.options.url)
     let currUrl = ''
     return this.browser
       .waitUntil(function () {
         return this.getUrl().then(res => {
           currUrl = decodeUrl(res)
-          return currUrl === urlPart
+          return currUrl === expectedUrl
         })
       }, aSec * 1000)
       .catch(e => {
         e = wrapError(e)
         if (e.message.indexOf('timeout')) {
-          throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`)
+          throw new Error(`expected url to be ${expectedUrl}, but found ${currUrl}`)
+        }
+        throw e
+      })
+  }
+
+  /**
+   * {{> waitCurrentPathEquals }}
+   */
+  async waitCurrentPathEquals(path, sec = null) {
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const normalizedPath = normalizePath(path)
+    const baseUrl = this.options.url || 'http://localhost'
+    let actualPath = ''
+
+    return this.browser
+      .waitUntil(
+        async () => {
+          const currUrl = await this.browser.getUrl()
+          const url = new URL(currUrl, baseUrl)
+          actualPath = url.pathname
+          return normalizePath(actualPath) === normalizedPath
+        },
+        { timeout: aSec * 1000 },
+      )
+      .catch(e => {
+        e = wrapError(e)
+        if (e.message.indexOf('timeout')) {
+          throw new Error(`expected path to be ${normalizedPath}, but found ${normalizePath(actualPath)}`)
         }
         throw e
       })
@@ -3010,32 +3074,33 @@ async function findClickable(locator, locateFn) {
   return await locateFn(locator.value) // by css or xpath
 }
 
-async function findFields(locator) {
+async function findFields(locator, context = null) {
+  const locateFn = prepareLocateFn.call(this, context)
   locator = new Locator(locator)
 
   if (this._isCustomLocator(locator)) {
-    return this._locate(locator)
+    return locateFn(locator)
   }
 
-  if (locator.isAccessibilityId() && !this.isWeb) return this._locate(locator, true)
-  if (locator.isRole()) return this._locate(locator, true)
-  if (!locator.isFuzzy()) return this._locate(locator, true)
+  if (locator.isAccessibilityId() && !this.isWeb) return locateFn(locator)
+  if (locator.isRole()) return locateFn(locator)
+  if (!locator.isFuzzy()) return locateFn(locator)
 
   const literal = xpathLocator.literal(locator.value)
-  let els = await this._locate(Locator.field.labelEquals(literal))
+  let els = await locateFn(Locator.field.labelEquals(literal))
   if (els.length) return els
 
-  els = await this._locate(Locator.field.labelContains(literal))
+  els = await locateFn(Locator.field.labelContains(literal))
   if (els.length) return els
 
-  els = await this._locate(Locator.field.byName(literal))
+  els = await locateFn(Locator.field.byName(literal))
   if (els.length) return els
 
-  return await this._locate(locator.value) // by css or xpath
+  return await locateFn(locator.value) // by css or xpath
 }
 
-async function proceedSeeField(assertType, field, value) {
-  const res = await findFields.call(this, field)
+async function proceedSeeField(assertType, field, value, context) {
+  const res = await findFields.call(this, field, context)
   assertElementExists(res, field, 'Field')
   const elem = usingFirstElement(res)
   const elemId = getElementId(elem)

package/lib/listener/globalRetry.js

@@ -5,16 +5,27 @@ import { isNotSet } from '../utils.js'
 
 const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
 
+const RETRY_PRIORITIES = {
+  MANUAL_STEP: 100,
+  STEP_PLUGIN: 50,
+  SCENARIO_CONFIG: 30,
+  FEATURE_CONFIG: 20,
+  HOOK_CONFIG: 10,
+}
+
 export default function () {
   event.dispatcher.on(event.suite.before, suite => {
     let retryConfig = Config.get('retry')
     if (!retryConfig) return
 
     if (Number.isInteger(+retryConfig)) {
-      // is number
       const retryNum = +retryConfig
       output.log(`Retries: ${retryNum}`)
-      suite.retries(retryNum)
+
+      if (suite.retries() === -1 || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
+        suite.retries(retryNum)
+        suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+      }
       return
     }
 
@@ -30,11 +41,18 @@ export default function () {
       hooks
         .filter(hook => !!config[hook])
         .forEach(hook => {
-          if (isNotSet(suite.opts[`retry${hook}`])) suite.opts[`retry${hook}`] = config[hook]
+          const retryKey = `retry${hook}`
+          if (isNotSet(suite.opts[retryKey])) {
+            suite.opts[retryKey] = config[hook]
+            suite.opts[`${retryKey}Priority`] = RETRY_PRIORITIES.HOOK_CONFIG
+          }
         })
 
       if (config.Feature) {
-        if (isNotSet(suite.retries())) suite.retries(config.Feature)
+        if (suite.retries() === -1 || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
+          suite.retries(config.Feature)
+          suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+        }
       }
 
       output.log(`Retries: ${JSON.stringify(config)}`)
@@ -46,7 +64,10 @@ export default function () {
     if (!retryConfig) return
 
     if (Number.isInteger(+retryConfig)) {
-      if (test.retries() === -1) test.retries(retryConfig)
+      if (test.retries() === -1) {
+        test.retries(retryConfig)
+        test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+      }
       return
     }
 
@@ -62,9 +83,14 @@ export default function () {
       }
 
       if (config.Scenario) {
-        if (test.retries() === -1) test.retries(config.Scenario)
+        if (test.retries() === -1 || (test.opts.retryPriority || 0) <= RETRY_PRIORITIES.SCENARIO_CONFIG) {
+          test.retries(config.Scenario)
+          test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+        }
         output.log(`Retries: ${config.Scenario}`)
       }
     }
   })
 }
+
+export { RETRY_PRIORITIES }