codeceptjs 4.0.0-rc.11 → 4.0.0-rc.15

package/lib/globals.js

@@ -8,19 +8,35 @@ import fsPath from 'path'
 import ActorFactory from './actor.js'
 import output from './output.js'
 import locator from './locator.js'
+import store from './store.js'
 
 /**
  * Initialize CodeceptJS core globals
  * Called from Codecept.initGlobals()
  */
 export async function initCodeceptGlobals(dir, config, container) {
+  store.initialize({
+    codeceptDir: dir,
+    outputDir: fsPath.resolve(dir, config.output),
+  })
+
+  store.noGlobals = config.noGlobals || false
+  store.maskSensitiveData = config.maskSensitiveData || false
+
+  // Keep globals for backward compat with external plugins
   global.codecept_dir = dir
   global.output_dir = fsPath.resolve(dir, config.output)
 
   if (config.noGlobals) return;
-    // Set up actor global - will use container when available
+
+  output.print(output.styles.debug('Global functions are deprecated. Use `import { Helper, pause, within, session } from "codeceptjs"` instead. Set `noGlobals: true` in config to disable globals.'));
+
+  const HelperModule = await import('@codeceptjs/helper')
+  global.Helper = global.codecept_helper = HelperModule.default || HelperModule
+
+  // Set up actor global - will use container when available
   global.actor = global.codecept_actor = (obj) => {
-    return ActorFactory(obj, global.container || container)
+    return ActorFactory(obj, container)
   }
   global.Actor = global.actor
 
@@ -52,8 +68,6 @@ export async function initCodeceptGlobals(dir, config, container) {
   const secretModule = await import('./secret.js')
   global.secret = secretModule.secret || (secretModule.default && secretModule.default.secret)
 
-  global.codecept_debug = output.debug
-
   const codeceptjsModule = await import('./index.js') // load all objects
   global.codeceptjs = codeceptjsModule.default || codeceptjsModule
 
@@ -65,9 +79,6 @@ export async function initCodeceptGlobals(dir, config, container) {
   global.Then = stepDefinitions.Then
   global.DefineParameterType = stepDefinitions.defineParameterType
 
-  // debug mode
-  global.debugMode = false
-
   // mask sensitive data
   global.maskSensitiveData = config.maskSensitiveData || false
 
@@ -78,6 +89,8 @@ export async function initCodeceptGlobals(dir, config, container) {
  * Called from mocha/ui.js pre-require event
  */
 export function initMochaGlobals(context) {
+  if (store.noGlobals) return;
+
   // Mocha test framework globals
   global.BeforeAll = context.BeforeAll
   global.AfterAll = context.AfterAll
@@ -106,6 +119,8 @@ export function getGlobalNames() {
   return [
     'codecept_dir',
     'output_dir',
+    'Helper',
+    'codecept_helper',
     'actor',
     'codecept_actor',
     'Actor',
@@ -117,13 +132,11 @@ export function getGlobalNames() {
     'inject',
     'share',
     'secret',
-    'codecept_debug',
     'codeceptjs',
     'Given',
     'When',
     'Then',
     'DefineParameterType',
-    'debugMode',
     'maskSensitiveData',
     'BeforeAll',
     'AfterAll',
@@ -136,6 +149,5 @@ export function getGlobalNames() {
     'After',
     'Scenario',
     'xScenario',
-    'container'
   ]
 }

package/lib/heal.js

@@ -4,6 +4,7 @@ import colors from 'chalk'
 import recorder from './recorder.js'
 import output from './output.js'
 import event from './event.js'
+import container from './container.js'
 
 /**
  * @class
@@ -69,7 +70,7 @@ class Heal {
       if (!prepareFn) continue
 
       if (context[property]) continue
-      context[property] = await prepareFn(global.inject())
+      context[property] = await prepareFn(container.support())
     }
 
     output.level(currentOutputLevel)
@@ -116,10 +117,10 @@ class Heal {
           })
 
           if (typeof codeSnippet === 'string') {
-            const I = global.container.support('I')
+            const I = container.support('I')
             await eval(codeSnippet)
           } else if (typeof codeSnippet === 'function') {
-            await codeSnippet(global.container.support())
+            await codeSnippet(container.support())
           }
 
           this.fixes.push({

package/lib/helper/ApiDataFactory.js

@@ -1,6 +1,7 @@
 import path from 'path'
 import Helper from '@codeceptjs/helper'
 import REST from './REST.js'
+import store from '../store.js'
 
 /**
  * Helper for managing remote data using REST API.
@@ -324,7 +325,7 @@ class ApiDataFactory extends Helper {
         await import.meta.resolve(modulePath)
       } catch (e) {
         // If not found, try relative to codecept_dir
-        modulePath = path.join(global.codecept_dir, modulePath)
+        modulePath = path.join(store.codeceptDir, modulePath)
       }
       // check if the new syntax `export default new Factory()` is used and loads the builder, otherwise loads the module that used old syntax `module.exports = new Factory()`.
       const module = await import(modulePath)

package/lib/helper/FileSystem.js

@@ -4,6 +4,7 @@ import fs from 'fs'
 
 import Helper from '@codeceptjs/helper'
 import { fileExists } from '../utils.js'
+import store from '../store.js'
 import { fileIncludes } from '../assert/include.js'
 import { fileEquals } from '../assert/equal.js'
 
@@ -33,7 +34,7 @@ import { fileEquals } from '../assert/equal.js'
 class FileSystem extends Helper {
   constructor() {
     super()
-    this.dir = global.codecept_dir
+    this.dir = store.codeceptDir
     this.file = ''
   }
 
@@ -52,7 +53,7 @@ class FileSystem extends Helper {
    * @param {string} openPath
    */
   amInPath(openPath) {
-    this.dir = path.join(global.codecept_dir, openPath)
+    this.dir = path.join(store.codeceptDir, openPath)
     try {
       this.debugSection('Dir', this.dir)
     } catch (e) {

package/lib/helper/GraphQLDataFactory.js

@@ -2,6 +2,7 @@ import path from 'path'
 
 import HelperModule from '@codeceptjs/helper'
 import GraphQL from './GraphQL.js'
+import store from '../store.js'
 
 /**
  * Helper for managing remote data using GraphQL queries.
@@ -251,7 +252,7 @@ class GraphQLDataFactory extends Helper {
       try {
         require.resolve(modulePath)
       } catch (e) {
-        modulePath = path.join(global.codecept_dir, modulePath)
+        modulePath = path.join(store.codeceptDir, modulePath)
       }
       const builder = require(modulePath)
       return builder.build(data)

package/lib/helper/Playwright.js

@@ -40,15 +40,12 @@ import { findReact, findVue, findByPlaywrightLocator } from './extras/Playwright
 import { dropFile } from './scripts/dropFile.js'
 import WebElement from '../element/WebElement.js'
 import { selectElement } from './extras/elementSelection.js'
+import { fillRichEditor } from './extras/richTextEditor.js'
 
 let playwright
 let perfTiming
 let defaultSelectorEnginesInitialized = false
 
-// Use global object to track selector registration across workers
-if (typeof global.__playwrightSelectorsRegistered === 'undefined') {
-  global.__playwrightSelectorsRegistered = false
-}
 
 const popupStore = new Popup()
 const consoleLogStore = new Console()
@@ -449,7 +446,7 @@ class Playwright extends Helper {
       this.options.recordVideo = { size }
     }
     if (this.options.recordVideo && !this.options.recordVideo.dir) {
-      this.options.recordVideo.dir = `${global.output_dir}/videos/`
+      this.options.recordVideo.dir = `${store.outputDir}/videos/`
     }
     this.isRemoteBrowser = !!this.playwrightOptions.browserWSEndpoint
     this.isElectron = this.options.browser === 'electron'
@@ -511,18 +508,18 @@ class Playwright extends Helper {
     try {
       // Always wrap in try-catch since selectors might be registered globally across workers
       // Check global flag to avoid re-registration in worker processes
-      if (!global.__playwrightSelectorsRegistered) {
+      if (!defaultSelectorEnginesInitialized) {
         try {
           await playwright.selectors.register('__value', createValueEngine)
           await playwright.selectors.register('__disabled', createDisabledEngine)
-          global.__playwrightSelectorsRegistered = true
+          defaultSelectorEnginesInitialized = true
           defaultSelectorEnginesInitialized = true
         } catch (e) {
           if (!e.message.includes('already registered')) {
             throw e
           }
           // Selector already registered globally by another worker
-          global.__playwrightSelectorsRegistered = true
+          defaultSelectorEnginesInitialized = true
           defaultSelectorEnginesInitialized = true
         }
       } else {
@@ -615,7 +612,7 @@ class Playwright extends Helper {
       if (this.options.recordVideo) contextOptions.recordVideo = this.options.recordVideo
       if (this.options.recordHar) {
         const harExt = this.options.recordHar.content && this.options.recordHar.content === 'attach' ? 'zip' : 'har'
-        const fileName = `${`${global.output_dir}${path.sep}har${path.sep}${uuidv4()}_${clearString(this.currentRunningTest.title)}`.slice(0, 245)}.${harExt}`
+        const fileName = `${`${store.outputDir}${path.sep}har${path.sep}${uuidv4()}_${clearString(this.currentRunningTest.title)}`.slice(0, 245)}.${harExt}`
         const dir = path.dirname(fileName)
         if (!fileExists(dir)) fs.mkdirSync(dir)
         this.options.recordHar.path = fileName
@@ -1637,7 +1634,7 @@ class Playwright extends Helper {
    * @returns Promise<void>
    */
   async replayFromHar(harFilePath, opts) {
-    const file = path.join(global.codecept_dir, harFilePath)
+    const file = path.join(store.codeceptDir, harFilePath)
 
     if (!fileExists(file)) {
       throw new Error(`File at ${file} cannot be found on local system`)
@@ -2048,7 +2045,7 @@ class Playwright extends Helper {
       const filePath = await download.path()
       fileName = fileName || `downloads/${path.basename(filePath)}`
 
-      const downloadPath = path.join(global.output_dir, fileName)
+      const downloadPath = path.join(store.outputDir, fileName)
       if (!fs.existsSync(path.dirname(downloadPath))) {
         fs.mkdirSync(path.dirname(downloadPath), '0777')
       }
@@ -2287,11 +2284,15 @@ class Playwright extends Helper {
     assertElementExists(els, field, 'Field')
     const el = selectElement(els, field, this)
 
+    await highlightActiveElement.call(this, el)
+
+    if (await fillRichEditor(this, el, value)) {
+      return this._waitForAction()
+    }
+
     await el.clear()
     if (store.debugMode) this.debugSection('Focused', await elToString(el, 1))
 
-    await highlightActiveElement.call(this, el)
-
     await el.type(value.toString(), { delay: this.options.pressKeyDelay })
 
     return this._waitForAction()
@@ -2347,7 +2348,7 @@ class Playwright extends Helper {
    *
    */
   async attachFile(locator, pathToFile, context = null) {
-    const file = path.join(global.codecept_dir, pathToFile)
+    const file = path.join(store.codeceptDir, pathToFile)
 
     if (!fileExists(file)) {
       throw new Error(`File at ${file} can not be found on local system`)
@@ -4823,7 +4824,7 @@ async function refreshContextSession() {
 
 function saveVideoForPage(page, name) {
   if (!page.video()) return null
-  const fileName = `${`${global.output_dir}${pathSeparator}videos${pathSeparator}${uuidv4()}_${clearString(name)}`.slice(0, 245)}.webm`
+  const fileName = `${`${store.outputDir}${pathSeparator}videos${pathSeparator}${uuidv4()}_${clearString(name)}`.slice(0, 245)}.webm`
   page
     .video()
     .saveAs(fileName)
@@ -4840,7 +4841,7 @@ async function saveTraceForContext(context, name) {
   if (!context) return
   if (!context.tracing) return
   try {
-    const fileName = `${`${global.output_dir}${pathSeparator}trace${pathSeparator}${uuidv4()}_${clearString(name)}`.slice(0, 245)}.zip`
+    const fileName = `${`${store.outputDir}${pathSeparator}trace${pathSeparator}${uuidv4()}_${clearString(name)}`.slice(0, 245)}.zip`
     await context.tracing.stop({ path: fileName })
     return fileName
   } catch (err) {

package/lib/helper/Puppeteer.js

@@ -45,6 +45,7 @@ import { dontSeeElementError, seeElementError, dontSeeElementInDOMError, seeElem
 import { dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics } from './network/actions.js'
 import WebElement from '../element/WebElement.js'
 import { selectElement } from './extras/elementSelection.js'
+import { fillRichEditor } from './extras/richTextEditor.js'
 
 let puppeteer
 
@@ -752,7 +753,7 @@ class Puppeteer extends Helper {
     }
 
     if (this.options.trace) {
-      const fileName = `${`${global.output_dir}${path.sep}trace${path.sep}${uuidv4()}_${clearString(this.currentRunningTest.title)}`.slice(0, 245)}.json`
+      const fileName = `${`${store.outputDir}${path.sep}trace${path.sep}${uuidv4()}_${clearString(this.currentRunningTest.title)}`.slice(0, 245)}.json`
       const dir = path.dirname(fileName)
       if (!fileExists(dir)) fs.mkdirSync(dir)
       await this.page.tracing.start({ screenshots: true, path: fileName })
@@ -1326,7 +1327,7 @@ class Puppeteer extends Helper {
    * @param {string} [downloadPath='downloads'] change this parameter to set another directory for saving
    */
   async handleDownloads(downloadPath = 'downloads') {
-    downloadPath = path.join(global.output_dir, downloadPath)
+    downloadPath = path.join(store.outputDir, downloadPath)
     if (!fs.existsSync(downloadPath)) {
       fs.mkdirSync(downloadPath, '0777')
     }
@@ -1388,7 +1389,7 @@ class Puppeteer extends Helper {
       },
     })
 
-    const outputFile = path.join(`${global.output_dir}/${fileName}`)
+    const outputFile = path.join(`${store.outputDir}/${fileName}`)
 
     try {
       await new Promise((resolve, reject) => {
@@ -1595,9 +1596,18 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async fillField(field, value, context = null) {
-    const els = await findVisibleFields.call(this, field, context)
+    let els = await findVisibleFields.call(this, field, context)
+    if (!els.length) {
+      els = await findFields.call(this, field, context)
+    }
     assertElementExists(els, field, 'Field')
     const el = selectElement(els, field, this)
+
+    if (await fillRichEditor(this, el, value)) {
+      highlightActiveElement.call(this, el, await this._getContext())
+      return this._waitForAction()
+    }
+
     const tag = await el.getProperty('tagName').then(el => el.jsonValue())
     const editable = await el.getProperty('contenteditable').then(el => el.jsonValue())
     if (tag === 'INPUT' || tag === 'TEXTAREA') {
@@ -1656,7 +1666,7 @@ class Puppeteer extends Helper {
    * {{> attachFile }}
    */
   async attachFile(locator, pathToFile, context = null) {
-    const file = path.join(global.codecept_dir, pathToFile)
+    const file = path.join(store.codeceptDir, pathToFile)
 
     if (!fileExists(file)) {
       throw new Error(`File at ${file} can not be found on local system`)
@@ -3568,7 +3578,7 @@ function getNormalizedKey(key) {
 }
 
 function highlightActiveElement(element, context) {
-  if (this.options.highlightElement && global.debugMode) {
+  if (this.options.highlightElement && store.debugMode) {
     highlightElement(element, context)
   }
 }

package/lib/helper/WebDriver.js

@@ -42,6 +42,7 @@ import { dropFile } from './scripts/dropFile.js'
 import { dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics } from './network/actions.js'
 import WebElement from '../element/WebElement.js'
 import { selectElement } from './extras/elementSelection.js'
+import { fillRichEditor } from './extras/richTextEditor.js'
 
 const SHADOW = 'shadow'
 const webRoot = 'body'
@@ -1279,6 +1280,11 @@ class WebDriver extends Helper {
     assertElementExists(res, field, 'Field')
     const elem = selectElement(res, field, this)
     highlightActiveElement.call(this, elem)
+
+    if (await fillRichEditor(this, elem, value)) {
+      return
+    }
+
     try {
       await elem.clearValue()
     } catch (err) {
@@ -1353,7 +1359,7 @@ class WebDriver extends Helper {
    * {{> attachFile }}
    */
   async attachFile(locator, pathToFile, context = null) {
-    let file = path.join(global.codecept_dir, pathToFile)
+    let file = path.join(store.codeceptDir, pathToFile)
     if (!fileExists(file)) {
       throw new Error(`File at ${file} can not be found on local system`)
     }
@@ -3484,7 +3490,7 @@ function isModifierKey(key) {
 }
 
 function highlightActiveElement(element) {
-  if (this.options.highlightElement && global.debugMode) {
+  if (this.options.highlightElement && store.debugMode) {
     highlightElement(element, this.browser)
   }
 }

package/lib/helper/extras/Download.js

@@ -0,0 +1,45 @@
+import fs from 'fs'
+import path from 'path'
+import minimatch from 'minimatch'
+import store from '../../store.js'
+import assert from 'assert'
+
+function getDownloadDir() {
+  return path.join(store.outputDir, 'downloads')
+}
+
+function getNewFiles(downloadDir, sinceTimestamp) {
+  if (!fs.existsSync(downloadDir)) return []
+  return fs.readdirSync(downloadDir).filter(name => {
+    const stat = fs.statSync(path.join(downloadDir, name))
+    return stat.isFile() && stat.mtimeMs >= sinceTimestamp
+  })
+}
+
+function seeFileDownloaded(arg) {
+  const downloadDir = getDownloadDir()
+  const files = getNewFiles(downloadDir, this._downloadStartTimestamp)
+
+  if (arg === undefined || arg === null) {
+    assert.ok(files.length > 0, `No files downloaded to ${downloadDir}`)
+    return
+  }
+  if (typeof arg === 'number') {
+    assert.strictEqual(files.length, arg, `Expected ${arg} downloaded file(s), found ${files.length}: [${files.join(', ')}]`)
+    return
+  }
+  const regexMatch = arg.match(/^\/(.+)\/$/)
+  if (regexMatch) {
+    const re = new RegExp(regexMatch[1])
+    assert.ok(files.some(f => re.test(f)), `No file matches ${arg}. Downloaded: [${files.join(', ')}]`)
+    return
+  }
+  if (/[*?[\]]/.test(arg)) {
+    const matched = minimatch.match(files, arg)
+    assert.ok(matched.length > 0, `No file matches glob "${arg}". Downloaded: [${files.join(', ')}]`)
+    return
+  }
+  assert.ok(files.includes(arg), `File "${arg}" not downloaded. Downloaded: [${files.join(', ')}]`)
+}
+
+export { seeFileDownloaded, getDownloadDir }

package/lib/helper/extras/richTextEditor.js

@@ -0,0 +1,115 @@
+import WebElement from '../../element/WebElement.js'
+
+const MARKER = 'data-codeceptjs-rte-target'
+
+const EDITOR = {
+  STANDARD: 'standard',
+  IFRAME: 'iframe',
+  CONTENTEDITABLE: 'contenteditable',
+  HIDDEN_TEXTAREA: 'hidden-textarea',
+}
+
+function detectAndMark(el, opts) {
+  const marker = opts.marker
+  const kinds = opts.kinds
+  const CE = '[contenteditable="true"], [contenteditable=""]'
+  const MAX_HIDDEN_ASCENT = 3
+
+  function mark(kind, target) {
+    document.querySelectorAll('[' + marker + ']').forEach(n => n.removeAttribute(marker))
+    if (target && target.nodeType === 1) target.setAttribute(marker, '1')
+    return kind
+  }
+
+  if (!el || el.nodeType !== 1) return mark(kinds.STANDARD, el)
+
+  const tag = el.tagName
+  if (tag === 'IFRAME') return mark(kinds.IFRAME, el)
+  if (el.isContentEditable) return mark(kinds.CONTENTEDITABLE, el)
+
+  const canSearchDescendants = tag !== 'INPUT' && tag !== 'TEXTAREA'
+  if (canSearchDescendants) {
+    const iframe = el.querySelector('iframe')
+    if (iframe) return mark(kinds.IFRAME, iframe)
+    const ce = el.querySelector(CE)
+    if (ce) return mark(kinds.CONTENTEDITABLE, ce)
+    const textarea = el.querySelector('textarea')
+    if (textarea) return mark(kinds.HIDDEN_TEXTAREA, textarea)
+  }
+
+  const style = window.getComputedStyle(el)
+  const isHidden =
+    el.offsetParent === null ||
+    (el.offsetWidth === 0 && el.offsetHeight === 0) ||
+    style.display === 'none' ||
+    style.visibility === 'hidden'
+  if (!isHidden) return mark(kinds.STANDARD, el)
+
+  const isFormHidden = tag === 'INPUT' && el.type === 'hidden'
+  if (isFormHidden) return mark(kinds.STANDARD, el)
+
+  let scope = el.parentElement
+  for (let depth = 0; scope && depth < MAX_HIDDEN_ASCENT; depth++, scope = scope.parentElement) {
+    const iframeNear = scope.querySelector('iframe')
+    if (iframeNear) return mark(kinds.IFRAME, iframeNear)
+    const ceNear = scope.querySelector(CE)
+    if (ceNear) return mark(kinds.CONTENTEDITABLE, ceNear)
+    const textareaNear = [...scope.querySelectorAll('textarea')].find(t => t !== el)
+    if (textareaNear) return mark(kinds.HIDDEN_TEXTAREA, textareaNear)
+  }
+
+  return mark(kinds.STANDARD, el)
+}
+
+function selectAllInEditable(el) {
+  const doc = el.ownerDocument
+  const win = doc.defaultView
+  el.focus()
+  const range = doc.createRange()
+  range.selectNodeContents(el)
+  const sel = win.getSelection()
+  sel.removeAllRanges()
+  sel.addRange(range)
+}
+
+function unmarkAll(marker) {
+  document.querySelectorAll('[' + marker + ']').forEach(n => n.removeAttribute(marker))
+}
+
+async function findMarked(helper) {
+  const root = helper.page || helper.browser
+  const raw = await root.$('[' + MARKER + ']')
+  return new WebElement(raw, helper)
+}
+
+async function clearMarker(helper) {
+  if (helper.page) return helper.page.evaluate(unmarkAll, MARKER)
+  return helper.executeScript(unmarkAll, MARKER)
+}
+
+export async function fillRichEditor(helper, el, value) {
+  const source = el instanceof WebElement ? el : new WebElement(el, helper)
+  const kind = await source.evaluate(detectAndMark, { marker: MARKER, kinds: EDITOR })
+  if (kind === EDITOR.STANDARD) return false
+
+  const target = await findMarked(helper)
+  const delay = helper.options.pressKeyDelay
+
+  if (kind === EDITOR.IFRAME) {
+    await target.inIframe(async body => {
+      await body.evaluate(selectAllInEditable)
+      await body.typeText(value, { delay })
+    })
+  } else if (kind === EDITOR.HIDDEN_TEXTAREA) {
+    await target.focus()
+    await target.selectAllAndDelete()
+    await target.typeText(value, { delay })
+  } else if (kind === EDITOR.CONTENTEDITABLE) {
+    await target.click()
+    await target.evaluate(selectAllInEditable)
+    await target.typeText(value, { delay })
+  }
+
+  await clearMarker(helper)
+  return true
+}

package/lib/history.js

@@ -2,6 +2,7 @@ import colors from 'chalk'
 import fs from 'fs'
 import path from 'path'
 import output from './output.js'
+import store from './store.js'
 
 /**
  * REPL history records REPL commands and stores them in
@@ -9,8 +10,8 @@ import output from './output.js'
  */
 class ReplHistory {
   constructor() {
-    if (global.output_dir) {
-      this.historyFile = path.join(global.output_dir, 'cli-history')
+    if (store.outputDir) {
+      this.historyFile = path.join(store.outputDir, 'cli-history')
     }
     this.commands = []
   }

package/lib/listener/config.js

@@ -2,16 +2,18 @@ import event from '../event.js'
 import recorder from '../recorder.js'
 import { deepMerge, deepClone, ucfirst } from '../utils.js'
 import output from '../output.js'
+import container from '../container.js'
 
 /**
  * Enable Helpers to listen to test events
  */
+let initialized = false
+
 export default function () {
-  // Use global flag to prevent duplicate initialization across module re-imports
-  if (global.__codeceptConfigListenerInitialized) {
+  if (initialized) {
     return
   }
-  global.__codeceptConfigListenerInitialized = true
+  initialized = true
 
   enableDynamicConfigFor('suite')
   enableDynamicConfigFor('test')
@@ -20,7 +22,7 @@ export default function () {
     event.dispatcher.on(event[type].before, (context = {}) => {
       // Get helpers dynamically at runtime, not at initialization time
       // This ensures we get the actual helper instances, not placeholders
-      const helpers = global.container.helpers()
+      const helpers = container.helpers()
 
       function updateHelperConfig(helper, config) {
         // Guard against undefined or invalid helpers

package/lib/listener/emptyRun.js

@@ -1,6 +1,7 @@
 import figures from 'figures'
 import event from '../event.js'
 import output from '../output.js'
+import container from '../container.js'
 import { searchWithFusejs } from '../utils.js'
 
 export default function () {
@@ -12,7 +13,7 @@ export default function () {
 
   event.dispatcher.on(event.all.result, () => {
     if (isEmptyRun) {
-      const mocha = global.container.mocha()
+      const mocha = container.mocha()
 
       if (mocha.options.grep) {
         output.print()

package/lib/listener/helpers.js

@@ -3,11 +3,12 @@ import event from '../event.js'
 import recorder from '../recorder.js'
 import store from '../store.js'
 import output from '../output.js'
+import container from '../container.js'
 /**
  * Enable Helpers to listen to test events
  */
 export default function () {
-  const helpers = global.container.helpers()
+  const helpers = container.helpers()
 
   const runHelpersHook = (hook, param) => {
     if (store.dryRun) return
@@ -29,11 +30,13 @@ export default function () {
   event.dispatcher.on(event.suite.before, suite => {
     // if (suite.parent) return; // only for root suite
     runAsyncHelpersHook('_beforeSuite', suite, true)
+    recorder.catch()
   })
 
   event.dispatcher.on(event.suite.after, suite => {
     // if (suite.parent) return; // only for root suite
     runAsyncHelpersHook('_afterSuite', suite, true)
+    recorder.catch()
   })
 
   event.dispatcher.on(event.test.started, test => {