codeceptjs 4.0.0-beta.7.esm-aria → 4.0.0-beta.8.esm-aria

package/lib/helper/WebDriver.js

@@ -3,6 +3,7 @@ let webdriverio
 import assert from 'assert'
 import path from 'path'
 import crypto from 'crypto'
+
 import Helper from '@codeceptjs/helper'
 import promiseRetry from 'promise-retry'
 import { includes as stringIncludes } from '../assert/include.js'
@@ -22,6 +23,7 @@ import { focusElement } from './scripts/focusElement.js'
 import { blurElement } from './scripts/blurElement.js'
 import { dontSeeElementError, seeElementError, seeElementInDOMError, dontSeeElementInDOMError } from './errors/ElementAssertion.js'
 import { dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics } from './network/actions.js'
+import WebElement from '../element/WebElement.js'
 
 const SHADOW = 'shadow'
 const webRoot = 'body'
@@ -504,7 +506,7 @@ class WebDriver extends Helper {
     }
     config.capabilities.browserName = config.browser || config.capabilities.browserName
 
-    // WebDriver Bidi Protocol. Default: false
+    // WebDriver Bidi Protocol. Default: true
     config.capabilities.webSocketUrl = config.bidiProtocol ?? config.capabilities.webSocketUrl ?? true
 
     config.capabilities.browserVersion = config.browserVersion || config.capabilities.browserVersion
@@ -656,8 +658,11 @@ class WebDriver extends Helper {
 
     this.browser.on('dialog', () => {})
 
-    await this.browser.sessionSubscribe({ events: ['log.entryAdded'] })
-    this.browser.on('log.entryAdded', logEvents)
+    // Check for Bidi, because "sessionSubscribe" is an exclusive Bidi protocol feature. Otherwise, error will be thrown.
+    if (this.browser.capabilities && this.browser.capabilities.webSocketUrl) {
+      await this.browser.sessionSubscribe({ events: ['log.entryAdded'] })
+      this.browser.on('log.entryAdded', logEvents)
+    }
 
     return this.browser
   }
