codeceptjs 4.0.0-rc.11 → 4.0.0-rc.16

package/lib/ai.js

@@ -7,6 +7,7 @@ import { generateText } from 'ai'
 import { fileURLToPath } from 'url'
 import path from 'path'
 import { fileExists } from './utils.js'
+import store from './store.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
@@ -24,8 +25,8 @@ async function loadPrompts() {
   for (const name of promptNames) {
     let promptPath
 
-    if (global.codecept_dir) {
-      promptPath = path.join(global.codecept_dir, `prompts/${name}.js`)
+    if (store.codeceptDir) {
+      promptPath = path.join(store.codeceptDir, `prompts/${name}.js`)
     }
 
     if (!promptPath || !fileExists(promptPath)) {

package/lib/assertions.js

@@ -0,0 +1,18 @@
+import Assertion from './assert.js'
+import { equals, urlEquals, fileEquals } from './assert/equal.js'
+import { includes, fileIncludes } from './assert/include.js'
+import { empty } from './assert/empty.js'
+import { truth } from './assert/truth.js'
+
+export { Assertion, equals, urlEquals, fileEquals, includes, fileIncludes, empty, truth }
+
+export default {
+  Assertion,
+  equals,
+  urlEquals,
+  fileEquals,
+  includes,
+  fileIncludes,
+  empty,
+  truth,
+}

package/lib/codecept.js

@@ -21,6 +21,7 @@ import { emptyFolder } from './utils.js'
 import { initCodeceptGlobals } from './globals.js'
 import { validateTypeScriptSetup, getTSNodeESMWarning } from './utils/loaderCheck.js'
 import recorder from './recorder.js'
+import store from './store.js'
 
 import storeListener from './listener/store.js'
 import stepsListener from './listener/steps.js'
@@ -71,7 +72,7 @@ class Codecept {
         } else {
           // For npm packages, resolve from the user's directory
           // This ensures packages like tsx are found in user's node_modules
-          const userDir = global.codecept_dir || process.cwd()
+          const userDir = store.codeceptDir || process.cwd()
           
           try {
             // Use createRequire to resolve from user's directory
@@ -102,8 +103,6 @@ class Codecept {
     await this.requireModules(this.requiringModules)
     // initializing listeners
     await container.create(this.config, this.opts)
-    // Store container globally for easy access
-    global.container = container
     await this.runHooks()
   }
 
@@ -129,6 +128,7 @@ class Codecept {
         './listener/config.js',
         './listener/result.js',
         './listener/helpers.js',
+        './listener/pageobjects.js',
         './listener/globalTimeout.js',
         './listener/globalRetry.js',
         './listener/retryEnhancer.js',
@@ -171,7 +171,7 @@ class Codecept {
    */
   loadTests(pattern) {
     const options = {
-      cwd: global.codecept_dir,
+      cwd: store.codeceptDir,
     }
 
     let patterns = [pattern]
@@ -203,7 +203,7 @@ class Codecept {
         globSync(pattern, options).forEach(file => {
           if (file.includes('node_modules')) return
           if (!fsPath.isAbsolute(file)) {
-            file = fsPath.join(global.codecept_dir, file)
+            file = fsPath.join(store.codeceptDir, file)
           }
           if (!this.testFiles.includes(fsPath.resolve(file))) {
             this.testFiles.push(fsPath.resolve(file))
@@ -293,7 +293,7 @@ class Codecept {
 
       if (test) {
         if (!fsPath.isAbsolute(test)) {
-          test = fsPath.join(global.codecept_dir, test)
+          test = fsPath.join(store.codeceptDir, test)
         }
         const testBasename = fsPath.basename(test, '.js')
         const testFeatureBasename = fsPath.basename(test, '.feature')

package/lib/command/check.js

@@ -135,6 +135,7 @@ export default async function (options) {
   printCheck('plugins', checks['plugins'], Object.keys(Container.plugins()).join(', '))
 
   if (Object.keys(helpers).length) {
+    store.dryRun = false
     const suite = Container.mocha().suite
     const test = createTest('test', () => {})
     checks.setup = true
@@ -154,7 +155,6 @@ export default async function (options) {
     checks.teardown = true
     for (const helper of Object.values(helpers).reverse()) {
       try {
-        if (helper._passed) await helper._passed(test)
         if (helper._after) await helper._after(test)
         if (helper._finishTest) await helper._finishTest(suite)
         if (helper._afterSuite) await helper._afterSuite(suite)
@@ -166,6 +166,7 @@ export default async function (options) {
     }
 
     printCheck('Helpers After', checks['teardown'], standardActingHelpers.some(h => Object.keys(helpers).includes(h)) ? 'Closing browser' : '')
+    store.dryRun = true
   }
 
   try {

package/lib/command/dryRun.js

@@ -20,8 +20,7 @@ export default async function (test, options) {
   if (config.plugins) {
     // disable all plugins by default, they can be enabled with -p option
     for (const plugin in config.plugins) {
-      // if `-p all` is passed, then enabling all plugins, otherwise plugins could be enabled by `-p customLocator,commentStep,tryTo`
-      config.plugins[plugin].enabled = options.plugins === 'all'
+      config.plugins[plugin].enabled = false
     }
   }
 
@@ -50,7 +49,7 @@ async function printTests(files) {
   const { default: figures } = await import('figures')
   const { default: colors } = await import('chalk')
 
-  output.print(output.styles.debug(`Tests from ${global.codecept_dir}:`))
+  output.print(output.styles.debug(`Tests from ${store.codeceptDir}:`))
   output.print()
 
   const mocha = Container.mocha()

package/lib/command/generate.js

@@ -5,6 +5,7 @@ import { mkdirp } from 'mkdirp'
 import path from 'path'
 import { fileExists, ucfirst, lcfirst, beautify } from '../utils.js'
 import output from '../output.js'
+import store from '../store.js'
 import generateDefinitions from './definitions.js'
 import { getConfig, getTestRoot, safeFileWrite, readConfig } from './utils.js'
 
@@ -20,6 +21,7 @@ Scenario('test something', async ({ {{actor}} }) => {
 // generates empty test
 export async function test(genPath) {
   const testsPath = getTestRoot(genPath)
+  store.codeceptDir = testsPath
   global.codecept_dir = testsPath
   const config = await getConfig(testsPath)
   if (!config) return

package/lib/command/gherkin/snippets.js

@@ -8,6 +8,7 @@ import fsPath from 'path'
 import { getConfig, getTestRoot } from '../utils.js'
 import Codecept from '../../codecept.js'
 import output from '../../output.js'
+import store from '../../store.js'
 import { matchStep } from '../../mocha/bdd.js'
 
 const uuidFn = IdGenerator.uuid()
@@ -43,9 +44,9 @@ export default async function (genPath, options) {
   }
 
   const files = []
-  globSync(options.feature || config.gherkin.features, { cwd: options.feature ? '.' : global.codecept_dir }).forEach(file => {
+  globSync(options.feature || config.gherkin.features, { cwd: options.feature ? '.' : store.codeceptDir }).forEach(file => {
     if (!fsPath.isAbsolute(file)) {
-      file = fsPath.join(global.codecept_dir, file)
+      file = fsPath.join(store.codeceptDir, file)
     }
     files.push(fsPath.resolve(file))
   })
@@ -92,7 +93,7 @@ export default async function (genPath, options) {
       if (child.scenario.keyword === 'Scenario Outline') continue // skip scenario outline
       parseSteps(child.scenario.steps)
         .map(step => {
-          return Object.assign(step, { file: file.replace(global.codecept_dir, '').slice(1) })
+          return Object.assign(step, { file: file.replace(store.codeceptDir, '').slice(1) })
         })
         .map(step => newSteps.set(`${step.type}(${step})`, step))
     }
@@ -107,7 +108,7 @@ export default async function (genPath, options) {
   }
 
   if (!fsPath.isAbsolute(stepFile)) {
-    stepFile = fsPath.join(global.codecept_dir, stepFile)
+    stepFile = fsPath.join(store.codeceptDir, stepFile)
   }
 
   const snippets = [...newSteps.values()]

package/lib/command/init.js

@@ -19,6 +19,7 @@ const defaultConfig = {
   output: '',
   helpers: {},
   include: {},
+  noGlobals: true,
   plugins: {
   },
 }

package/lib/command/run-multiple.js

@@ -8,6 +8,7 @@ import event from '../event.js'
 import { createRuns } from './run-multiple/collection.js'
 import { clearString, replaceValueDeep } from '../utils.js'
 import { getConfig, getTestRoot, fail } from './utils.js'
+import store from '../store.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -35,6 +36,7 @@ export default async function (selectedRuns, options) {
   const configFile = options.config
 
   const testRoot = getTestRoot(configFile)
+  store.codeceptDir = testRoot
   global.codecept_dir = testRoot
 
   // copy opts to run

package/lib/command/run-workers.js

@@ -41,6 +41,7 @@ export default async function (workerCount, selectedRuns, options) {
   output.print(`CodeceptJS v${Codecept.version()} ${output.standWithUkraine()}`)
   output.print(`Running tests in ${output.styles.bold(numberOfWorkers)} workers...`)
   store.hasWorkers = true
+  store.workerMode = true
   process.env.RUNS_WITH_WORKERS = 'true'
 
   const workers = new Workers(numberOfWorkers, config)

package/lib/command/run.js

@@ -32,7 +32,7 @@ export default async function (test, options) {
     codecept.loadTests(test)
 
     if (options.verbose) {
-      global.debugMode = true
+      store.debugMode = true
       const { getMachineInfo } = await import('./info.js')
       await getMachineInfo()
     }

package/lib/command/workers/runTests.js

@@ -21,8 +21,8 @@ const { options, tests, testRoot, workerIndex, poolMode } = workerData
 
 // Global error handlers to catch critical errors but not test failures
 process.on('uncaughtException', (err) => {
-  if (global.container?.tsFileMapping && fixErrorStack) {
-    const fileMapping = global.container.tsFileMapping()
+  if (container?.tsFileMapping && fixErrorStack) {
+    const fileMapping = container.tsFileMapping()
     if (fileMapping) {
       fixErrorStack(err, fileMapping)
     }
@@ -40,8 +40,8 @@ process.on('uncaughtException', (err) => {
 })
 
 process.on('unhandledRejection', (reason, promise) => {
-  if (reason && typeof reason === 'object' && reason.stack && global.container?.tsFileMapping && fixErrorStack) {
-    const fileMapping = global.container.tsFileMapping()
+  if (reason && typeof reason === 'object' && reason.stack && container?.tsFileMapping && fixErrorStack) {
+    const fileMapping = container.tsFileMapping()
     if (fileMapping) {
       fixErrorStack(reason, fileMapping)
     }
@@ -163,8 +163,8 @@ initPromise = (async function () {
       // IMPORTANT: await is required here since getConfig is async
       baseConfig = await getConfig(options.config || testRoot)
     } catch (configErr) {
-      if (global.container?.tsFileMapping && fixErrorStack) {
-        const fileMapping = global.container.tsFileMapping()
+      if (container?.tsFileMapping && fixErrorStack) {
+        const fileMapping = container.tsFileMapping()
         if (fileMapping) {
           fixErrorStack(configErr, fileMapping)
         }
@@ -185,8 +185,8 @@ initPromise = (async function () {
     try {
       await codecept.init(testRoot)
     } catch (initErr) {
-      if (global.container?.tsFileMapping && fixErrorStack) {
-        const fileMapping = global.container.tsFileMapping()
+      if (container?.tsFileMapping && fixErrorStack) {
+        const fileMapping = container.tsFileMapping()
         if (fileMapping) {
           fixErrorStack(initErr, fileMapping)
         }
@@ -218,8 +218,8 @@ initPromise = (async function () {
       parentPort?.close()
     }
   } catch (err) {
-    if (global.container?.tsFileMapping && fixErrorStack) {
-      const fileMapping = global.container.tsFileMapping()
+    if (container?.tsFileMapping && fixErrorStack) {
+      const fileMapping = container.tsFileMapping()
       if (fileMapping) {
         fixErrorStack(err, fileMapping)
       }

package/lib/container.js

@@ -18,6 +18,11 @@ import actorFactory from './actor.js'
 
 let asyncHelperPromise
 
+let beforeCalledSet = new Set()
+
+export function getBeforeCalledSet() { return beforeCalledSet }
+export function resetBeforeCalledSet() { beforeCalledSet = new Set() }
+
 let container = {
   helpers: {},
   support: {},
@@ -150,10 +155,23 @@ class Container {
     if (!name) {
       return container.proxySupport
     }
-    // Always return the proxy to ensure MetaStep creation works
+    if (typeof container.support[name] === 'function') {
+      return container.support[name]
+    }
     return container.proxySupport[name]
   }
 
+  /**
+   * Get raw (non-proxied) support objects for direct access.
+   * Used by listeners to call lifecycle hooks without MetaStep wrapping.
+   *
+   * @api
+   * @returns {object}
+   */
+  static supportObjects() {
+    return container.support
+  }
+
   /**
    * Get all helpers or get a helper by name
    *
@@ -183,7 +201,7 @@ class Container {
    * @api
    */
   static tsFileMapping() {
-    return container.tsFileMapping
+    return store.tsFileMapping
   }
 
   /**
@@ -426,11 +444,11 @@ async function requireHelperFromModule(helperName, config, HelperClass) {
         tempJsFile = allTempFiles
         fileMapping = mapping
         // Store file mapping in container for runtime error fixing (merge with existing)
-        if (!container.tsFileMapping) {
-          container.tsFileMapping = new Map()
+        if (!store.tsFileMapping) {
+          store.tsFileMapping = new Map()
         }
         for (const [key, value] of mapping.entries()) {
-          container.tsFileMapping.set(key, value)
+          store.tsFileMapping.set(key, value)
         }
       } catch (tsError) {
         throw new Error(`Failed to load TypeScript helper ${importPath}: ${tsError.message}. Make sure 'typescript' package is installed.`)
@@ -542,6 +560,19 @@ function createSupportObjects(config) {
           let currentValue = currentObject[prop]
 
           if (isFunction(currentValue) || isAsyncFunction(currentValue)) {
+            if (prop.toString().charAt(0) !== '_' && currentObject._before && !beforeCalledSet.has(name)) {
+              beforeCalledSet.add(name)
+              const originalValue = currentValue
+              const wrappedValue = async function (...args) {
+                await currentObject._before()
+                return originalValue.apply(currentObject, args)
+              }
+              const ms = new MetaStep(name, prop)
+              ms.setContext(currentObject)
+              debug(`metastep is created for ${name}.${prop.toString()}() (with _before)`)
+              return ms.run.bind(ms, asyncWrapper(wrappedValue))
+            }
+
             const ms = new MetaStep(name, prop)
             ms.setContext(currentObject)
             if (isAsyncFunction(currentValue)) currentValue = asyncWrapper(currentValue)
@@ -600,6 +631,8 @@ function createSupportObjects(config) {
         let value
         if (container.sharedKeys.has(prop) && prop in container.support) {
           value = container.support[prop]
+        } else if (prop in container.support && typeof container.support[prop] === 'function') {
+          value = container.support[prop]
         } else {
           value = lazyLoad(prop)
         }
@@ -614,6 +647,9 @@ function createSupportObjects(config) {
         if (container.sharedKeys.has(key) && key in container.support) {
           return container.support[key]
         }
+        if (key in container.support && typeof container.support[key] === 'function') {
+          return container.support[key]
+        }
         return lazyLoad(key)
       },
     },
@@ -654,14 +690,28 @@ async function loadPluginFallback(modulePath, config) {
 async function createPlugins(config, options = {}) {
   const plugins = {}
 
-  const enabledPluginsByOptions = (options.plugins || '').split(',')
+  const pluginOptionMap = new Map()
+  for (const token of (options.plugins || '').split(',').filter(Boolean)) {
+    const parts = token.split(':')
+    pluginOptionMap.set(parts[0], parts.slice(1))
+  }
+
+  for (const [name] of pluginOptionMap) {
+    if (!config[name]) config[name] = {}
+  }
+
   for (const pluginName in config) {
     if (!config[pluginName]) config[pluginName] = {}
     const pluginConfig = config[pluginName]
-    if (!pluginConfig.enabled && enabledPluginsByOptions.indexOf(pluginName) < 0) {
+    const enabledByCli = pluginOptionMap.has(pluginName)
+    if (!pluginConfig.enabled && !enabledByCli) {
       continue // plugin is disabled
     }
 
+    if (enabledByCli && pluginOptionMap.get(pluginName).length > 0) {
+      pluginConfig._args = pluginOptionMap.get(pluginName)
+    }
+
     // Generic workers gate:
     // - runInWorker / runInWorkers controls plugin execution inside worker threads.
     // - runInParent / runInMain can disable plugin in workers parent process.
@@ -672,7 +722,7 @@ async function createPlugins(config, options = {}) {
       continue
     }
 
-    if (!options.child && process.env.RUNS_WITH_WORKERS === 'true' && !runInParent) {
+    if (!options.child && store.workerMode && !runInParent) {
       continue
     }
     let module
@@ -681,7 +731,7 @@ async function createPlugins(config, options = {}) {
         module = pluginConfig.require
         if (module.startsWith('.')) {
           // local
-          module = path.resolve(global.codecept_dir, module) // custom plugin
+          module = path.resolve(store.codeceptDir, module) // custom plugin
         }
       } else {
         module = `./plugin/${pluginName}.js`
@@ -716,7 +766,7 @@ async function loadGherkinStepsAsync(paths) {
       bddModule.clearCurrentStepFile()
     }
   } else {
-    const folderPath = paths.startsWith('.') ? normalizeAndJoin(global.codecept_dir, paths) : ''
+    const folderPath = paths.startsWith('.') ? normalizeAndJoin(store.codeceptDir, paths) : ''
     if (folderPath !== '') {
       const files = globSync(folderPath)
       for (const file of files) {
@@ -764,7 +814,7 @@ async function loadSupportObject(modulePath, supportObjectName) {
     }
   }
   if (typeof modulePath === 'string' && modulePath.charAt(0) === '.') {
-    modulePath = path.join(global.codecept_dir, modulePath)
+    modulePath = path.join(store.codeceptDir, modulePath)
   }
   try {
     // Use dynamic import for both ESM and CJS modules
@@ -888,7 +938,7 @@ async function loadTranslation(locale, vocabularies) {
   const langs = await Translation.getLangs()
   if (langs[locale]) {
     translation = new Translation(langs[locale])
-  } else if (fileExists(path.join(global.codecept_dir, locale))) {
+  } else if (fileExists(path.join(store.codeceptDir, locale))) {
     // get from a provided file instead
     translation = Translation.createDefault()
     translation.loadVocabulary(locale)
@@ -905,7 +955,7 @@ function getHelperModuleName(helperName, config) {
   // classical require
   if (config[helperName].require) {
     if (config[helperName].require.startsWith('.')) {
-      let helperPath = path.resolve(global.codecept_dir, config[helperName].require)
+      let helperPath = path.resolve(store.codeceptDir, config[helperName].require)
       // Add .js extension if not present for ESM compatibility
       if (!path.extname(helperPath)) {
         helperPath += '.js'

package/lib/effects.js

@@ -4,6 +4,7 @@ import store from './store.js'
 import event from './event.js'
 import container from './container.js'
 import MetaStep from './step/meta.js'
+import { empty } from './assert/empty.js'
 import { isAsyncFunction } from './utils.js'
 
 /**
@@ -111,6 +112,11 @@ class WithinStep extends MetaStep {
  *
  * @throws Will handle errors that occur during the callback execution. Errors are logged and attached as notes to the test.
  */
+let hopeThatFailures = []
+event.dispatcher.on(event.test.before, () => {
+  hopeThatFailures = []
+})
+
 async function hopeThat(callback) {
   if (store.dryRun) return
   const sessionName = 'hopeThat'
@@ -131,6 +137,7 @@ async function hopeThat(callback) {
         result = false
         const msg = err.inspect ? err.inspect() : err.toString()
         output.debug(`Unsuccessful assertion > ${msg}`)
+        hopeThatFailures.push(msg)
         event.dispatcher.once(event.test.finished, test => {
           if (!test.notes) test.notes = []
           test.notes.push({ type: 'conditionalError', text: msg })
@@ -153,6 +160,16 @@ async function hopeThat(callback) {
   )
 }
 
+/**
+ * Asserts that no `hopeThat` soft assertion has failed in the current test.
+ * Call once at the end of a scenario to fail it when any soft assertion failed.
+ */
+hopeThat.noErrors = function () {
+  const failures = hopeThatFailures
+  hopeThatFailures = []
+  empty('soft assertions').assert(failures)
+}
+
 /**
  * A CodeceptJS utility function to retry a step or callback multiple times with a specified polling interval.
  *

package/lib/element/WebElement.js

@@ -256,6 +256,134 @@ class WebElement {
     }
   }
 
+  /**
+   * Run a function in the browser with this element as the first argument.
+   * @param {Function} fn Browser-side function. Receives the element, then extra args.
+   * @param {...any} args Additional arguments passed to the function
+   * @returns {Promise<any>} Value returned by fn
+   */
+  async evaluate(fn, ...args) {
+    switch (this.helperType) {
+      case 'playwright':
+      case 'puppeteer':
+        return this.element.evaluate(fn, ...args)
+      case 'webdriver':
+        return this.helper.executeScript(fn, this.element, ...args)
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Focus the element.
+   * @returns {Promise<void>}
+   */
+  async focus() {
+    switch (this.helperType) {
+      case 'playwright':
+        return this.element.focus()
+      case 'puppeteer':
+        if (this.element.focus) return this.element.focus()
+        return this.element.evaluate(el => el.focus())
+      case 'webdriver':
+        return this.helper.executeScript(el => el.focus(), this.element)
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Type characters via the page/browser keyboard into the focused element.
+   * Unlike `type()`, this does not call `.fill()`/`.setValue()`, so it works
+   * with contenteditable nodes, iframe bodies, and editor-owned hidden textareas.
+   * @param {string} text Text to send
+   * @param {Object} [options] Options (e.g. `{ delay }`)
+   * @returns {Promise<void>}
+   */
+  async typeText(text, options = {}) {
+    const s = String(text)
+    switch (this.helperType) {
+      case 'playwright':
+      case 'puppeteer':
+        return this.helper.page.keyboard.type(s, options)
+      case 'webdriver': {
+        const ENTER = '\uE007'
+        const parts = s.split('\n')
+        for (let i = 0; i < parts.length; i++) {
+          if (parts[i]) await this.helper.browser.keys(parts[i])
+          if (i < parts.length - 1) await this.helper.browser.keys(ENTER)
+        }
+        return
+      }
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Select all content in the focused field and delete it via keyboard input.
+   * Sends Ctrl+A and Meta+A (so it works across platforms) followed by Backspace.
+   * @returns {Promise<void>}
+   */
+  async selectAllAndDelete() {
+    switch (this.helperType) {
+      case 'playwright':
+        await this.helper.page.keyboard.press('Control+a').catch(() => {})
+        await this.helper.page.keyboard.press('Meta+a').catch(() => {})
+        await this.helper.page.keyboard.press('Backspace')
+        return
+      case 'puppeteer':
+        for (const mod of ['Control', 'Meta']) {
+          try {
+            await this.helper.page.keyboard.down(mod)
+            await this.helper.page.keyboard.press('KeyA')
+            await this.helper.page.keyboard.up(mod)
+          } catch (e) {}
+        }
+        await this.helper.page.keyboard.press('Backspace')
+        return
+      case 'webdriver': {
+        const b = this.helper.browser
+        await b.keys(['Control', 'a']).catch(() => {})
+        await b.keys(['Meta', 'a']).catch(() => {})
+        await b.keys(['Backspace'])
+        return
+      }
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Treat this element as an iframe; invoke `fn` with a WebElement wrapping
+   * the iframe body. For WebDriver this switches the browser into the frame
+   * for the duration of the callback and switches back on exit.
+   * @param {(body: WebElement) => Promise<any>} fn
+   * @returns {Promise<any>} Return value of fn
+   */
+  async inIframe(fn) {
+    switch (this.helperType) {
+      case 'playwright':
+      case 'puppeteer': {
+        const frame = await this.element.contentFrame()
+        const body = await frame.$('body')
+        return fn(new WebElement(body, this.helper))
+      }
+      case 'webdriver': {
+        const browser = this.helper.browser
+        await browser.switchFrame(this.element)
+        try {
+          const body = await browser.$('body')
+          return await fn(new WebElement(body, this.helper))
+        } finally {
+          await browser.switchFrame(null)
+        }
+      }
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
   /**
    * Find first child element matching the locator
    * @param {string|Object} locator Element locator