codeceptjs 4.0.1-beta.2 → 4.0.1-beta.20

package/lib/helper/Playwright.js

@@ -30,7 +30,7 @@ import ElementNotFound from './errors/ElementNotFound.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 { findReact, findVue } from './extras/PlaywrightLocator.js'
 import WebElement from '../element/WebElement.js'
 
 let playwright
@@ -355,7 +355,7 @@ 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
@@ -367,7 +367,7 @@ class Playwright extends Helper {
         validCustomLocators = config.customLocatorStrategies
       }
     }
-    
+
     this.customLocatorStrategies = validCustomLocators
     this._customLocatorsRegistered = false
 
@@ -416,6 +416,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'
@@ -794,10 +795,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 +838,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 +949,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 +962,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
@@ -1390,7 +1379,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 +1388,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 +1398,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 +1524,7 @@ class Playwright extends Helper {
           acceptDownloads: true,
           ...this.options.emulate,
         }
-        
+
         try {
           this.browserContext = await this.browser.newContext(contextOptions)
         } catch (err) {
@@ -2504,7 +2489,19 @@ class Playwright extends Helper {
    * {{> selectOption }}
    */
   async selectOption(select, option) {
-    const els = await findFields.call(this, select)
+    const selectLocator = Locator.from(select, 'css')
+    let els = null
+
+    if (selectLocator.isFuzzy()) {
+      els = await findByRole(this.page, { role: 'listbox', name: selectLocator.value })
+      if (!els || els.length === 0) {
+        els = await findByRole(this.page, { role: 'combobox', name: selectLocator.value })
+      }
+    }
+
+    if (!els || els.length === 0) {
+      els = await findFields.call(this, select)
+    }
     assertElementExists(els, select, 'Selectable field')
     const el = els[0]
 
@@ -2805,17 +2802,6 @@ 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 locatorObj = new Locator(locator, 'css')
 
     if (locatorObj.isCustom()) {
@@ -2828,21 +2814,32 @@ class Playwright extends Helper {
       assertElementExists(text, locatorObj.toString())
       this.debugSection('Text', text)
       return text
-    } else {
-      locator = this._contextLocator(locator)
-      try {
-        const text = await this.page.textContent(locator)
-        assertElementExists(text, locator)
+    }
+
+    if (locatorObj.isRole()) {
+      // Handle role locators with text/exact options
+      const roleElements = await findByRole(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
-      } catch (error) {
-        // Convert Playwright timeout errors to ElementNotFound for consistency
-        if (error.message && error.message.includes('Timeout')) {
-          throw new ElementNotFound(locator, 'text')
-        }
-        throw error
       }
     }
+
+    locator = this._contextLocator(locator)
+    try {
+      const text = await this.page.textContent(locator)
+      assertElementExists(text, locator)
+      this.debugSection('Text', text)
+      return text
+    } catch (error) {
+      // Convert Playwright timeout errors to ElementNotFound for consistency
+      if (error.message && error.message.includes('Timeout')) {
+        throw new ElementNotFound(locator, 'text')
+      }
+      throw error
+    }
   }
 
   /**
@@ -3183,14 +3180,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
@@ -4321,50 +4318,26 @@ function buildLocatorString(locator) {
   if (locator.isXPath()) {
     return `xpath=${locator.value}`
   }
-  return locator.simplify()
+    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
- * Returns elements array if role locator, null otherwise
- */
-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()
+async function findByRole(context, locator) {
+  const matchedLocator = Locator.from(locator)
+  if (!matchedLocator.isRole()) return null
+  const roleOptions = matchedLocator.getRoleOptions()
+  return context.getByRole(roleOptions.role, roleOptions.options).all()
 }
 
 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})
-  const roleElements = await handleRoleLocator(matcher, locator)
+  const matchedLocator = Locator.from(locator)
+  const roleElements = await findByRole(matcher, matchedLocator)
   if (roleElements) return roleElements
 
-  locator = new Locator(locator, 'css')
+  const isReactLocator = matchedLocator.type === 'react'
+  const isVueLocator = matchedLocator.type === 'vue'
 
-  // Handle custom locators directly instead of relying on Playwright selector engines
-  if (locator.isCustom()) {
-    return findCustomElements.call(this, matcher, locator)
-  }
+  if (isReactLocator) return findReact(matcher, matchedLocator)
+  if (isVueLocator) return findVue(matcher, matchedLocator)
 
   // Check if we have a custom context locator and need to search within it
   if (this.contextLocator) {
@@ -4377,12 +4350,12 @@ async function findElements(matcher, locator) {
       }
 
       // Search within the first context element
-      const locatorString = buildLocatorString(locator)
+      const locatorString = buildLocatorString(matchedLocator)
       return contextElements[0].locator(locatorString).all()
     }
   }
 
-  const locatorString = buildLocatorString(locator)
+  const locatorString = buildLocatorString(matchedLocator)
 
   return matcher.locator(locatorString).all()
 }
