codeceptjs 4.0.0-rc.2 → 4.0.0-rc.20

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/PlaywrightReactVueLocator.js

@@ -1,52 +1,61 @@
+import fs from 'fs'
+import { fileURLToPath } from 'url'
+
+let resqScript
+
 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 = '';
+  const page = typeof matcher.page === 'function' ? matcher.page() : matcher
 
-  if (reactLocator.props) {
-    props += propBuilder(reactLocator.props);
-    _locator += props;
+  if (!resqScript) {
+    resqScript = fs.readFileSync(fileURLToPath(import.meta.resolve('resq'))).toString()
   }
-  return matcher.locator(_locator).all();
-}
+  await page.evaluate(resqScript)
+  await page.evaluate(() => window.resq.waitToLoadReact())
+
+  const arrayHandle = await page.evaluateHandle(
+    ({ selector, props, state }) => {
+      let elements = window.resq.resq$$(selector)
+      if (Object.keys(props).length) elements = elements.byProps(props)
+      if (Object.keys(state).length) elements = elements.byState(state)
+      if (!elements.length) return []
 
-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 = '';
+      let nodes = []
+      elements.forEach(element => {
+        let { node, isFragment } = element
+        if (!node) {
+          isFragment = true
+          node = element.children
+        }
+        if (isFragment) nodes = nodes.concat(node)
+        else nodes.push(node)
+      })
+      return [...nodes]
+    },
+    {
+      selector: reactLocator.react,
+      props: reactLocator.props || {},
+      state: reactLocator.state || {},
+    },
+  )
 
-  if (vueLocator.props) {
-    props += propBuilder(vueLocator.props);
-    _locator += props;
+  const properties = await arrayHandle.getProperties()
+  await arrayHandle.dispose()
+  const result = []
+  for (const property of properties.values()) {
+    const elementHandle = property.asElement()
+    if (elementHandle) result.push(elementHandle)
   }
-  return matcher.locator(_locator).all();
+  return result
 }
 
 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]);
+    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;
+  return matcher.locator(pwValue).all()
 }
 
-export { findReact, findVue, findByPlaywrightLocator };
+export { findReact, findByPlaywrightLocator }

package/lib/helper/extras/elementSelection.js

@@ -0,0 +1,58 @@
+import store from '../../store.js'
+import output from '../../output.js'
+import WebElement from '../../element/WebElement.js'
+import MultipleElementsFound from '../errors/MultipleElementsFound.js'
+
+function resolveElementIndex(value) {
+  if (value === 'first') return 1
+  if (value === 'last') return -1
+  return value
+}
+
+function isStrictStep(opts, helper) {
+  if (opts?.exact === true || opts?.strictMode === true) return true
+  if (opts?.exact === false || opts?.strictMode === false) return false
+  return helper.options.strict
+}
+
+function selectElement(els, locator, helper) {
+  const opts = store.currentStep?.opts
+  const rawIndex = opts?.elementIndex
+  const elementIndex = resolveElementIndex(rawIndex)
+
+  if (elementIndex != null) {
+    if (els.length === 1) return els[0]
+
+    if (!Number.isInteger(elementIndex) || elementIndex === 0) {
+      throw new Error(`elementIndex must be a non-zero integer or 'first'/'last', got: ${rawIndex}`)
+    }
+
+    let idx
+    if (elementIndex > 0) {
+      idx = elementIndex - 1
+      if (idx >= els.length) {
+        throw new Error(`elementIndex ${elementIndex} exceeds the number of elements found (${els.length}) for "${locator}"`)
+      }
+    } else {
+      idx = els.length + elementIndex
+      if (idx < 0) {
+        throw new Error(`elementIndex ${elementIndex} exceeds the number of elements found (${els.length}) for "${locator}"`)
+      }
+    }
+
+    output.debug(`[Elements] Using element #${elementIndex} out of ${els.length}`)
+    return els[idx]
+  }
+
+  if (isStrictStep(opts, helper)) {
+    if (els.length > 1) {
+      const webElements = Array.from(els).map(el => new WebElement(el, helper))
+      throw new MultipleElementsFound(locator, webElements)
+    }
+  }
+
+  if (els.length > 1) output.debug(`[Elements] Using first element out of ${els.length}`)
+  return els[0]
+}
+
+export { selectElement }

package/lib/helper/extras/focusCheck.js