@@ -1004,7 +1009,20 @@ class WebDriver extends Helper {
    *
    */
   async grabWebElements(locator) {
-    return this._locate(locator)
+    const elements = await this._locate(locator)
+    return elements.map(element => new WebElement(element, this))
+  }
+
+  /**
+   * {{> grabWebElement }}
+   *
+   */
+  async grabWebElement(locator) {
+    const elements = await this._locate(locator)
+    if (elements.length === 0) {
+      throw new ElementNotFound(locator, 'Element')
+    }
+    return new WebElement(elements[0], this)
   }
 
   /**
@@ -1049,7 +1067,7 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async click(locator, context = null) {
-    const clickMethod = this.browser.isMobile && !this.browser.isW3C ? 'touchClick' : 'elementClick'
+    const clickMethod = this.browser.isMobile && this.browser.capabilities.platformName !== 'android' ? 'touchClick' : 'elementClick'
     const locateFn = prepareLocateFn.call(this, context)
 
     const res = await findClickable.call(this, locator, locateFn)
@@ -1136,6 +1154,75 @@ class WebDriver extends Helper {
     await this.browser.buttonDown(2)
   }
 
+  /**
+   * Performs click at specific coordinates.
+   * If locator is provided, the coordinates are relative to the element's top-left corner.
+   * If locator is not provided, the coordinates are relative to the body element.
+   *
+   * ```js
+   * // Click at coordinates (100, 200) relative to body
+   * I.clickXY(100, 200);
+   *
+   * // Click at coordinates (50, 30) relative to element's top-left corner
+   * I.clickXY('#someElement', 50, 30);
+   * ```
+   *
+   * @param {CodeceptJS.LocatorOrString|number} locator Element to click on or X coordinate if no element.
+   * @param {number} [x] X coordinate relative to element's top-left, or Y coordinate if locator is a number.
+   * @param {number} [y] Y coordinate relative to element's top-left.
+   * @returns {Promise<void>}
+   */
+  async clickXY(locator, x, y) {
+    // If locator is a number, treat it as X coordinate and use body as base
+    if (typeof locator === 'number') {
+      const globalX = locator
+      const globalY = x
+      locator = '//body'
+      x = globalX
+      y = globalY
+    }
+
+    // Locate the base element
+    const res = await this._locate(withStrictLocator(locator), true)
+    assertElementExists(res, locator, 'Element to click')
+    const el = usingFirstElement(res)
+
+    // Get element position and size to calculate top-left corner
+    const location = await el.getLocation()
+    const size = await el.getSize()
+
+    // WebDriver clicks at center by default, so we need to offset from center to top-left
+    // then add our desired x, y coordinates
+    const offsetX = -(size.width / 2) + x
+    const offsetY = -(size.height / 2) + y
+
+    if (this.browser.isW3C) {
+      // Use performActions for W3C WebDriver
+      return this.browser.performActions([
+        {
+          type: 'pointer',
+          id: 'pointer1',
+          parameters: { pointerType: 'mouse' },
+          actions: [
+            {
+              type: 'pointerMove',
+              origin: el,
+              duration: 0,
+              x: Math.round(offsetX),
+              y: Math.round(offsetY),
+            },
+            { type: 'pointerDown', button: 0 },
+            { type: 'pointerUp', button: 0 },
+          ],
+        },
+      ])
+    }
+
+    // Fallback for non-W3C browsers
+    await el.moveTo({ xOffset: Math.round(offsetX), yOffset: Math.round(offsetY) })
+    return el.click()
+  }
+
   /**
    * {{> forceRightClick }}
    *
@@ -1173,7 +1260,17 @@ class WebDriver extends Helper {
     assertElementExists(res, field, 'Field')
     const elem = usingFirstElement(res)
     highlightActiveElement.call(this, elem)
-    await elem.clearValue()
+    try {
+      await elem.clearValue()
+    } catch (err) {
+      if (err.message && err.message.includes('invalid element state')) {
+        await this.executeScript(el => {
+          el.value = ''
+        }, elem)
+      } else {
+        throw err
+      }
+    }
     await elem.setValue(value.toString())
   }
 
@@ -1268,7 +1365,7 @@ class WebDriver extends Helper {
    * {{> checkOption }}
    */
   async checkOption(field, context = null) {
-    const clickMethod = this.browser.isMobile && !this.browser.isW3C ? 'touchClick' : 'elementClick'
+    const clickMethod = this.browser.isMobile && this.browser.capabilities.platformName !== 'android' ? 'touchClick' : 'elementClick'
     const locateFn = prepareLocateFn.call(this, context)
 
     const res = await findCheckable.call(this, field, locateFn)
@@ -1289,7 +1386,7 @@ class WebDriver extends Helper {
    * {{> uncheckOption }}
    */
   async uncheckOption(field, context = null) {
-    const clickMethod = this.browser.isMobile && !this.browser.isW3C ? 'touchClick' : 'elementClick'
+    const clickMethod = this.browser.isMobile && this.browser.capabilities.platformName !== 'android' ? 'touchClick' : 'elementClick'
     const locateFn = prepareLocateFn.call(this, context)
 
     const res = await findCheckable.call(this, field, locateFn)
@@ -2912,14 +3009,6 @@ async function findFields(locator) {
   let els = await this._locate(Locator.field.labelEquals(literal))
   if (els.length) return els
 
-  // Try ARIA selector for accessible name
-  try {
-    els = await this._locate(`aria/${locator.value}`)
-    if (els.length) return els
-  } catch (e) {
-    // ARIA selector not supported or failed
-  }
-
   els = await this._locate(Locator.field.labelContains(literal))
   if (els.length) return els
 

package/lib/helper/clientscripts/PollyWebDriverExt.js

@@ -108,4 +108,4 @@ const pollyWebDriver = {
   },
 };
 
-module.exports = pollyWebDriver;
+export default pollyWebDriver;

package/lib/helper/extras/PlaywrightReactVueLocator.js

@@ -0,0 +1,52 @@
+async function findReact(matcher, locator) {
+  // Handle both Locator objects and raw locator objects
+  const reactLocator = locator.locator || locator
+  let _locator = `_react=${reactLocator.react}`;
+  let props = '';
+
+  if (reactLocator.props) {
+    props += propBuilder(reactLocator.props);
+    _locator += props;
+  }
+  return matcher.locator(_locator).all();
+}
+
+async function findVue(matcher, locator) {
+  // Handle both Locator objects and raw locator objects
+  const vueLocator = locator.locator || locator
+  let _locator = `_vue=${vueLocator.vue}`;
+  let props = '';
+
+  if (vueLocator.props) {
+    props += propBuilder(vueLocator.props);
+    _locator += props;
+  }
+  return matcher.locator(_locator).all();
+}
+
+async function findByPlaywrightLocator(matcher, locator) {
+  // 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) {
+  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 { findReact, findVue, findByPlaywrightLocator };

package/lib/helper/extras/PlaywrightRestartOpts.js

@@ -1,6 +1,7 @@
 const RESTART_OPTS = {
   session: 'keep',
   context: false,
+  browser: true,
 }
 
 let restarts = null
@@ -19,9 +20,15 @@ export function setRestartStrategy(options) {
     return
   }
 
+  // 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')
+  if (restarts === null || restarts === undefined) throw new Error('No restart strategy set, use the following values for restart: session, context, browser')
 }
 
 export function restartsSession() {
@@ -31,3 +38,7 @@ export function restartsSession() {
 export function restartsContext() {
   return restarts === 'context'
 }
+
+export function restartsBrowser() {
+  return restarts === 'browser'
+}

package/lib/helper/network/actions.js

@@ -28,8 +28,8 @@ async function seeTraffic({ name, url, parameters, requestPostData, timeout = 10
     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.')
+  if (!this.recordedAtLeastOnce) {
+    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++) {
@@ -57,8 +57,8 @@ async function seeTraffic({ name, url, parameters, requestPostData, timeout = 10
 }
 
 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.')
+  if (!this.recordedAtLeastOnce) {
+    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 => {
@@ -97,8 +97,10 @@ async function grabRecordedNetworkTraffics() {
 
 function stopRecordingTraffic() {
   // @ts-ignore
-  this.page.removeAllListeners('request')
-  this.recording = false
+  this.page.removeAllListeners('request');
+   // @ts-ignore
+  this.page.removeAllListeners('requestfinished');
+  this.recording = false;
 }
 
 function flushNetworkTraffics() {

package/lib/listener/config.js

@@ -2,10 +2,17 @@ import event from '../event.js'
 import recorder from '../recorder.js'
 import { deepMerge, deepClone, ucfirst } from '../utils.js'
 import output from '../output.js'
+
 /**
  * Enable Helpers to listen to test events
  */
 export default function () {
+  // Use global flag to prevent duplicate initialization across module re-imports
+  if (global.__codeceptConfigListenerInitialized) {
+    return
+  }
+  global.__codeceptConfigListenerInitialized = true
+  
   const helpers = global.container.helpers()
 
   enableDynamicConfigFor('suite')
@@ -14,7 +21,7 @@ export default function () {
   function enableDynamicConfigFor(type) {
     event.dispatcher.on(event[type].before, (context = {}) => {
       function updateHelperConfig(helper, config) {
-        const oldConfig = { ...helper.options }
+        const oldConfig = deepClone(helper.options)
         try {
           helper._setConfig(deepMerge(deepClone(oldConfig), config))
           output.debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`)
@@ -22,10 +29,11 @@ export default function () {
           recorder.throw(err)
           return
         }
-        event.dispatcher.once(event[type].after, () => {
+        const restoreCallback = () => {
           helper._setConfig(oldConfig)
           output.debug(`[${ucfirst(type)} Config] Reverted for ${helper.constructor.name}`)
-        })
+        }
+        event.dispatcher.once(event[type].after, restoreCallback)
       }
 
       // change config

package/lib/listener/enhancedGlobalRetry.js

@@ -0,0 +1,110 @@
+import event from '../event.js'
+import output from '../output.js'
+import Config from '../config.js'
+import { isNotSet } from '../utils.js'
+
+const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
+
+/**
+ * Priority levels for retry mechanisms (higher number = higher priority)
+ * This ensures consistent behavior when multiple retry mechanisms are active
+ */
+const RETRY_PRIORITIES = {
+  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
+  STEP_PLUGIN: 50, // retryFailedStep plugin
+  SCENARIO_CONFIG: 30, // Global scenario retry config
+  FEATURE_CONFIG: 20, // Global feature retry config
+  HOOK_CONFIG: 10, // Hook retry config - lowest priority
+}
+
+/**
+ * Enhanced global retry mechanism that coordinates with other retry types
+ */
+export default function () {
+  event.dispatcher.on(event.suite.before, suite => {
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
+
+    if (Number.isInteger(+retryConfig)) {
+      // is number - apply as feature-level retry
+      const retryNum = +retryConfig
+      output.log(`[Global Retry] Feature retries: ${retryNum}`)
+
+      // Only set if not already set by higher priority mechanism
+      if (isNotSet(suite.retries())) {
+        suite.retries(retryNum)
+        suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+      }
+      return
+    }
+
+    if (!Array.isArray(retryConfig)) {
+      retryConfig = [retryConfig]
+    }
+
+    for (const config of retryConfig) {
+      if (config.grep) {
+        if (!suite.title.includes(config.grep)) continue
+      }
+
+      // Handle hook retries with priority awareness
+      hooks
+        .filter(hook => !!config[hook])
+        .forEach(hook => {
+          const retryKey = `retry${hook}`
+          if (isNotSet(suite.opts[retryKey])) {
+            suite.opts[retryKey] = config[hook]
+            suite.opts[`${retryKey}Priority`] = RETRY_PRIORITIES.HOOK_CONFIG
+          }
+        })
+
+      // Handle feature-level retries
+      if (config.Feature) {
+        if (isNotSet(suite.retries()) || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
+          suite.retries(config.Feature)
+          suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+          output.log(`[Global Retry] Feature retries: ${config.Feature}`)
+        }
+      }
+    }
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
+
+    if (Number.isInteger(+retryConfig)) {
+      // Only set if not already set by higher priority mechanism
+      if (test.retries() === -1) {
+        test.retries(retryConfig)
+        test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+        output.log(`[Global Retry] Scenario retries: ${retryConfig}`)
+      }
+      return
+    }
+
+    if (!Array.isArray(retryConfig)) {
+      retryConfig = [retryConfig]
+    }
+
+    retryConfig = retryConfig.filter(config => !!config.Scenario)
+
+    for (const config of retryConfig) {
+      if (config.grep) {
+        if (!test.fullTitle().includes(config.grep)) continue
+      }
+
+      if (config.Scenario) {
+        // Respect priority system
+        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(`[Global Retry] Scenario retries: ${config.Scenario}`)
+        }
+      }
+    }
+  })
+}
+
+// Export priority constants for use by other retry mechanisms
+export { RETRY_PRIORITIES }

package/lib/listener/globalTimeout.js

@@ -21,14 +21,29 @@ export default function () {
 
   // disable timeout for BeforeSuite/AfterSuite hooks
   // add separate configs to them?
+  // When a BeforeSuite/AfterSuite hook starts we want to disable the
+  // per-test timeout during that hook execution only. Previously the
+  // code cleared `suiteTimeout` permanently which caused the suite
+  // level timeout to be lost for subsequent tests. Save previous
+  // values and restore them when the hook finishes.
+  let __prevTimeout = undefined
+  let __prevSuiteTimeout = undefined
+
   event.dispatcher.on(event.hook.started, hook => {
-    if (hook instanceof BeforeSuiteHook) {
+    if (hook instanceof BeforeSuiteHook || hook instanceof AfterSuiteHook) {
+      __prevTimeout = timeout
+      // copy array to preserve original values
+      __prevSuiteTimeout = suiteTimeout.slice()
       timeout = null
       suiteTimeout = []
     }
-    if (hook instanceof AfterSuiteHook) {
-      timeout = null
-      suiteTimeout = []
+  })
+
+  event.dispatcher.on(event.hook.finished, hook => {
+    if (hook instanceof BeforeSuiteHook || hook instanceof AfterSuiteHook) {
+      // restore previously stored values
+      timeout = __prevTimeout
+      suiteTimeout = __prevSuiteTimeout.slice()
     }
   })
 

package/lib/listener/helpers.js

@@ -74,7 +74,10 @@ export default function () {
 
   event.dispatcher.on(event.all.result, () => {
     // Skip _finishTest for all helpers if any browser helper restarts to avoid double cleanup
-    const hasBrowserRestart = Object.values(helpers).some(helper => (helper.config && helper.config.restart) || (helper.options && helper.options.restart === 'context'))
+    const hasBrowserRestart = Object.values(helpers).some(helper => 
+      (helper.config && (helper.config.restart === 'browser' || helper.config.restart === 'context' || helper.config.restart === true)) || 
+      (helper.options && (helper.options.restart === 'browser' || helper.options.restart === 'context' || helper.options.restart === true))
+    )
 
     Object.keys(helpers).forEach(key => {
       const helper = helpers[key]
@@ -86,7 +89,10 @@ export default function () {
 
   event.dispatcher.on(event.all.after, () => {
     // Skip _cleanup for all helpers if any browser helper restarts to avoid double cleanup
-    const hasBrowserRestart = Object.values(helpers).some(helper => (helper.config && helper.config.restart) || (helper.options && helper.options.restart === 'context'))
+    const hasBrowserRestart = Object.values(helpers).some(helper => 
+      (helper.config && (helper.config.restart === 'browser' || helper.config.restart === 'context' || helper.config.restart === true)) || 
+      (helper.options && (helper.options.restart === 'browser' || helper.options.restart === 'context' || helper.options.restart === true))
+    )
 
     Object.keys(helpers).forEach(key => {
       const helper = helpers[key]

package/lib/listener/retryEnhancer.js

@@ -0,0 +1,85 @@
+import event from '../event.js'
+import { enhanceMochaTest } from '../mocha/test.js'
+
+/**
+ * Enhance retried tests by copying CodeceptJS-specific properties from the original test
+ * This fixes the issue where Mocha's shallow clone during retries loses CodeceptJS properties
+ */
+export default function () {
+  event.dispatcher.on(event.test.before, test => {
+    // Check if this test is a retry (has a reference to the original test)
+    const originalTest = test.retriedTest && test.retriedTest()
+
+    if (originalTest) {
+      // This is a retried test - copy CodeceptJS-specific properties from the original
+      copyCodeceptJSProperties(originalTest, test)
+
+      // Ensure the test is enhanced with CodeceptJS functionality
+      enhanceMochaTest(test)
+    }
+  })
+}
+
+/**
+ * Copy CodeceptJS-specific properties from the original test to the retried test
+ * @param {CodeceptJS.Test} originalTest - The original test object
+ * @param {CodeceptJS.Test} retriedTest - The retried test object
+ */
+function copyCodeceptJSProperties(originalTest, retriedTest) {
+  // Copy CodeceptJS-specific properties
+  if (originalTest.opts !== undefined) {
+    retriedTest.opts = originalTest.opts ? { ...originalTest.opts } : {}
+  }
+
+  if (originalTest.tags !== undefined) {
+    retriedTest.tags = originalTest.tags ? [...originalTest.tags] : []
+  }
+
+  if (originalTest.notes !== undefined) {
+    retriedTest.notes = originalTest.notes ? [...originalTest.notes] : []
+  }
+
+  if (originalTest.meta !== undefined) {
+    retriedTest.meta = originalTest.meta ? { ...originalTest.meta } : {}
+  }
+
+  if (originalTest.artifacts !== undefined) {
+    retriedTest.artifacts = originalTest.artifacts ? [...originalTest.artifacts] : []
+  }
+
+  if (originalTest.steps !== undefined) {
+    retriedTest.steps = originalTest.steps ? [...originalTest.steps] : []
+  }
+
+  if (originalTest.config !== undefined) {
+    retriedTest.config = originalTest.config ? { ...originalTest.config } : {}
+  }
+
+  if (originalTest.inject !== undefined) {
+    retriedTest.inject = originalTest.inject ? { ...originalTest.inject } : {}
+  }
+
+  // Copy methods that might be missing
+  if (originalTest.addNote && !retriedTest.addNote) {
+    retriedTest.addNote = function (type, note) {
+      this.notes = this.notes || []
+      this.notes.push({ type, text: note })
+    }
+  }
+
+  if (originalTest.applyOptions && !retriedTest.applyOptions) {
+    retriedTest.applyOptions = originalTest.applyOptions.bind(retriedTest)
+  }
+
+  if (originalTest.simplify && !retriedTest.simplify) {
+    retriedTest.simplify = originalTest.simplify.bind(retriedTest)
+  }
+
+  // Preserve the uid if it exists
+  if (originalTest.uid !== undefined) {
+    retriedTest.uid = originalTest.uid
+  }
+
+  // Mark as enhanced
+  retriedTest.codeceptjs = true
+}

package/lib/listener/steps.js

@@ -4,10 +4,14 @@ import event from '../event.js'
 import store from '../store.js'
 import output from '../output.js'
 import { BeforeHook, AfterHook, BeforeSuiteHook, AfterSuiteHook } from '../mocha/hooks.js'
+import recorder from '../recorder.js'
 
 let currentTest
 let currentHook
 
+// Session names that should not contribute steps to the main test trace
+const EXCLUDED_SESSIONS = ['tryTo', 'hopeThat']
+
 /**
  * Register steps inside tests
  */
@@ -76,6 +80,14 @@ export default function () {
       return currentHook.steps.push(step)
     }
     if (!currentTest || !currentTest.steps) return
+
+    // Check if we're in a session that should be excluded from main test steps
+    const currentSessionId = recorder.getCurrentSessionId()
+    if (currentSessionId && EXCLUDED_SESSIONS.includes(currentSessionId)) {
+      // Skip adding this step to the main test steps
+      return
+    }
+
     currentTest.steps.push(step)
   })
 

package/lib/mocha/asyncWrapper.js

@@ -117,9 +117,19 @@ export function injected(fn, suite, hookName) {
     const errHandler = err => {
       recorder.session.start('teardown')
       recorder.cleanAsyncErr()
-      if (hookName == 'before' || hookName == 'beforeSuite') suiteTestFailedHookError(suite, err, hookName)
-      if (hookName === 'after') suite.eachTest(test => event.emit(event.test.after, test))
-      if (hookName === 'afterSuite') event.emit(event.suite.after, suite)
+      if (['before', 'beforeSuite'].includes(hookName)) {
+        suiteTestFailedHookError(suite, err, hookName)
+      }
+      if (hookName === 'after') {
+        suiteTestFailedHookError(suite, err, hookName)
+        suite.eachTest(test => {
+          event.emit(event.test.after, test)
+        })
+      }
+      if (hookName === 'afterSuite') {
+        suiteTestFailedHookError(suite, err, hookName)
+        event.emit(event.suite.after, suite)
+      }
       recorder.add(() => doneFn(err))
     }
 

package/lib/mocha/cli.js

@@ -228,7 +228,7 @@ class Cli extends Base {
 
         // explicitly show file with error
         if (test.file) {
-          log += `\n${output.styles.basic(figures.circle)} ${output.styles.section('File:')} ${output.styles.basic(test.file)}\n`
+          log += `\n${output.styles.basic(figures.circle)} ${output.styles.section('File:')} file://${test.file}\n`
         }
 
         const steps = test.steps || (test.ctx && test.ctx.test.steps)