@@ -4391,7 +4364,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)) {
@@ -4475,13 +4448,17 @@ async function findCustomElements(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)
+  const matchedLocator = Locator.from(locator)
+  const roleElements = await findByRole(matcher, matchedLocator)
+  if (roleElements && roleElements.length > 0) return roleElements[0]
+
+  const isReactLocator = matchedLocator.type === 'react'
+  const isVueLocator = matchedLocator.type === 'vue'
 
-  locator = new Locator(locator, 'css')
+  if (isReactLocator) return findReact(matcher, matchedLocator)
+  if (isVueLocator) return findVue(matcher, matchedLocator)
 
-  return matcher.locator(buildLocatorString(locator)).first()
+  return matcher.locator(buildLocatorString(matchedLocator)).first()
 }
 
 async function getVisibleElements(elements) {
@@ -4533,8 +4510,14 @@ async function proceedClick(locator, context = null, options = {}) {
 }
 
 async function findClickable(matcher, locator) {
+  // Convert to Locator first to handle JSON strings properly
   const matchedLocator = new Locator(locator)
 
+  // Handle role locators from Locator
+  if (matchedLocator.isRole()) {
+    return findByRole(matcher, matchedLocator)
+  }
+
   if (!matchedLocator.isFuzzy()) return findElements.call(this, matcher, matchedLocator)
 
   let els
@@ -4607,14 +4590,17 @@ async function findCheckable(locator, context) {
   }
 
   // Handle role locators with text/exact options
-  const roleElements = await handleRoleLocator(contextEl, locator)
+  const roleElements = await findByRole(contextEl, locator)
   if (roleElements) return roleElements
 
-  const matchedLocator = new Locator(locator)
+  const matchedLocator = Locator.from(locator)
   if (!matchedLocator.isFuzzy()) {
     return findElements.call(this, contextEl, matchedLocator)
   }
 
+  const checkboxByRole = await findByRole(contextEl, { role: 'checkbox', name: matchedLocator.value })
+  if (checkboxByRole) return checkboxByRole
+
   const literal = xpathLocator.literal(matchedLocator.value)
   let els = await findElements.call(this, contextEl, Locator.checkable.byText(literal))
   if (els.length) {
@@ -4636,17 +4622,15 @@ async function proceedIsChecked(assertType, option) {
 }
 
 async function findFields(locator) {
-  // Handle role locators with text/exact options
-  if (isRoleLocatorObject(locator)) {
-    const page = await this.page
-    const roleElements = await handleRoleLocator(page, locator)
-    if (roleElements) return roleElements
-  }
+  const page = await this.page
+  const roleElements = await findByRole(page, locator)
+  if (roleElements) return roleElements
 
   const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
     return this._locate(matchedLocator)
   }
+
   const literal = xpathLocator.literal(locator)
 
   let els = await this._locate({ xpath: Locator.field.labelEquals(literal) })
@@ -4967,7 +4951,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/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/helper/extras/PlaywrightLocator.js

@@ -11,22 +11,20 @@ function buildLocatorString(locator) {
 }
 
 async function findElements(matcher, locator) {
-  const matchedLocator = new Locator(locator, 'css')
+  const matchedLocator = Locator.from(locator, 'css')
 
   if (matchedLocator.type === 'react') return findReact(matcher, matchedLocator)
   if (matchedLocator.type === 'vue') return findVue(matcher, matchedLocator)
-  if (matchedLocator.type === 'pw') return findByPlaywrightLocator(matcher, matchedLocator)
   if (matchedLocator.isRole()) return findByRole(matcher, matchedLocator)
 
   return matcher.locator(buildLocatorString(matchedLocator)).all()
 }
 
 async function findElement(matcher, locator) {
-  const matchedLocator = new Locator(locator, 'css')
+  const matchedLocator = Locator.from(locator, 'css')
 
   if (matchedLocator.type === 'react') return findReact(matcher, matchedLocator)
   if (matchedLocator.type === 'vue') return findVue(matcher, matchedLocator)
-  if (matchedLocator.type === 'pw') return findByPlaywrightLocator(matcher, matchedLocator, { first: true })
   if (matchedLocator.isRole()) return findByRole(matcher, matchedLocator, { first: true })
 
   return matcher.locator(buildLocatorString(matchedLocator)).first()
@@ -46,49 +44,30 @@ async function getVisibleElements(elements) {
 }
 
 async function findReact(matcher, locator) {
-  const details = locator.locator ?? { react: locator.value }
-  let locatorString = `_react=${details.react}`
+  const props = locator.locator?.props
+  let locatorString = `_react=${locator.value}`
 
-  if (details.props) {
-    locatorString += propBuilder(details.props)
+  if (props) {
+    locatorString += propBuilder(props)
   }
 
   return matcher.locator(locatorString).all()
 }
 
 async function findVue(matcher, locator) {
-  const details = locator.locator ?? { vue: locator.value }
-  let locatorString = `_vue=${details.vue}`
+  const props = locator.locator?.props
+  let locatorString = `_vue=${locator.value}`
 
-  if (details.props) {
-    locatorString += propBuilder(details.props)
+  if (props) {
+    locatorString += propBuilder(props)
   }
 
   return matcher.locator(locatorString).all()
 }
 
-async function findByPlaywrightLocator(matcher, locator, { first = false } = {}) {
-  const details = locator.locator ?? { pw: locator.value }
-  const locatorValue = details.pw
-
-  const handle = matcher.locator(locatorValue)
-  return first ? handle.first() : handle.all()
-}
-
 async function findByRole(matcher, locator, { first = false } = {}) {
-  const details = locator.locator ?? { role: locator.value }
-  const { role, text, name, exact, includeHidden, ...rest } = details
-  const options = { ...rest }
-
-  if (includeHidden !== undefined) options.includeHidden = includeHidden
-
-  const accessibleName = name ?? text
-  if (accessibleName !== undefined) {
-    options.name = accessibleName
-    if (exact === true) options.exact = true
-  }
-
-  const roleLocator = matcher.getByRole(role, options)
+  const roleOptions = locator.getRoleOptions()
+  const roleLocator = matcher.getByRole(roleOptions.role, roleOptions.options)
   return first ? roleLocator.first() : roleLocator.all()
 }
 
@@ -107,4 +86,4 @@ function propBuilder(props) {
   return _props
 }
 
-export { buildLocatorString, findElements, findElement, getVisibleElements, findReact, findVue, findByPlaywrightLocator, findByRole }
+export { buildLocatorString, findElements, findElement, getVisibleElements, findReact, findVue, findByRole }

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]