codeceptjs 4.0.0-beta.3 → 4.0.0-beta.5

package/lib/helper/JSONResponse.js

@@ -1,12 +1,5 @@
 const Helper = require('@codeceptjs/helper')
-
-let expect
-
-import('chai').then((chai) => {
-  expect = chai.expect
-  chai.use(require('chai-deep-match'))
-})
-
+const assert = require('assert')
 const joi = require('joi')
 
 /**
@@ -77,12 +70,10 @@ class JSONResponse extends Helper {
   _beforeSuite() {
     this.response = null
     if (!this.helpers[this.options.requestHelper]) {
-      throw new Error(
-        `Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`,
-      )
+      throw new Error(`Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`)
     }
     // connect to REST helper
-    this.helpers[this.options.requestHelper].config.onResponse = (response) => {
+    this.helpers[this.options.requestHelper].config.onResponse = response => {
       this.response = response
     }
   }
@@ -110,7 +101,7 @@ class JSONResponse extends Helper {
    */
   seeResponseCodeIs(code) {
     this._checkResponseReady()
-    expect(this.response.status).to.eql(code, 'Response code is not the same as expected')
+    assert.strictEqual(this.response.status, code, 'Response code is not the same as expected')
   }
 
   /**
@@ -124,7 +115,7 @@ class JSONResponse extends Helper {
    */
   dontSeeResponseCodeIs(code) {
     this._checkResponseReady()
-    expect(this.response.status).not.to.eql(code)
+    assert.notStrictEqual(this.response.status, code)
   }
 
   /**
@@ -132,8 +123,7 @@ class JSONResponse extends Helper {
    */
   seeResponseCodeIsClientError() {
     this._checkResponseReady()
-    expect(this.response.status).to.be.gte(400)
-    expect(this.response.status).to.be.lt(500)
+    assert(this.response.status >= 400 && this.response.status < 500)
   }
 
   /**
@@ -141,8 +131,7 @@ class JSONResponse extends Helper {
    */
   seeResponseCodeIsRedirection() {
     this._checkResponseReady()
-    expect(this.response.status).to.be.gte(300)
-    expect(this.response.status).to.be.lt(400)
+    assert(this.response.status >= 300 && this.response.status < 400)
   }
 
   /**
@@ -150,8 +139,7 @@ class JSONResponse extends Helper {
    */
   seeResponseCodeIsServerError() {
     this._checkResponseReady()
-    expect(this.response.status).to.be.gte(500)
-    expect(this.response.status).to.be.lt(600)
+    assert(this.response.status >= 500 && this.response.status < 600)
   }
 
   /**
@@ -164,8 +152,7 @@ class JSONResponse extends Helper {
    */
   seeResponseCodeIsSuccessful() {
     this._checkResponseReady()
-    expect(this.response.status).to.be.gte(200)
-    expect(this.response.status).to.be.lt(300)
+    assert(this.response.status >= 200 && this.response.status < 300)
   }
 
   /**
@@ -188,17 +175,19 @@ class JSONResponse extends Helper {
   seeResponseContainsJson(json = {}) {
     this._checkResponseReady()
     if (Array.isArray(this.response.data)) {
-      let fails = 0
+      let found = false
       for (const el of this.response.data) {
         try {
-          expect(el).to.deep.match(json)
+          this._assertContains(el, json)
+          found = true
+          break
         } catch (err) {
-          fails++
+          continue
         }
       }
-      expect(fails < this.response.data.length, `No elements in array matched ${JSON.stringify(json)}`).to.be.true
+      assert(found, `No elements in array matched ${JSON.stringify(json)}`)
     } else {
-      expect(this.response.data).to.deep.match(json)
+      this._assertContains(this.response.data, json)
     }
   }
 
@@ -222,9 +211,22 @@ class JSONResponse extends Helper {
   dontSeeResponseContainsJson(json = {}) {
     this._checkResponseReady()
     if (Array.isArray(this.response.data)) {
-      this.response.data.forEach((data) => expect(data).not.to.deep.match(json))
+      for (const data of this.response.data) {
+        try {
+          this._assertContains(data, json)
+          assert.fail(`Found matching element: ${JSON.stringify(data)}`)
+        } catch (err) {
+          // expected to fail
+          continue
+        }
+      }
     } else {
-      expect(this.response.data).not.to.deep.match(json)
+      try {
+        this._assertContains(this.response.data, json)
+        assert.fail('Response contains the JSON')
+      } catch (err) {
+        // expected to fail
+      }
     }
   }
 
@@ -250,20 +252,27 @@ class JSONResponse extends Helper {
   seeResponseContainsKeys(keys = []) {
     this._checkResponseReady()
     if (Array.isArray(this.response.data)) {
-      this.response.data.forEach((data) => expect(data).to.include.keys(keys))
+      for (const data of this.response.data) {
+        for (const key of keys) {
+          assert(key in data, `Key "${key}" is not found in ${JSON.stringify(data)}`)
+        }
+      }
     } else {
-      expect(this.response.data).to.include.keys(keys)
+      for (const key of keys) {
+        assert(key in this.response.data, `Key "${key}" is not found in ${JSON.stringify(this.response.data)}`)
+      }
     }
   }
 
   /**
-   * Executes a callback function passing in `response` object and chai assertions with `expect`
+   * Executes a callback function passing in `response` object and assert
    * Use it to perform custom checks of response data
    *
    * ```js
-   * I.seeResponseValidByCallback(({ data, status, expect }) => {
-   *   expect(status).to.eql(200);
-   *   expect(data).keys.to.include(['user', 'company']);
+   * I.seeResponseValidByCallback(({ data, status }) => {
+   *   assert.strictEqual(status, 200);
+   *   assert('user' in data);
+   *   assert('company' in data);
    * });
    * ```
    *
@@ -271,7 +280,7 @@ class JSONResponse extends Helper {
    */
   seeResponseValidByCallback(fn) {
     this._checkResponseReady()
-    fn({ ...this.response, expect })
+    fn({ ...this.response, assert })
     const body = fn.toString()
     fn.toString = () => `${body.split('\n')[1]}...`
   }