@@ -0,0 +1,43 @@
+import store from '../../store.js'
+import NonFocusedType from '../errors/NonFocusedType.js'
+
+const MODIFIER_PATTERN = /^(control|ctrl|meta|cmd|command|commandorcontrol|ctrlorcommand)/i
+const EDITING_KEYS = new Set(['a', 'c', 'x', 'v', 'z', 'y'])
+
+async function isNoElementFocused(helper) {
+  return helper.executeScript(() => {
+    const ae = document.activeElement
+    return !ae || ae === document.documentElement || (ae === document.body && !ae.isContentEditable)
+  })
+}
+
+export async function checkFocusBeforeType(helper) {
+  if (!helper.options.strict && !store.debugMode) return
+  if (!await isNoElementFocused(helper)) return
+
+  const message = 'No element is in focus. Use I.click() or I.focus() to activate an element before typing.'
+  if (helper.options.strict) throw new NonFocusedType(message)
+  helper.debugSection('Warning', message)
+}
+
+export async function checkFocusBeforePressKey(helper, originalKey) {
+  if (!helper.options.strict && !store.debugMode) return
+  if (!Array.isArray(originalKey)) return
+
+  let hasCtrlOrMeta = false
+  let actionKey = null
+  for (const k of originalKey) {
+    if (MODIFIER_PATTERN.test(k)) {
+      hasCtrlOrMeta = true
+    } else {
+      actionKey = k
+    }
+  }
+  if (!hasCtrlOrMeta || !actionKey || !EDITING_KEYS.has(actionKey.toLowerCase())) return
+
+  if (!await isNoElementFocused(helper)) return
+
+  const message = `No element is in focus. Key combination with "${originalKey.join('+')}" may not work as expected. Use I.click() or I.focus() first.`
+  if (helper.options.strict) throw new NonFocusedType(message)
+  helper.debugSection('Warning', message)
+}

package/lib/helper/extras/richTextEditor.js

@@ -0,0 +1,178 @@
+import WebElement from '../../element/WebElement.js'
+
+const MARKER = 'data-codeceptjs-rte-target'
+
+const EDITOR = {
+  STANDARD: 'standard',
+  IFRAME: 'iframe',
+  CONTENTEDITABLE: 'contenteditable',
+  HIDDEN_TEXTAREA: 'hidden-textarea',
+  UNREACHABLE: 'unreachable',
+}
+
+function detectAndMark(el, opts) {
+  const marker = opts.marker
+  const kinds = opts.kinds
+  const CE = '[contenteditable="true"], [contenteditable=""]'
+
+  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 isFormHidden = tag === 'INPUT' && el.type === 'hidden'
+  if ((tag === 'INPUT' || tag === 'TEXTAREA') && !isFormHidden) {
+    const style = window.getComputedStyle(el)
+    if (style.display === 'none') return mark(kinds.UNREACHABLE, 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 textareas = [...el.querySelectorAll('textarea')]
+    const focusable = textareas.find(t => window.getComputedStyle(t).display !== 'none')
+    const textarea = focusable || textareas[0]
+    if (textarea) return mark(kinds.HIDDEN_TEXTAREA, textarea)
+  }
+
+  return mark(kinds.STANDARD, el)
+}
+
+function detectInsideFrame() {
+  const MARKER = 'data-codeceptjs-rte-target'
+  const CE = '[contenteditable="true"], [contenteditable=""]'
+  const CONTENTEDITABLE = 'contenteditable'
+  const HIDDEN_TEXTAREA = 'hidden-textarea'
+  const body = document.body
+  document.querySelectorAll('[' + MARKER + ']').forEach(n => n.removeAttribute(MARKER))
+
+  if (body.isContentEditable) return CONTENTEDITABLE
+
+  const ce = body.querySelector(CE)
+  if (ce) {
+    ce.setAttribute(MARKER, '1')
+    return CONTENTEDITABLE
+  }
+
+  const textareas = [...body.querySelectorAll('textarea')]
+  const focusable = textareas.find(t => window.getComputedStyle(t).display !== 'none')
+  const textarea = focusable || textareas[0]
+  if (textarea) {
+    textarea.setAttribute(MARKER, '1')
+    return HIDDEN_TEXTAREA
+  }
+
+  return CONTENTEDITABLE
+}
+
+async function evaluateInFrame(helper, body, fn) {
+  if (body.helperType === 'webdriver') {
+    return helper.executeScript(fn)
+  }
+  return body.element.evaluate(fn)
+}
+
+function focusMarkedInFrameScript() {
+  const el = document.querySelector('[data-codeceptjs-rte-target]') || document.body
+  el.focus()
+  return document.activeElement === el
+}
+
+function selectAllInFrameScript() {
+  const el = document.querySelector('[data-codeceptjs-rte-target]') || document.body
+  el.focus()
+  const range = document.createRange()
+  range.selectNodeContents(el)
+  const sel = window.getSelection()
+  sel.removeAllRanges()
+  sel.addRange(range)
+  return document.activeElement === 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))
+}
+
+function isActive(el) {
+  return el.ownerDocument.activeElement === el
+}
+
+async function assertFocused(target) {
+  const focused = await target.evaluate(isActive)
+  if (!focused) {
+    throw new Error('fillField: rich editor target did not accept focus. Locator must point at the visible editor surface (a wrapper, iframe, or contenteditable) — not a hidden backing element.')
+  }
+}
+
+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
+  if (kind === EDITOR.UNREACHABLE) {
+    throw new Error('fillField: cannot fill a display:none form control. Locator must point at the visible editor surface (a wrapper, iframe, or contenteditable).')
+  }
+
+  const target = await findMarked(helper)
+  const delay = helper.options.pressKeyDelay
+
+  if (kind === EDITOR.IFRAME) {
+    await target.inIframe(async body => {
+      const innerKind = await evaluateInFrame(helper, body, detectInsideFrame)
+      if (innerKind === EDITOR.HIDDEN_TEXTAREA) {
+        const focused = await evaluateInFrame(helper, body, focusMarkedInFrameScript)
+        if (!focused) throw new Error('fillField: rich editor target inside iframe did not accept focus.')
+        await body.selectAllAndDelete()
+        await body.typeText(value, { delay })
+      } else {
+        const focused = await evaluateInFrame(helper, body, selectAllInFrameScript)
+        if (!focused) throw new Error('fillField: rich editor target inside iframe did not accept focus.')
+        await body.typeText(value, { delay })
+      }
+    })
+  } else if (kind === EDITOR.HIDDEN_TEXTAREA) {
+    await target.focus()
+    await assertFocused(target)
+    await target.selectAllAndDelete()
+    await target.typeText(value, { delay })
+  } else if (kind === EDITOR.CONTENTEDITABLE) {
+    await target.click()
+    await target.evaluate(selectAllInEditable)
+    await assertFocused(target)
+    await target.typeText(value, { delay })
+  }
+
+  await clearMarker(helper)
+  return true
+}

