codeceptjs 4.0.1-beta.3 → 4.0.1-beta.31

package/lib/helper/Playwright.js

@@ -44,6 +44,36 @@ if (typeof global.__playwrightSelectorsRegistered === 'undefined') {
   global.__playwrightSelectorsRegistered = false
 }
 
+/**
+ * Creates a Playwright selector engine factory for a custom locator strategy.
+ * @param {string} name - Strategy name for error messages
+ * @param {Function} func - The locator function (selector, root) => Element|Element[]
+ * @returns {Function} Selector engine factory
+ */
+function createCustomSelectorEngine(name, func) {
+  return () => ({
+    create: () => null,
+    query(root, selector) {
+      if (!root) return null
+      try {
+        const result = func(selector, root)
+        return Array.isArray(result) ? result[0] : result
+      } catch (e) {
+        return null
+      }
+    },
+    queryAll(root, selector) {
+      if (!root) return []
+      try {
+        const result = func(selector, root)
+        return Array.isArray(result) ? result : result ? [result] : []
+      } catch (e) {
+        return []
+      }
+    },
+  })
+}
+
 const popupStore = new Popup()
 const consoleLogStore = new Console()
 const availableBrowsers = ['chromium', 'webkit', 'firefox', 'electron']
@@ -355,26 +385,16 @@ class Playwright extends Helper {
     this.recordingWebSocketMessages = false
     this.recordedWebSocketMessagesAtLeastOnce = false
     this.cdpSession = null
-    
+
     // Filter out invalid customLocatorStrategies (empty arrays, objects without functions)
     // This can happen in worker threads where config is serialized/deserialized
-    let validCustomLocators = null
-    if (typeof config.customLocatorStrategies === 'object' && config.customLocatorStrategies !== null) {
-      // Check if it's an empty array or object with no function properties
-      const entries = Object.entries(config.customLocatorStrategies)
-      const hasFunctions = entries.some(([_, value]) => typeof value === 'function')
-      if (hasFunctions) {
-        validCustomLocators = config.customLocatorStrategies
-      }
-    }
-    
-    this.customLocatorStrategies = validCustomLocators
+    this.customLocatorStrategies = this._parseCustomLocatorStrategies(config.customLocatorStrategies)
     this._customLocatorsRegistered = false
 
     // Add custom locator strategies to global registry for early registration
     if (this.customLocatorStrategies) {
-      for (const [strategyName, strategyFunction] of Object.entries(this.customLocatorStrategies)) {
-        globalCustomLocatorStrategies.set(strategyName, strategyFunction)
+      for (const [name, func] of Object.entries(this.customLocatorStrategies)) {
+        globalCustomLocatorStrategies.set(name, func)
       }
     }
 
@@ -416,6 +436,7 @@ class Playwright extends Helper {
       ignoreHTTPSErrors: false, // Adding it here o that context can be set up to ignore the SSL errors,
       highlightElement: false,
       storageState: undefined,
+      onResponse: null,
     }
 
     process.env.testIdAttribute = 'data-testid'
@@ -564,54 +585,23 @@ class Playwright extends Helper {
       }
 
       // Register all custom locator strategies from the global registry
-      for (const [strategyName, strategyFunction] of globalCustomLocatorStrategies.entries()) {
-        if (!registeredCustomLocatorStrategies.has(strategyName)) {
-          try {
-            // Create a selector engine factory function exactly like createValueEngine pattern
-            // Capture variables in closure to avoid reference issues
-            const createCustomEngine = ((name, func) => {
-              return () => {
-                return {
-                  create() {
-                    return null
-                  },
-                  query(root, selector) {
-                    try {
-                      if (!root) return null
-                      const result = func(selector, root)
-                      return Array.isArray(result) ? result[0] : result
-                    } catch (error) {
-                      console.warn(`Error in custom locator "${name}":`, error)
-                      return null
-                    }
-                  },
-                  queryAll(root, selector) {
-                    try {
-                      if (!root) return []
-                      const result = func(selector, root)
-                      return Array.isArray(result) ? result : result ? [result] : []
-                    } catch (error) {
-                      console.warn(`Error in custom locator "${name}":`, error)
-                      return []
-                    }
-                  },
-                }
-              }
-            })(strategyName, strategyFunction)
+      await this._registerGlobalCustomLocators()
+    } catch (e) {
+      console.warn(e)
+    }
+  }
 
-            await playwright.selectors.register(strategyName, createCustomEngine)
-            registeredCustomLocatorStrategies.add(strategyName)
-          } catch (error) {
-            if (!error.message.includes('already registered')) {
-              console.warn(`Failed to register custom locator strategy '${strategyName}':`, error)
-            } else {
-              console.log(`Custom locator strategy '${strategyName}' already registered`)
-            }
-          }
+  async _registerGlobalCustomLocators() {
+    for (const [name, func] of globalCustomLocatorStrategies.entries()) {
+      if (registeredCustomLocatorStrategies.has(name)) continue
+      try {
+        await playwright.selectors.register(name, createCustomSelectorEngine(name, func))
+        registeredCustomLocatorStrategies.add(name)
+      } catch (e) {
+        if (!e.message.includes('already registered')) {
+          this.debugSection('Custom Locator', `Failed to register '${name}': ${e.message}`)
         }
       }
-    } catch (e) {
-      console.warn(e)
     }
   }
 
@@ -794,10 +784,7 @@ class Playwright extends Helper {
             await Promise.allSettled(pages.map(p => p.close().catch(() => {})))
           }
           // Use timeout to prevent hanging (10s should be enough for browser cleanup)
-          await Promise.race([
-            this._stopBrowser(),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout')), 10000)),
-          ])
+          await Promise.race([this._stopBrowser(), new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout')), 10000))])
         } catch (e) {
           console.warn('Warning during browser restart in _after:', e.message)
           // Force cleanup even on timeout
@@ -840,10 +827,7 @@ class Playwright extends Helper {
     if (this.isRunning) {
       try {
         // Add timeout protection to prevent hanging
-        await Promise.race([
-          this._stopBrowser(),
-          new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in afterSuite')), 10000)),
-        ])
+        await Promise.race([this._stopBrowser(), new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in afterSuite')), 10000))])
       } catch (e) {
         console.warn('Warning during suite cleanup:', e.message)
         // Track suite cleanup failures
@@ -954,10 +938,7 @@ class Playwright extends Helper {
     if (this.isRunning) {
       try {
         // Add timeout protection to prevent hanging
-        await Promise.race([
-          this._stopBrowser(),
-          new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in cleanup')), 10000)),
-        ])
+        await Promise.race([this._stopBrowser(), new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in cleanup')), 10000))])
       } catch (e) {
         console.warn('Warning during final cleanup:', e.message)
         // Force cleanup on timeout
@@ -970,10 +951,7 @@ class Playwright extends Helper {
       if (this.browser) {
         try {
           // Add timeout protection to prevent hanging
-          await Promise.race([
-            this._stopBrowser(),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in forced cleanup')), 10000)),
-          ])
+          await Promise.race([this._stopBrowser(), new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in forced cleanup')), 10000))])
         } catch (e) {
           console.warn('Warning during forced cleanup:', e.message)
           // Force cleanup on timeout
@@ -1288,28 +1266,31 @@ class Playwright extends Helper {
     return this.browser
   }
 
+  _hasCustomLocatorStrategies() {
+    return !!(this.customLocatorStrategies && Object.keys(this.customLocatorStrategies).length > 0)
+  }
+
+  _parseCustomLocatorStrategies(strategies) {
+    if (typeof strategies !== 'object' || strategies === null) return null
+    const hasValidFunctions = Object.values(strategies).some(v => typeof v === 'function')
+    return hasValidFunctions ? strategies : null
+  }
+
   _lookupCustomLocator(customStrategy) {
-    if (typeof this.customLocatorStrategies !== 'object' || this.customLocatorStrategies === null) {
-      return null
-    }
+    if (!this._hasCustomLocatorStrategies()) return null
     const strategy = this.customLocatorStrategies[customStrategy]
     return typeof strategy === 'function' ? strategy : null
   }
 
   _isCustomLocator(locator) {
     const locatorObj = new Locator(locator)
-    if (locatorObj.isCustom()) {
-      const customLocator = this._lookupCustomLocator(locatorObj.type)
-      if (customLocator) {
-        return true
-      }
-      throw new Error('Please define "customLocatorStrategies" as an Object and the Locator Strategy as a "function".')
-    }
-    return false
+    if (!locatorObj.isCustom()) return false
+    if (this._lookupCustomLocator(locatorObj.type)) return true
+    throw new Error('Please define "customLocatorStrategies" as an Object and the Locator Strategy as a "function".')
   }
 
   _isCustomLocatorStrategyDefined() {
-    return !!(this.customLocatorStrategies && Object.keys(this.customLocatorStrategies).length > 0)
+    return this._hasCustomLocatorStrategies()
   }
 
   /**
@@ -1332,49 +1313,16 @@ class Playwright extends Helper {
   }
 
   async _registerCustomLocatorStrategies() {
-    if (!this.customLocatorStrategies) return
-
-    for (const [strategyName, strategyFunction] of Object.entries(this.customLocatorStrategies)) {
-      if (!registeredCustomLocatorStrategies.has(strategyName)) {
-        try {
-          const createCustomEngine = ((name, func) => {
-            return () => {
-              return {
-                create(root, target) {
-                  return null
-                },
-                query(root, selector) {
-                  try {
-                    if (!root) return null
-                    const result = func(selector, root)
-                    return Array.isArray(result) ? result[0] : result
-                  } catch (error) {
-                    console.warn(`Error in custom locator "${name}":`, error)
-                    return null
-                  }
-                },
-                queryAll(root, selector) {
-                  try {
-                    if (!root) return []
-                    const result = func(selector, root)
-                    return Array.isArray(result) ? result : result ? [result] : []
-                  } catch (error) {
-                    console.warn(`Error in custom locator "${name}":`, error)
-                    return []
-                  }
-                },
-              }
-            }
-          })(strategyName, strategyFunction)
+    if (!this._hasCustomLocatorStrategies()) return
 
-          await playwright.selectors.register(strategyName, createCustomEngine)
-          registeredCustomLocatorStrategies.add(strategyName)
-        } catch (error) {
-          if (!error.message.includes('already registered')) {
-            console.warn(`Failed to register custom locator strategy '${strategyName}':`, error)
-          } else {
-            console.log(`Custom locator strategy '${strategyName}' already registered`)
-          }
+    for (const [name, func] of Object.entries(this.customLocatorStrategies)) {
+      if (registeredCustomLocatorStrategies.has(name)) continue
+      try {
+        await playwright.selectors.register(name, createCustomSelectorEngine(name, func))
+        registeredCustomLocatorStrategies.add(name)
+      } catch (e) {
+        if (!e.message.includes('already registered')) {
+          this.debugSection('Custom Locator', `Failed to register '${name}': ${e.message}`)
         }
       }
     }
@@ -1390,7 +1338,7 @@ class Playwright extends Helper {
     this.context = null
     this.frame = null
     popupStore.clear()
-    
+
     // Remove all event listeners to prevent hanging
     if (this.browser) {
       try {
@@ -1399,7 +1347,8 @@ class Playwright extends Helper {
         // Ignore errors if browser is already closed
       }
     }
-    
+
+    // Close browserContext if recordHar is enabled
     if (this.options.recordHar && this.browserContext) {
       try {
         await this.browserContext.close()
@@ -1408,22 +1357,17 @@ class Playwright extends Helper {
       }
     }
     this.browserContext = null
-    
+
+    // Initiate browser close without waiting for it to complete
+    // The browser process will be cleaned up when the Node process exits
     if (this.browser) {
       try {
-        // Add timeout to prevent browser.close() from hanging indefinitely
-        await Promise.race([
-          this.browser.close(),
-          new Promise((_, reject) => 
-            setTimeout(() => reject(new Error('Browser close timeout')), 5000)
-          )
-        ])
+        // Fire and forget - don't wait for close to complete
+        this.browser.close().catch(() => {
+          // Silently ignore any errors during async close
+        })
       } catch (e) {
-        // Ignore errors if browser is already closed or timeout
-        if (!e.message?.includes('Browser close timeout')) {
-          // Non-timeout error, can be ignored as well
-        }
-        // Force cleanup even on error
+        // Ignore any synchronous errors
       }
     }
     this.browser = null
@@ -1539,7 +1483,7 @@ class Playwright extends Helper {
           acceptDownloads: true,
           ...this.options.emulate,
         }
-        
+
         try {
           this.browserContext = await this.browser.newContext(contextOptions)
         } catch (err) {
@@ -3183,14 +3127,14 @@ class Playwright extends Helper {
     this.debugSection('Response', await response.text())
 
     // hook to allow JSON response handle this
-    if (this.config.onResponse) {
+    if (this.options.onResponse) {
       const axiosResponse = {
         data: await response.json(),
         status: response.status(),
         statusText: response.statusText(),
         headers: response.headers(),
       }
-      this.config.onResponse(axiosResponse)
+      this.options.onResponse(axiosResponse)
     }
 
     return response
@@ -4337,11 +4281,11 @@ function isRoleLocatorObject(locator) {
  */
 async function handleRoleLocator(context, locator) {
   if (!isRoleLocatorObject(locator)) return null
-  
+
   const options = {}
   if (locator.text) options.name = locator.text
   if (locator.exact !== undefined) options.exact = locator.exact
-  
+
   return context.getByRole(locator.role, Object.keys(options).length > 0 ? options : undefined).all()
 }
 
@@ -4350,7 +4294,7 @@ async function findElements(matcher, locator) {
   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)
@@ -4391,7 +4335,7 @@ async function findCustomElements(matcher, locator) {
   // Always prioritize this.customLocatorStrategies which is set in constructor from config
   // and persists in every worker thread instance
   let strategyFunction = null
-  
+
   if (this.customLocatorStrategies && this.customLocatorStrategies[locator.type]) {
     strategyFunction = this.customLocatorStrategies[locator.type]
   } else if (globalCustomLocatorStrategies.has(locator.type)) {
@@ -4967,7 +4911,7 @@ async function refreshContextSession() {
       this.debugSection('Session', 'Skipping storage cleanup - no active page/context')
       return
     }
-    
+
     const currentUrl = await this.grabCurrentUrl()
 
     if (currentUrl.startsWith('http')) {

package/lib/helper/Puppeteer.js

@@ -2955,7 +2955,7 @@ async function findElements(matcher, locator) {
 async function findElement(matcher, locator) {
   if (locator.react) return findReactElements.call(this, locator)
   locator = new Locator(locator, 'css')
-  
+
   // Check if locator is a role locator and call findByRole
   if (locator.isRole()) {
     const elements = await findByRole.call(this, matcher, locator)
@@ -2967,10 +2967,13 @@ async function findElement(matcher, locator) {
     const elements = await matcher.$$(locator.simplify())
     return elements[0]
   }
-  
-  // For XPath in Puppeteer 24.x+, use the same approach as findElements
-  // $x method was removed, so we use ::-p-xpath() or fallback
-  const elements = await findElements.call(this, matcher, locator)
+  // puppeteer version < 19.4.0 is no longer supported. This one is backward support.
+  if (puppeteer.default?.defaultBrowserRevision) {
+    const elements = await matcher.$$(`xpath/${locator.value}`)
+    return elements[0]
+  }
+  // For Puppeteer 24.x+, $x method was removed - use ::-p-xpath() selector
+  const elements = await matcher.$$(`::-p-xpath(${locator.value})`)
   return elements[0]
 }
 

package/lib/helper/REST.js

@@ -94,7 +94,9 @@ const config = {}
 class REST extends Helper {
   constructor(config) {
     super(config)
-    this.options = {
+
+    // Set defaults first
+    const defaults = {
       timeout: 10000,
       defaultHeaders: {},
       endpoint: '',
@@ -103,15 +105,16 @@ class REST extends Helper {
       onResponse: null,
     }
 
+    // Merge config with defaults
+    this._setConfig(config)
+    this.options = { ...defaults, ...this.options }
+
     if (this.options.maxContentLength) {
       const maxContentLength = this.options.maxUploadFileSize * 1024 * 1024
       this.options.maxContentLength = maxContentLength
       this.options.maxBodyLength = maxContentLength
     }
 
-    // override defaults with config
-    this._setConfig(config)
-
     this.headers = { ...this.options.defaultHeaders }
 
     // Create an agent with SSL certificate
@@ -215,8 +218,9 @@ class REST extends Helper {
       }
     }
 
-    if (this.config.onRequest) {
-      await this.config.onRequest(request)
+    const onRequest = this.options.onRequest || this.config.onRequest
+    if (onRequest) {
+      await onRequest(request)
     }
 
     try {
@@ -245,8 +249,9 @@ class REST extends Helper {
       }
       response = err.response
     }
-    if (this.config.onResponse) {
-      await this.config.onResponse(response)
+    const onResponse = this.options.onResponse || this.config.onResponse
+    if (onResponse) {
+      await onResponse(response)
     }
     try {
       this.options.prettyPrintJson ? this.debugSection('Response', beautify(JSON.stringify(response.data))) : this.debugSection('Response', JSON.stringify(response.data))

package/lib/listener/config.js

@@ -12,15 +12,23 @@ export default function () {
     return
   }
   global.__codeceptConfigListenerInitialized = true
-  
-  const helpers = global.container.helpers()
 
   enableDynamicConfigFor('suite')
   enableDynamicConfigFor('test')
 
   function enableDynamicConfigFor(type) {
     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()
+
       function updateHelperConfig(helper, config) {
+        // Guard against undefined or invalid helpers
+        if (!helper || !helper.constructor) {
+          output.debug(`[${ucfirst(type)} Config] Helper not found or not properly initialized`)
+          return
+        }
+
         const oldConfig = deepClone(helper.options)
         try {
           helper._setConfig(deepMerge(deepClone(oldConfig), config))
@@ -41,7 +49,7 @@ export default function () {
         for (let name in context.config) {
           const config = context.config[name]
           if (name === '0') {
-            // first helper
+            // first helper - get dynamically
             name = Object.keys(helpers)[0]
           }
           const helper = helpers[name]

package/lib/mocha/factory.js

@@ -62,34 +62,9 @@ class MochaFactory {
         const jsFiles = this.files.filter(file => !file.match(/\.feature$/))
         this.files = this.files.filter(file => !file.match(/\.feature$/))
 
-        // Load JavaScript test files using ESM imports
+        // Load JavaScript test files using original loadFiles
         if (jsFiles.length > 0) {
-          try {
-            // Try original loadFiles first for compatibility
-            originalLoadFiles.call(this, fn)
-          } catch (e) {
-            // If original loadFiles fails, load ESM files manually
-            if (e.message.includes('not in cache') || e.message.includes('ESM') || e.message.includes('getStatus')) {
-              // Load ESM files by importing them synchronously using top-level await workaround
-              for (const file of jsFiles) {
-                try {
-                  // Convert file path to file:// URL for dynamic import
-                  const fileUrl = `file://${file}`
-                  // Use import() but don't await it - let it load in the background
-                  import(fileUrl).catch(importErr => {
-                    // If dynamic import fails, the file may have syntax errors or other issues
-                    console.error(`Failed to load test file ${file}:`, importErr.message)
-                  })
-                  if (fn) fn()
-                } catch (fileErr) {
-                  console.error(`Error processing test file ${file}:`, fileErr.message)
-                  if (fn) fn(fileErr)
-                }
-              }
-            } else {
-              throw e
-            }
-          }
+          originalLoadFiles.call(this, fn)
         }
 
         // add ids for each test and check uniqueness

package/lib/mocha/test.js

@@ -154,14 +154,16 @@ function cloneTest(test) {
 function testToFileName(test, { suffix = '', unique = false } = {}) {
   let fileName = test.title
 
-  if (unique) fileName = `${fileName}_${test?.uid || Math.floor(new Date().getTime() / 1000)}`
-  if (suffix) fileName = `${fileName}_${suffix}`
   // remove tags with empty string (disable for now)
   // fileName = fileName.replace(/\@\w+/g, '')
   fileName = fileName.slice(0, 100)
   if (fileName.indexOf('{') !== -1) {
     fileName = fileName.substr(0, fileName.indexOf('{') - 3).trim()
   }
+
+  // Apply unique suffix AFTER removing data part to ensure uniqueness
+  if (unique) fileName = `${fileName}_${test?.uid || Math.floor(new Date().getTime())}`
+  if (suffix) fileName = `${fileName}_${suffix}`
   if (test.ctx && test.ctx.test && test.ctx.test.type === 'hook') fileName = clearString(`${test.title}_${test.ctx.test.title}`)
   // TODO: add suite title to file name
   // if (test.parent && test.parent.title) {

package/lib/output.js

@@ -222,12 +222,10 @@ const output = {
     /**
      * @param {Mocha.Test} test
      */
-
     started(test) {
       if (outputLevel < 1) return
       print(`  ${colors.dim.bold('Scenario()')}`)
     },
-
     /**
      * @param {Mocha.Test} test
      */
@@ -273,10 +271,12 @@ const output = {
   },
 
   /**
+   * Prints the stats of a test run to the console.
    * @param {number} passed
    * @param {number} failed
    * @param {number} skipped
    * @param {number|string} duration
+   * @param {number} [failedHooks]
    */
   result(passed, failed, skipped, duration, failedHooks = 0) {
     let style = colors.bgGreen

package/lib/step/base.js

@@ -147,9 +147,22 @@ class Step {
   line() {
     const lines = this.stack.split('\n')
     if (lines[STACK_LINE]) {
-      return lines[STACK_LINE].trim()
+      let line = lines[STACK_LINE].trim()
         .replace(global.codecept_dir || '', '.')
         .trim()
+
+      // Map .temp.mjs back to original .ts files using container's tsFileMapping
+      const fileMapping = global.container?.tsFileMapping?.()
+      if (line.includes('.temp.mjs') && fileMapping) {
+        for (const [tsFile, mjsFile] of fileMapping.entries()) {
+          if (line.includes(mjsFile)) {
+            line = line.replace(mjsFile, tsFile)
+            break
+          }
+        }
+      }
+
+      return line
     }
     return ''
   }