@@ -288,7 +297,7 @@ class JSONResponse extends Helper {
    */
   seeResponseEquals(resp) {
     this._checkResponseReady()
-    expect(this.response.data).to.deep.equal(resp)
+    assert.deepStrictEqual(this.response.data, resp)
   }
 
   /**
@@ -335,6 +344,35 @@ class JSONResponse extends Helper {
   _checkResponseReady() {
     if (!this.response) throw new Error('Response is not available')
   }
+
+  _assertContains(actual, expected) {
+    for (const key in expected) {
+      assert(key in actual, `Key "${key}" not found in ${JSON.stringify(actual)}`)
+      if (typeof expected[key] === 'object' && expected[key] !== null) {
+        if (Array.isArray(expected[key])) {
+          // Handle array comparison: each expected element should have a match in actual array
+          assert(Array.isArray(actual[key]), `Expected array for key "${key}", but got ${typeof actual[key]}`)
+          for (const expectedItem of expected[key]) {
+            let found = false
+            for (const actualItem of actual[key]) {
+              try {
+                this._assertContains(actualItem, expectedItem)
+                found = true
+                break
+              } catch (err) {
+                continue
+              }
+            }
+            assert(found, `No matching element found in array for ${JSON.stringify(expectedItem)}`)
+          }
+        } else {
+          this._assertContains(actual[key], expected[key])
+        }
+      } else {
+        assert.deepStrictEqual(actual[key], expected[key], `Values for key "${key}" don't match`)
+      }
+    }
+  }
 }
 
 module.exports = JSONResponse

package/lib/helper/Mochawesome.js

@@ -1,9 +1,9 @@
-let addMochawesomeContext
 let currentTest
 let currentSuite
 
 const Helper = require('@codeceptjs/helper')
 const { clearString } = require('../utils')
+const { testToFileName } = require('../mocha/test')
 
 class Mochawesome extends Helper {
   constructor(config) {
@@ -15,7 +15,8 @@ class Mochawesome extends Helper {
       disableScreenshots: false,
     }
 
-    addMochawesomeContext = require('mochawesome/addContext')
+    this._addContext = require('mochawesome/addContext')
+
     this._createConfig(config)
   }
 
@@ -36,35 +37,56 @@ class Mochawesome extends Helper {
   }
 
   _test(test) {
-    currentTest = { test }
+    // If this is a retried test, we want to add context to the retried test
+    // but also potentially preserve context from the original test
+    const originalTest = test.retriedTest && test.retriedTest()
+    if (originalTest) {
+      // This is a retried test - use the retried test for context
+      currentTest = { test }
+
+      // Optionally copy context from original test if it exists
+      // Note: mochawesome context is stored in test.ctx, but we need to be careful
+      // not to break the mocha context structure
+    } else {
+      // Normal test (not a retry)
+      currentTest = { test }
+    }
   }
 
   _failed(test) {
     if (this.options.disableScreenshots) return
     let fileName
     // Get proper name if we are fail on hook
-    if (test.ctx.test.type === 'hook') {
+    if (test.ctx?.test?.type === 'hook') {
       currentTest = { test: test.ctx.test }
       // ignore retries if we are in hook
       test._retries = -1
       fileName = clearString(`${test.title}_${currentTest.test.title}`)
     } else {
       currentTest = { test }
-      fileName = clearString(test.title)
+      fileName = testToFileName(test)
     }
     if (this.options.uniqueScreenshotNames) {
-      const uuid = test.uuid || test.ctx.test.uuid
-      fileName = `${fileName.substring(0, 10)}_${uuid}`
+      fileName = testToFileName(test, { unique: true })
     }
     if (test._retries < 1 || test._retries === test.retryNum) {
       fileName = `${fileName}.failed.png`
-      return addMochawesomeContext(currentTest, fileName)
+      return this._addContext(currentTest, fileName)
     }
   }
 
   addMochawesomeContext(context) {
     if (currentTest === '') currentTest = { test: currentSuite.ctx.test }
-    return addMochawesomeContext(currentTest, context)
+
+    // For retried tests, make sure we're adding context to the current (retried) test
+    // not the original test
+    let targetTest = currentTest
+    if (currentTest.test && currentTest.test.retriedTest && currentTest.test.retriedTest()) {
+      // This test has been retried, make sure we're using the current test for context
+      targetTest = { test: currentTest.test }
+    }
+
+    return this._addContext(targetTest, context)
   }
 }
 

package/lib/helper/Nightmare.js

@@ -111,13 +111,7 @@ class Nightmare extends Helper {
       const by = Object.keys(locator)[0]
       const value = locator[by]
 
-      this.evaluate_now(
-        (by, locator, contextEl) => window.codeceptjs.findAndStoreElements(by, locator, contextEl),
-        done,
-        by,
-        value,
-        contextEl,
-      )
+      this.evaluate_now((by, locator, contextEl) => window.codeceptjs.findAndStoreElements(by, locator, contextEl), done, by, value, contextEl)
     })
 
     this.Nightmare.action('findElement', function (locator, contextEl, done) {
@@ -244,7 +238,7 @@ class Nightmare extends Helper {
                     nodeId: queryResult.nodeId,
                     files: pathsToUpload,
                   },
-                  (err) => {
+                  err => {
                     if (Object.keys(err).length > 0) {
                       parent.emit('log', 'problem setting input', err)
                       return done(err)
@@ -351,7 +345,7 @@ class Nightmare extends Helper {
     const outputFile = path.join(global.output_dir, fileName)
     this.debug(`HAR is saving to ${outputFile}`)
 
-    await this.browser.getHAR().then((har) => {
+    await this.browser.getHAR().then(har => {
       require('fs').writeFileSync(outputFile, JSON.stringify({ log: har }))
     })
   }
@@ -361,7 +355,7 @@ class Nightmare extends Helper {
   }
 
   async _stopBrowser() {
-    return this.browser.end().catch((error) => {
+    return this.browser.end().catch(error => {
       this.debugSection('Error on End', error)
     })
   }
@@ -445,7 +439,7 @@ class Nightmare extends Helper {
       // navigating to the same url will cause an error in nightmare, so don't do it
       return
     }
-    return this.browser.goto(url, headers).then((res) => {
+    return this.browser.goto(url, headers).then(res => {
       this.debugSection('URL', res.url)
       this.debugSection('Code', res.code)
       this.debugSection('Headers', JSON.stringify(res.headers))
@@ -535,7 +529,7 @@ class Nightmare extends Helper {
     locator = new Locator(locator, 'css')
     const num = await this.browser.evaluate(
       (by, locator) => {
-        return window.codeceptjs.findElements(by, locator).filter((e) => e.offsetWidth > 0 && e.offsetHeight > 0).length
+        return window.codeceptjs.findElements(by, locator).filter(e => e.offsetWidth > 0 && e.offsetHeight > 0).length
       },
       locator.type,
       locator.value,
@@ -551,7 +545,7 @@ class Nightmare extends Helper {
     locator = new Locator(locator, 'css')
     const num = await this.browser.evaluate(
       (by, locator) => {
-        return window.codeceptjs.findElements(by, locator).filter((e) => e.offsetWidth > 0 && e.offsetHeight > 0).length
+        return window.codeceptjs.findElements(by, locator).filter(e => e.offsetWidth > 0 && e.offsetHeight > 0).length
       },
       locator.type,
       locator.value,
@@ -598,9 +592,7 @@ class Nightmare extends Helper {
    */
   async seeNumberOfElements(locator, num) {
     const elements = await this._locate(locator)
-    return equals(
-      `expected number of elements (${new Locator(locator)}) is ${num}, but found ${elements.length}`,
-    ).assert(elements.length, num)
+    return equals(`expected number of elements (${new Locator(locator)}) is ${num}, but found ${elements.length}`).assert(elements.length, num)
   }
 
   /**
@@ -608,10 +600,7 @@ class Nightmare extends Helper {
    */
   async seeNumberOfVisibleElements(locator, num) {
     const res = await this.grabNumberOfVisibleElements(locator)
-    return equals(`expected number of visible elements (${new Locator(locator)}) is ${num}, but found ${res}`).assert(
-      res,
-      num,
-    )
+    return equals(`expected number of visible elements (${new Locator(locator)}) is ${num}, but found ${res}`).assert(res, num)
   }
 
   /**
@@ -622,7 +611,7 @@ class Nightmare extends Helper {
 
     const num = await this.browser.evaluate(
       (by, locator) => {
-        return window.codeceptjs.findElements(by, locator).filter((e) => e.offsetWidth > 0 && e.offsetHeight > 0).length
+        return window.codeceptjs.findElements(by, locator).filter(e => e.offsetWidth > 0 && e.offsetHeight > 0).length
       },
       locator.type,
       locator.value,
@@ -637,7 +626,7 @@ class Nightmare extends Helper {
   async click(locator, context = null) {
     const el = await findClickable.call(this, locator, context)
     assertElementExists(el, locator, 'Clickable')
-    return this.browser.evaluate((el) => window.codeceptjs.clickEl(el), el).wait(this.options.waitForAction)
+    return this.browser.evaluate(el => window.codeceptjs.clickEl(el), el).wait(this.options.waitForAction)
   }
 
   /**
@@ -646,7 +635,7 @@ class Nightmare extends Helper {
   async doubleClick(locator, context = null) {
     const el = await findClickable.call(this, locator, context)
     assertElementExists(el, locator, 'Clickable')
-    return this.browser.evaluate((el) => window.codeceptjs.doubleClickEl(el), el).wait(this.options.waitForAction)
+    return this.browser.evaluate(el => window.codeceptjs.doubleClickEl(el), el).wait(this.options.waitForAction)
   }
 
   /**
@@ -655,7 +644,7 @@ class Nightmare extends Helper {
   async rightClick(locator, context = null) {
     const el = await findClickable.call(this, locator, context)
     assertElementExists(el, locator, 'Clickable')
-    return this.browser.evaluate((el) => window.codeceptjs.rightClickEl(el), el).wait(this.options.waitForAction)
+    return this.browser.evaluate(el => window.codeceptjs.rightClickEl(el), el).wait(this.options.waitForAction)
   }
 
   /**
@@ -665,9 +654,7 @@ class Nightmare extends Helper {
     locator = new Locator(locator, 'css')
     const el = await this.browser.findElement(locator.toStrict())
     assertElementExists(el, locator)
-    return this.browser
-      .evaluate((el, x, y) => window.codeceptjs.hoverEl(el, x, y), el, offsetX, offsetY)
-      .wait(this.options.waitForAction) // wait for hover event to happen
+    return this.browser.evaluate((el, x, y) => window.codeceptjs.hoverEl(el, x, y), el, offsetX, offsetY).wait(this.options.waitForAction) // wait for hover event to happen
   }
 
   /**
@@ -676,7 +663,7 @@ class Nightmare extends Helper {
    * Wrapper for synchronous [evaluate](https://github.com/segmentio/nightmare#evaluatefn-arg1-arg2)
    */
   async executeScript(...args) {
-    return this.browser.evaluate.apply(this.browser, args).catch((err) => err) // Nightmare's first argument is error :(
+    return this.browser.evaluate.apply(this.browser, args).catch(err => err) // Nightmare's first argument is error :(
   }
 
   /**
@@ -686,7 +673,7 @@ class Nightmare extends Helper {
    * Unlike NightmareJS implementation calling `done` will return its first argument.
    */
   async executeAsyncScript(...args) {
-    return this.browser.evaluate.apply(this.browser, args).catch((err) => err) // Nightmare's first argument is error :(
+    return this.browser.evaluate.apply(this.browser, args).catch(err => err) // Nightmare's first argument is error :(
   }
 
   /**
@@ -705,7 +692,7 @@ class Nightmare extends Helper {
   async checkOption(field, context = null) {
     const els = await findCheckable.call(this, field, context)
     assertElementExists(els[0], field, 'Checkbox or radio')
-    return this.browser.evaluate((els) => window.codeceptjs.checkEl(els[0]), els).wait(this.options.waitForAction)
+    return this.browser.evaluate(els => window.codeceptjs.checkEl(els[0]), els).wait(this.options.waitForAction)
   }
 
   /**
@@ -714,7 +701,7 @@ class Nightmare extends Helper {
   async uncheckOption(field, context = null) {
     const els = await findCheckable.call(this, field, context)
     assertElementExists(els[0], field, 'Checkbox or radio')
-    return this.browser.evaluate((els) => window.codeceptjs.unCheckEl(els[0]), els).wait(this.options.waitForAction)
+    return this.browser.evaluate(els => window.codeceptjs.unCheckEl(els[0]), els).wait(this.options.waitForAction)
   }
 
   /**
@@ -826,7 +813,7 @@ class Nightmare extends Helper {
     locator = new Locator(locator, 'css')
     const els = await this.browser.findElements(locator.toStrict())
     const texts = []
-    const getText = (el) => window.codeceptjs.fetchElement(el).innerText
+    const getText = el => window.codeceptjs.fetchElement(el).innerText
     for (const el of els) {
       texts.push(await this.browser.evaluate(getText, el))
     }
@@ -855,7 +842,7 @@ class Nightmare extends Helper {
     locator = new Locator(locator, 'css')
     const els = await this.browser.findElements(locator.toStrict())
     const values = []
-    const getValues = (el) => window.codeceptjs.fetchElement(el).value
+    const getValues = el => window.codeceptjs.fetchElement(el).value
     for (const el of els) {
       values.push(await this.browser.evaluate(getValues, el))
     }
@@ -887,9 +874,7 @@ class Nightmare extends Helper {
 
     for (let index = 0; index < els.length; index++) {
       const el = els[index]
-      array.push(
-        await this.browser.evaluate((el, attr) => window.codeceptjs.fetchElement(el).getAttribute(attr), el, attr),
-      )
+      array.push(await this.browser.evaluate((el, attr) => window.codeceptjs.fetchElement(el).getAttribute(attr), el, attr))
     }
 
     return array
@@ -921,7 +906,7 @@ class Nightmare extends Helper {
 
     for (let index = 0; index < els.length; index++) {
       const el = els[index]
-      array.push(await this.browser.evaluate((el) => window.codeceptjs.fetchElement(el).innerHTML, el))
+      array.push(await this.browser.evaluate(el => window.codeceptjs.fetchElement(el).innerHTML, el))
     }
     this.debugSection('GrabHTML', array)
 
@@ -953,7 +938,7 @@ class Nightmare extends Helper {
 
     const getCssPropForElement = async (el, prop) => {
       return (
-        await this.browser.evaluate((el) => {
+        await this.browser.evaluate(el => {
           return window.getComputedStyle(window.codeceptjs.fetchElement(el))
         }, el)
       )[toCamelCase(prop)]
@@ -1083,7 +1068,7 @@ class Nightmare extends Helper {
    * {{> wait }}
    */
   async wait(sec) {
-    return new Promise((done) => {
+    return new Promise(done => {
       setTimeout(done, sec * 1000)
     })
   }
@@ -1106,7 +1091,7 @@ class Nightmare extends Helper {
         locator.value,
         text,
       )
-      .catch((err) => {
+      .catch(err => {
         if (err.message.indexOf('Cannot read property') > -1) {
           throw new Error(`element (${JSON.stringify(context)}) is not in DOM. Unable to wait text.`)
         } else if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
@@ -1132,7 +1117,7 @@ class Nightmare extends Helper {
         locator.type,
         locator.value,
       )
-      .catch((err) => {
+      .catch(err => {
         if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
           throw new Error(`element (${JSON.stringify(locator)}) still not visible on page after ${sec} sec`)
         } else throw err
@@ -1163,7 +1148,7 @@ class Nightmare extends Helper {
         locator.type,
         locator.value,
       )
-      .catch((err) => {
+      .catch(err => {
         if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
           throw new Error(`element (${JSON.stringify(locator)}) still visible after ${sec} sec`)
         } else throw err
@@ -1179,7 +1164,7 @@ class Nightmare extends Helper {
 
     return this.browser
       .wait((by, locator) => window.codeceptjs.findElement(by, locator) !== null, locator.type, locator.value)
-      .catch((err) => {
+      .catch(err => {
         if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
           throw new Error(`element (${JSON.stringify(locator)}) still not present on page after ${sec} sec`)
         } else throw err
@@ -1203,7 +1188,7 @@ class Nightmare extends Helper {
 
     return this.browser
       .wait((by, locator) => window.codeceptjs.findElement(by, locator) === null, locator.type, locator.value)
-      .catch((err) => {
+      .catch(err => {
         if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
           throw new Error(`element (${JSON.stringify(locator)}) still on page after ${sec} sec`)
         } else throw err
@@ -1324,7 +1309,7 @@ class Nightmare extends Helper {
         offsetY,
       )
     }
-    // eslint-disable-next-line prefer-arrow-callback
+
     return this.executeScript(
       function (x, y) {
         return window.scrollTo(x, y)
@@ -1345,30 +1330,24 @@ class Nightmare extends Helper {
    * {{> scrollPageToBottom }}
    */
   async scrollPageToBottom() {
-    /* eslint-disable prefer-arrow-callback, comma-dangle */
     return this.executeScript(function () {
       const body = document.body
       const html = document.documentElement
-      window.scrollTo(
-        0,
-        Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight),
-      )
+      window.scrollTo(0, Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight))
     })
-    /* eslint-enable */
   }
 
   /**
    * {{> grabPageScrollPosition }}
    */
   async grabPageScrollPosition() {
-    /* eslint-disable comma-dangle */
     function getScrollPosition() {
       return {
         x: window.pageXOffset,
         y: window.pageYOffset,
       }
     }
-    /* eslint-enable comma-dangle */
+
     return this.executeScript(getScrollPosition)
   }
 }
@@ -1393,7 +1372,7 @@ async function proceedSee(assertType, text, context) {
 
   const texts = await this.browser.evaluate(
     (by, locator) => {
-      return window.codeceptjs.findElements(by, locator).map((el) => el.innerText)
+      return window.codeceptjs.findElements(by, locator).map(el => el.innerText)
     },
     locator.type,
     locator.value,
@@ -1405,8 +1384,8 @@ async function proceedSee(assertType, text, context) {
 async function proceedSeeInField(assertType, field, value) {
   const el = await findField.call(this, field)
   assertElementExists(el, field, 'Field')
-  const tag = await this.browser.evaluate((el) => window.codeceptjs.fetchElement(el).tagName, el)
-  const fieldVal = await this.browser.evaluate((el) => window.codeceptjs.fetchElement(el).value, el)
+  const tag = await this.browser.evaluate(el => window.codeceptjs.fetchElement(el).tagName, el)
+  const fieldVal = await this.browser.evaluate(el => window.codeceptjs.fetchElement(el).value, el)
   if (tag === 'select') {
     // locate option by values and check them
     const text = await this.browser.evaluate(
@@ -1424,8 +1403,8 @@ async function proceedSeeInField(assertType, field, value) {
 async function proceedIsChecked(assertType, option) {
   const els = await findCheckable.call(this, option)
   assertElementExists(els, option, 'Checkable')
-  const selected = await this.browser.evaluate((els) => {
-    return els.map((el) => window.codeceptjs.fetchElement(el).checked).reduce((prev, cur) => prev || cur)
+  const selected = await this.browser.evaluate(els => {
+    return els.map(el => window.codeceptjs.fetchElement(el).checked).reduce((prev, cur) => prev || cur)
   }, els)
   return truth(`checkable ${option}`, 'to be checked')[assertType](selected)
 }