codeceptjs 4.0.0-rc.9 → 4.0.0

package/lib/els.js

@@ -6,10 +6,11 @@ import recordStep from './step/record.js'
 import FuncStep from './step/func.js'
 import { truth } from './assert/truth.js'
 import { isAsyncFunction, humanizeFunction } from './utils.js'
+import WebElement from './element/WebElement.js'
 
 function element(purpose, locator, fn) {
   let stepConfig
-  if (arguments[arguments.length - 1] instanceof StepConfig) {
+  if (StepConfig.isStepConfig(arguments[arguments.length - 1])) {
     stepConfig = arguments[arguments.length - 1]
   }
 
@@ -28,7 +29,8 @@ function element(purpose, locator, fn) {
       const els = await step.helper._locate(locator)
       output.debug(`Found ${els.length} elements, using first element`)
 
-      return fn(els[0])
+      const wrapped = new WebElement(els[0], step.helper)
+      return fn(wrapped)
     },
     stepConfig,
   )
@@ -52,7 +54,8 @@ function eachElement(purpose, locator, fn) {
     let i = 0
     for (const el of els) {
       try {
-        await fn(el, i)
+        const wrapped = new WebElement(el, step.helper)
+        await fn(wrapped, i)
       } catch (err) {
         output.error(`eachElement: failed operation on element #${i} ${el}`)
         errs.push(err)
@@ -74,7 +77,8 @@ function expectElement(locator, fn) {
     const els = await step.helper._locate(locator)
     output.debug(`Found ${els.length} elements, first will be used for assertion`)
 
-    const result = await fn(els[0])
+    const wrapped = new WebElement(els[0], step.helper)
+    const result = await fn(wrapped)
     const assertion = truth(`element (${locator})`, fn.toString())
     assertion.assert(result)
   })
@@ -92,7 +96,8 @@ function expectAnyElement(locator, fn) {
 
     let found = false
     for (const el of els) {
-      const result = await fn(el)
+      const wrapped = new WebElement(el, step.helper)
+      const result = await fn(wrapped)
       if (result) {
         found = true
         break
@@ -113,7 +118,8 @@ function expectAllElements(locator, fn) {
     let i = 1
     for (const el of els) {
       output.debug(`checking element #${i}: ${el}`)
-      const result = await fn(el)
+      const wrapped = new WebElement(el, step.helper)
+      const result = await fn(wrapped)
       const assertion = truth(`element #${i} of (${locator})`, humanizeFunction(fn))
       assertion.assert(result)
       i++

package/lib/globals.js

@@ -8,27 +8,47 @@ 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
-  global.actor = global.codecept_actor = (obj) => {
-    return ActorFactory(obj, global.container || container)
-  }
-  global.Actor = global.actor
-
-  // Use dynamic imports for modules to avoid circular dependencies
+  // pause/inject/share stay global even under noGlobals — they're the everyday
+  // debugging/wiring entry points and have no useful import alternative for
+  // page-object code that runs before the container is available.
   global.pause = async (...args) => {
     const pauseModule = await import('./pause.js')
     return (pauseModule.default || pauseModule)(...args)
   }
+  global.inject = () => container.support()
+  global.share = container.share
+
+  if (config.noGlobals) return;
+
+  output.print(output.styles.debug('Global functions are deprecated. Use `import { Helper, 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, container)
+  }
+  global.Actor = global.actor
 
   global.within = async (...args) => {
     return (await import('./effects.js')).within(...args)
@@ -46,14 +66,9 @@ export async function initCodeceptGlobals(dir, config, container) {
     return locator.build(locatorQuery)
   }
 
-  global.inject = () => container.support()
-  global.share = container.share
-
   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 +80,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 +90,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 +120,8 @@ export function getGlobalNames() {
   return [
     'codecept_dir',
     'output_dir',
+    'Helper',
+    'codecept_helper',
     'actor',
     'codecept_actor',
     'Actor',
@@ -117,13 +133,11 @@ export function getGlobalNames() {
     'inject',
     'share',
     'secret',
-    'codecept_debug',
     'codeceptjs',
     'Given',
     'When',
     'Then',
     'DefineParameterType',
-    'debugMode',
     'maskSensitiveData',
     'BeforeAll',
     'AfterAll',
@@ -136,6 +150,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
@@ -48,12 +49,14 @@ class Heal {
   }
 
   hasCorrespondingRecipes(step) {
-    return matchRecipes(this.recipes, this.contextName).filter(r => !r.steps || r.steps.includes(step.name)).length > 0
+    return matchRecipes(this.recipes, this.contextName).filter(r => !r.steps || r.steps.includes(step.title)).length > 0
   }
 
   async getCodeSuggestions(context) {
     const suggestions = []
+    const stepName = context.step?.title
     const recipes = matchRecipes(this.recipes, this.contextName)
+      .filter(r => !r.steps || !stepName || r.steps.includes(stepName))
 
     debug('Recipes', recipes)
 
@@ -69,7 +72,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 +119,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

@@ -7,6 +7,7 @@ import promiseRetry from 'promise-retry'
 import Locator from '../locator.js'
 import recorder from '../recorder.js'
 import store from '../store.js'
+import { checkFocusBeforeType, checkFocusBeforePressKey } from './extras/focusCheck.js'
 import { includes as stringIncludes } from '../assert/include.js'
 import { urlEquals, equals } from '../assert/equal.js'
 import { empty } from '../assert/empty.js'
@@ -35,19 +36,16 @@ import MultipleElementsFound from './errors/MultipleElementsFound.js'
 import RemoteBrowserConnectionRefused from './errors/RemoteBrowserConnectionRefused.js'
 import Popup from './extras/Popup.js'
 import Console from './extras/Console.js'
-import { findReact, findVue, findByPlaywrightLocator } from './extras/PlaywrightReactVueLocator.js'
+import { findByPlaywrightLocator } from './extras/PlaywrightLocator.js'
 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()
@@ -448,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'
@@ -510,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 {
@@ -614,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
@@ -757,6 +755,11 @@ class Playwright extends Helper {
   }
 
   async _afterSuite() {
+    // Reset leftover test-level cleanup state (e.g. screenshot failures)
+    // so only errors from this suite teardown are evaluated below.
+    this.hasCleanupError = false
+    this.testFailures = []
+
     // Stop browser after suite completes
     // For restart strategies: stop after each suite
     // For session mode (restart:false): stop after the last suite
@@ -1636,7 +1639,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`)
@@ -2047,7 +2050,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')
       }
@@ -2078,15 +2081,6 @@ class Playwright extends Helper {
     return proceedClick.call(this, locator, context, options)
   }
 
-  /**
-   * Clicks link and waits for navigation (deprecated)
-   */
-  async clickLink(locator, context = null) {
-    console.log('clickLink deprecated: Playwright automatically waits for navigation to happen.')
-    console.log('Replace I.clickLink with I.click')
-    return this.click(locator, context)
-  }
-
   /**
    * {{> forceClick }}
    */
@@ -2231,6 +2225,7 @@ class Playwright extends Helper {
    * {{> pressKeyWithKeyNormalization }}
    */
   async pressKey(key) {
+    await checkFocusBeforePressKey(this, key)
     const modifiers = []
     if (Array.isArray(key)) {
       for (let k of key) {
@@ -2259,6 +2254,8 @@ class Playwright extends Helper {
    * {{> type }}
    */
   async type(keys, delay = null) {
+    await checkFocusBeforeType(this)
+
     // Always use page.keyboard.type for any string (including single character and national characters).
     if (!Array.isArray(keys)) {
       keys = keys.toString()
@@ -2283,11 +2280,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()
@@ -2343,7 +2344,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`)
@@ -2669,8 +2670,11 @@ class Playwright extends Helper {
    * @returns {Promise<any>}
    */
   async executeScript(fn, arg) {
-    if (this.context && this.context.constructor.name === 'FrameLocator') {
-      // switching to iframe context
+    if (arg && typeof arg.getNativeElement === 'function') arg = arg.getNativeElement()
+    if (arg && typeof arg.evaluate === 'function' && typeof arg.locator === 'function') {
+      return arg.evaluate(fn)
+    }
+    if (this.context && typeof this.context.url !== 'function' && typeof this.context.innerText !== 'function') {
       return this.context.locator(':root').evaluate(fn, arg)
     }
     return this.page.evaluate.apply(this.page, [fn, arg])
@@ -2700,15 +2704,12 @@ class Playwright extends Helper {
    *
    */
   async grabTextFrom(locator) {
-    // Handle role locators with text/exact options
-    if (isRoleLocatorObject(locator)) {
-      const elements = await handleRoleLocator(this.page, locator)
-      if (elements && elements.length > 0) {
-        const text = await elements[0].textContent()
-        assertElementExists(text, JSON.stringify(locator))
-        this.debugSection('Text', text)
-        return text
-      }
+    const roleElements = await handleRoleLocator(this.page, locator)
+    if (roleElements && roleElements.length > 0) {
+      const text = await roleElements[0].textContent()
+      assertElementExists(text, JSON.stringify(locator))
+      this.debugSection('Text', text)
+      return text
     }
 
     const locatorObj = new Locator(locator, 'css')
@@ -2936,7 +2937,7 @@ class Playwright extends Helper {
     const els = await this._locate(matchedLocator)
     assertElementExists(els, locator)
     const snapshot = await els[0].ariaSnapshot()
-    this.debugSection('Aria Snapshot', snapshot)
+    this.debugSection('Aria Snapshot', `${snapshot.split('\n').length} lines`)
     return snapshot
   }
 
@@ -3296,8 +3297,6 @@ class Playwright extends Helper {
   }
 
   /**
-   * This method accepts [React selectors](https://codecept.io/react).
-   *
    * {{> waitForVisible }}
    */
   async waitForVisible(locator, sec) {
@@ -3410,7 +3409,7 @@ class Playwright extends Helper {
   }
 
   async _getContext() {
-    if ((this.context && this.context.constructor.name === 'FrameLocator') || this.context) {
+    if (this.context) {
       return this.context
     }
     if (this.frame) {
@@ -4194,25 +4193,22 @@ export function buildLocatorString(locator) {
   return locator.simplify()
 }
 
-/**
- * Checks if a locator is a role locator object (e.g., {role: 'button', text: 'Submit', exact: true})
- */
-function isRoleLocatorObject(locator) {
-  return locator && typeof locator === 'object' && locator.role && !locator.type
-}
-
 /**
  * Handles role locator objects by converting them to Playwright's getByRole() API
+ * Accepts both raw objects ({role: 'button', text: 'Submit'}) and Locator-wrapped role objects.
  * Returns elements array if role locator, null otherwise
  */
 async function handleRoleLocator(context, locator) {
-  if (!isRoleLocatorObject(locator)) return null
+  const loc = new Locator(locator)
+  if (!loc.isRole()) return null
 
+  const roleObj = loc.locator || {}
   const options = {}
-  if (locator.text) options.name = locator.text
-  if (locator.exact !== undefined) options.exact = locator.exact
+  if (roleObj.text) options.name = roleObj.text
+  if (roleObj.name) options.name = roleObj.name
+  if (roleObj.exact !== undefined) options.exact = roleObj.exact
 
-  return context.getByRole(locator.role, Object.keys(options).length > 0 ? options : undefined).all()
+  return context.getByRole(roleObj.role, Object.keys(options).length > 0 ? options : undefined).all()
 }
 
 async function findByRole(context, locator) {
@@ -4224,13 +4220,8 @@ async function findByRole(context, locator) {
 }
 
 async function findElements(matcher, locator) {
-  // Check if locator is a Locator object with react/vue type, or a raw object with react/vue property
-  const isReactLocator = locator.type === 'react' || (locator.locator && locator.locator.react) || locator.react
-  const isVueLocator = locator.type === 'vue' || (locator.locator && locator.locator.vue) || locator.vue
   const isPwLocator = locator.type === 'pw' || (locator.locator && locator.locator.pw) || locator.pw
 
-  if (isReactLocator) return findReact(matcher, locator)
-  if (isVueLocator) return findVue(matcher, locator)
   if (isPwLocator) return findByPlaywrightLocator.call(this, matcher, locator)
 
   // Handle role locators with text/exact options (e.g., {role: 'button', text: 'Submit', exact: true})
@@ -4245,8 +4236,6 @@ async function findElements(matcher, locator) {
 }
 
 async function findElement(matcher, locator) {
-  if (locator.react) return findReact(matcher, locator)
-  if (locator.vue) return findVue(matcher, locator)
   if (locator.pw) return findByPlaywrightLocator.call(this, matcher, locator)
 
   locator = new Locator(locator, 'css')
@@ -4281,12 +4270,13 @@ async function proceedClick(locator, context = null, options = {}) {
     assertElementExists(els, locator, 'Clickable element')
   }
 
-  const elementIndex = store.currentStep?.opts?.elementIndex
+  const opts = store.currentStep?.opts
   let element
-  if (elementIndex != null) {
+  if (opts?.elementIndex != null) {
     element = selectElement(els, locator, this)
   } else {
-    if (this.options.strict) assertOnlyOneElement(els, locator, this)
+    const strict = (opts?.exact === false || opts?.strictMode === false) ? false : (this.options.strict || opts?.exact === true || opts?.strictMode === true)
+    if (strict) assertOnlyOneElement(els, locator, this)
     element = els.length > 1 ? (await getVisibleElements(els))[0] : els[0]
   }
 
@@ -4355,7 +4345,9 @@ async function proceedSee(assertType, text, context, strict = false) {
   if (!context) {
     const el = await this.context
 
-    allText = el.constructor.name !== 'Locator' ? [await el.locator('body').innerText()] : [await el.innerText()]
+    allText = typeof el.url !== 'function' && typeof el.innerText === 'function'
+      ? [await el.innerText()]
+      : [await el.locator('body').innerText()]
 
     description = 'web application'
   } else {
@@ -4425,12 +4417,9 @@ async function findFields(locator, context = null) {
     ? loc => findElements.call(this, contextEl, loc)
     : loc => this._locate(loc)
 
-  // Handle role locators with text/exact options
-  if (isRoleLocatorObject(locator)) {
-    const matcher = contextEl || (await this.page)
-    const roleElements = await handleRoleLocator(matcher, locator)
-    if (roleElements) return roleElements
-  }
+  const matcher = contextEl || (await this.page)
+  const roleElements = await handleRoleLocator(matcher, locator)
+  if (roleElements) return roleElements
 
   const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
@@ -4641,12 +4630,16 @@ async function targetCreatedHandler(page) {
       .catch(() => null)
       .then(async () => {
         if (this.context && this.context._type === 'Frame') {
-          // we are inside iframe?
+          // we are inside iframe via Frame object — refresh handle
           const frameEl = await this.context.frameElement()
           this.context = await frameEl.contentFrame()
           this.contextLocator = null
           return
         }
+        if (this.context && this.context.constructor && this.context.constructor.name === 'FrameLocator') {
+          // we are inside iframe via FrameLocator — keep it across load events
+          return
+        }
         // if context element was in iframe - keep it
         // if (await this.context.ownerFrame()) return;
         this.context = page
@@ -4827,7 +4820,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)
@@ -4844,7 +4837,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) {