package/lib/helper/scripts/dropFile.js

@@ -0,0 +1,11 @@
+export const dropFile = (el, { base64Content, fileName, mimeType }) => {
+  const binaryStr = atob(base64Content)
+  const bytes = new Uint8Array(binaryStr.length)
+  for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i)
+  const fileObj = new File([bytes], fileName, { type: mimeType })
+  const dataTransfer = new DataTransfer()
+  dataTransfer.items.add(fileObj)
+  el.dispatchEvent(new DragEvent('dragenter', { dataTransfer, bubbles: true }))
+  el.dispatchEvent(new DragEvent('dragover', { dataTransfer, bubbles: true }))
+  el.dispatchEvent(new DragEvent('drop', { dataTransfer, bubbles: 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/html.js

@@ -1,5 +1,8 @@
 import { parse, serialize } from 'parse5'
 import { minify } from 'html-minifier-terser'
+import beautify from 'js-beautify'
+
+const { html: html_beautify } = beautify
 
 async function minifyHtml(html) {
   return minify(html, {
@@ -14,6 +17,62 @@ async function minifyHtml(html) {
   })
 }
 
+const TRASH_HTML_CLASSES = /^(text-|color-|flex-|float-|v-|ember-|d-|border-)/
+
+function isTrashClass(className) {
+  if (!className) return true
+  if (/\d/.test(className)) return true
+  if (TRASH_HTML_CLASSES.test(className)) return true
+  if (/(:|__)/.test(className)) return true
+  return false
+}
+
+function filterClassValue(value) {
+  return (value || '')
+    .split(/\s+/)
+    .filter(c => c && !isTrashClass(c))
+    .join(' ')
+}
+
+const DROP_TAGS = new Set(['style', 'noscript'])
+const DROP_ATTRS = new Set(['style'])
+
+function cleanHtml(html) {
+  const document = parse(html)
+
+  function walk(node) {
+    if (!node) return false
+
+    if (DROP_TAGS.has(node.nodeName) || (node.nodeName === 'script' && !(node.attrs || []).some(a => a.name === 'src'))) {
+      const parent = node.parentNode
+      const idx = parent.childNodes.indexOf(node)
+      if (idx >= 0) parent.childNodes.splice(idx, 1)
+      return true
+    }
+
+    if (node.attrs) {
+      node.attrs = node.attrs.filter(attr => {
+        if (DROP_ATTRS.has(attr.name)) return false
+        if (attr.name === 'class') {
+          attr.value = filterClassValue(attr.value)
+          if (!attr.value) return false
+        }
+        return true
+      })
+    }
+
+    if (node.childNodes) {
+      for (let i = node.childNodes.length - 1; i >= 0; i--) {
+        walk(node.childNodes[i])
+      }
+    }
+    return false
+  }
+
+  walk(document)
+  return serialize(document)
+}
+
 const defaultHtmlOpts = {
   interactiveElements: ['a', 'input', 'button', 'select', 'textarea', 'option'],
   textElements: ['label', 'h1', 'h2'],
@@ -28,7 +87,6 @@ function removeNonInteractiveElements(html, opts = {}) {
   // Parse the HTML into a document tree
   const document = parse(html)
 
-  const trashHtmlClasses = /^(text-|color-|flex-|float-|v-|ember-|d-|border-)/
   // Array to store interactive elements
   const removeElements = ['path', 'script']
 
@@ -103,21 +161,10 @@ function removeNonInteractiveElements(html, opts = {}) {
     if (node.attrs) {
       // Filter and keep allowed attributes, accessibility attributes
       node.attrs = node.attrs.filter(attr => {
-        const { name, value } = attr
-        if (name === 'class') {
-          // Remove classes containing digits
-          attr.value = value
-            .split(' ')
-            // remove classes containing digits/
-            .filter(className => !/\d/.test(className))
-            // remove popular trash classes
-            .filter(className => !className.match(trashHtmlClasses))
-            // remove classes with : and __ in them
-            .filter(className => !className.match(/(:|__)/))
-            .join(' ')
+        if (attr.name === 'class') {
+          attr.value = filterClassValue(attr.value)
         }
-
-        return allowedAttrs.includes(name)
+        return allowedAttrs.includes(attr.name)
       })
     }
 
@@ -245,4 +292,44 @@ function splitByChunks(text, chunkSize) {
   return chunks.map(chunk => chunk.trim())
 }
 
-export { scanForErrorMessages, removeNonInteractiveElements, splitByChunks, minifyHtml }
+function simplifyHtmlElement(html, maxLength = 300) {
+  try {
+    html = removeNonInteractiveElements(html)
+    html = html.replace(/<html>(?:<head>.*?<\/head>)?<body>(.*)<\/body><\/html>/s, '$1').trim()
+  } catch (e) {
+    // keep raw html if minification fails
+  }
+  if (html.length > maxLength) {
+    html = html.slice(0, maxLength) + '...'
+  }
+  return html
+}
+
+async function formatHtml(html) {
+  let processed = html
+  try {
+    processed = await minifyHtml(processed)
+  } catch (e) {
+    // keep raw html if minification fails
+  }
+  try {
+    processed = cleanHtml(processed)
+  } catch (e) {
+    // keep minified html if cleaning fails
+  }
+  try {
+    return html_beautify(processed, {
+      indent_size: 2,
+      wrap_line_length: 0,
+      preserve_newlines: false,
+      end_with_newline: false,
+      // Force every element onto its own line so line numbers in trace HTML
+      // map 1:1 to elements (consumed by codeceptq for AI/agent debugging).
+      inline: [],
+    })
+  } catch (e) {
+    return processed
+  }
+}
+
+export { scanForErrorMessages, removeNonInteractiveElements, splitByChunks, minifyHtml, simplifyHtmlElement, formatHtml, cleanHtml, isTrashClass }

package/lib/index.js

@@ -23,6 +23,10 @@ import heal from './heal.js'
 import ai from './ai.js'
 import Workers from './workers.js'
 import Secret, { secret } from './secret.js'
+import session from './session.js'
+
+const inject = (name) => container.support(name)
+const locate = (query) => locator.build(query)
 
 export default {
   /** @type {typeof CodeceptJS.Codecept} */
@@ -67,7 +71,11 @@ export default {
   Secret,
   /** @type {typeof CodeceptJS.secret} */
   secret,
+
+  session,
+  inject,
+  locate,
 }
 
 // Named exports for ESM compatibility
-export { codecept, output, container, event, recorder, config, actor, helper, pause, within, dataTable, dataTableArgument, store, locator, heal, ai, Workers, Secret, secret }
+export { codecept, output, container, event, recorder, config, actor, helper, pause, within, dataTable, dataTableArgument, store, locator, heal, ai, Workers, Secret, secret, session, inject, locate }

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()