codeceptjs 4.0.0-beta.9.esm-aria → 4.0.0-rc.10

package/typings/index.d.ts

@@ -519,12 +519,12 @@ declare namespace CodeceptJS {
     retry(retries?: number): HookConfig
   }
 
-  function addStep(step: string, fn: Function): Promise<void>
+  function addStep(step: string | RegExp, fn: Function): Promise<void>
 }
 
-type TryTo = <T>(fn: () => Promise<T> | T) => Promise<T | false>
-type HopeThat = <T>(fn: () => Promise<T> | T) => Promise<T | false>
-type RetryTo = <T>(fn: () => Promise<T> | T, retries?: number) => Promise<T>
+type TryTo = (fn: () => void) => Promise<boolean>
+type HopeThat = (fn: () => void) => Promise<boolean>
+type RetryTo = (fn: (tries: number) => Promise<void> | void, maxTries: number, pollInterval?: number) => Promise<boolean>
 
 // Globals
 declare const codecept_dir: string
@@ -635,8 +635,105 @@ declare namespace Mocha {
   }
 }
 
+// Internal API types
 declare module 'codeceptjs' {
   export default codeceptjs
+
+  /**
+   * Dependency Injection Container
+   * Provides access to helpers, support objects, plugins, and translation
+   */
+  export const container: typeof CodeceptJS.Container
+
+  /**
+   * Test runner class
+   */
+  export const codecept: typeof CodeceptJS.Codecept
+
+  /**
+   * Output module for printing messages
+   */
+  export const output: typeof CodeceptJS.output
+
+  /**
+   * Event dispatcher for listening to CodeceptJS events
+   */
+  export const event: typeof CodeceptJS.event
+
+  /**
+   * Global promise chain recorder
+   */
+  export const recorder: CodeceptJS.recorder
+
+  /**
+   * Configuration module
+   */
+  export const config: typeof CodeceptJS.Config
+
+  /**
+   * Actor (I) constructor
+   */
+  export const actor: CodeceptJS.actor
+
+  /**
+   * Base Helper class
+   */
+  export const helper: typeof CodeceptJS.Helper
+
+  /**
+   * Pause execution until user input
+   */
+  export const pause: typeof CodeceptJS.pause
+
+  /**
+   * Execute steps within specific context
+   */
+  export const within: typeof CodeceptJS.within
+
+  /**
+   * Create data tables for data-driven tests
+   */
+  export const dataTable: typeof CodeceptJS.DataTable
+
+  /**
+   * Create data table arguments
+   */
+  export const dataTableArgument: typeof CodeceptJS.DataTableArgument
+
+  /**
+   * Shared store for test data
+   */
+  export const store: typeof CodeceptJS.store
+
+  /**
+   * Locator builder
+   */
+  export const locator: typeof CodeceptJS.Locator
+
+  /**
+   * Auto-healing module
+   */
+  export const heal: any
+
+  /**
+   * AI assistant module
+   */
+  export const ai: any
+
+  /**
+   * Workers for parallel execution
+   */
+  export const Workers: any
+
+  /**
+   * Secret value type for sensitive data
+   */
+  export const Secret: typeof CodeceptJS.Secret
+
+  /**
+   * Create a secret value
+   */
+  export const secret: typeof CodeceptJS.Secret.secret
 }
 
 declare module '@codeceptjs/helper' {
@@ -648,3 +745,22 @@ declare module 'codeceptjs/effects' {
   export const retryTo: RetryTo
   export const hopeThat: HopeThat
 }
+
+declare module 'codeceptjs/steps' {
+  const step: {
+    opts(opts: CodeceptJS.StepOptions): CodeceptJS.StepConfig;
+    timeout(timeout: number): CodeceptJS.StepConfig;
+    retry(retry: number): CodeceptJS.StepConfig;
+    stepOpts(opts: CodeceptJS.StepOptions): CodeceptJS.StepConfig;
+    stepTimeout(timeout: number): CodeceptJS.StepConfig;
+    stepRetry(retry: number): CodeceptJS.StepConfig;
+    section(name: string): any;
+    endSection(): any;
+    Section(name: string): any;
+    EndSection(): any;
+    Given(): any;
+    When(): any;
+    Then(): any;
+  }
+  export default step
+}

package/lib/helper/extras/PlaywrightLocator.js

@@ -1,110 +0,0 @@
-import Locator from '../../locator.js'
-
-function buildLocatorString(locator) {
-  if (locator.isCustom()) {
-    return `${locator.type}=${locator.value}`
-  }
-  if (locator.isXPath()) {
-    return `xpath=${locator.value}`
-  }
-  return locator.simplify()
-}
-
-async function findElements(matcher, locator) {
-  const matchedLocator = new Locator(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')
-
-  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()
-}
-
-async function getVisibleElements(elements) {
-  const visibleElements = []
-  for (const element of elements) {
-    if (await element.isVisible()) {
-      visibleElements.push(element)
-    }
-  }
-  if (visibleElements.length === 0) {
-    return elements
-  }
-  return visibleElements
-}
-
-async function findReact(matcher, locator) {
-  const details = locator.locator ?? { react: locator.value }
-  let locatorString = `_react=${details.react}`
-
-  if (details.props) {
-    locatorString += propBuilder(details.props)
-  }
-
-  return matcher.locator(locatorString).all()
-}
-
-async function findVue(matcher, locator) {
-  const details = locator.locator ?? { vue: locator.value }
-  let locatorString = `_vue=${details.vue}`
-
-  if (details.props) {
-    locatorString += propBuilder(details.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)
-  return first ? roleLocator.first() : roleLocator.all()
-}
-
-function propBuilder(props) {
-  let _props = ''
-
-  for (const [key, value] of Object.entries(props)) {
-    if (typeof value === 'object') {
-      for (const [k, v] of Object.entries(value)) {
-        _props += `[${key}.${k} = "${v}"]`
-      }
-    } else {
-      _props += `[${key} = "${value}"]`
-    }
-  }
-  return _props
-}
-
-export { buildLocatorString, findElements, findElement, getVisibleElements, findReact, findVue, findByPlaywrightLocator, findByRole }

package/lib/listener/enhancedGlobalRetry.js

@@ -1,110 +0,0 @@
-import event from '../event.js'
-import output from '../output.js'
-import Config from '../config.js'
-import { isNotSet } from '../utils.js'
-
-const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
-
-/**
- * Priority levels for retry mechanisms (higher number = higher priority)
- * This ensures consistent behavior when multiple retry mechanisms are active
- */
-const RETRY_PRIORITIES = {
-  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
-  STEP_PLUGIN: 50, // retryFailedStep plugin
-  SCENARIO_CONFIG: 30, // Global scenario retry config
-  FEATURE_CONFIG: 20, // Global feature retry config
-  HOOK_CONFIG: 10, // Hook retry config - lowest priority
-}
-
-/**
- * Enhanced global retry mechanism that coordinates with other retry types
- */
-export default function () {
-  event.dispatcher.on(event.suite.before, suite => {
-    let retryConfig = Config.get('retry')
-    if (!retryConfig) return
-
-    if (Number.isInteger(+retryConfig)) {
-      // is number - apply as feature-level retry
-      const retryNum = +retryConfig
-      output.log(`[Global Retry] Feature retries: ${retryNum}`)
-
-      // Only set if not already set by higher priority mechanism
-      if (isNotSet(suite.retries())) {
-        suite.retries(retryNum)
-        suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
-      }
-      return
-    }
-
-    if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig]
-    }
-
-    for (const config of retryConfig) {
-      if (config.grep) {
-        if (!suite.title.includes(config.grep)) continue
-      }
-
-      // Handle hook retries with priority awareness
-      hooks
-        .filter(hook => !!config[hook])
-        .forEach(hook => {
-          const retryKey = `retry${hook}`
-          if (isNotSet(suite.opts[retryKey])) {
-            suite.opts[retryKey] = config[hook]
-            suite.opts[`${retryKey}Priority`] = RETRY_PRIORITIES.HOOK_CONFIG
-          }
-        })
-
-      // Handle feature-level retries
-      if (config.Feature) {
-        if (isNotSet(suite.retries()) || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
-          suite.retries(config.Feature)
-          suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
-          output.log(`[Global Retry] Feature retries: ${config.Feature}`)
-        }
-      }
-    }
-  })
-
-  event.dispatcher.on(event.test.before, test => {
-    let retryConfig = Config.get('retry')
-    if (!retryConfig) return
-
-    if (Number.isInteger(+retryConfig)) {
-      // Only set if not already set by higher priority mechanism
-      if (test.retries() === -1) {
-        test.retries(retryConfig)
-        test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
-        output.log(`[Global Retry] Scenario retries: ${retryConfig}`)
-      }
-      return
-    }
-
-    if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig]
-    }
-
-    retryConfig = retryConfig.filter(config => !!config.Scenario)
-
-    for (const config of retryConfig) {
-      if (config.grep) {
-        if (!test.fullTitle().includes(config.grep)) continue
-      }
-
-      if (config.Scenario) {
-        // Respect priority system
-        if (test.retries() === -1 || (test.opts.retryPriority || 0) <= RETRY_PRIORITIES.SCENARIO_CONFIG) {
-          test.retries(config.Scenario)
-          test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
-          output.log(`[Global Retry] Scenario retries: ${config.Scenario}`)
-        }
-      }
-    }
-  })
-}
-
-// Export priority constants for use by other retry mechanisms
-export { RETRY_PRIORITIES }

package/lib/plugin/enhancedRetryFailedStep.js

@@ -1,99 +0,0 @@
-import event from '../event.js'
-import recorder from '../recorder.js'
-import store from '../store.js'
-import output from '../output.js'
-import { RETRY_PRIORITIES } from '../retryCoordinator.js'
-
-const defaultConfig = {
-  retries: 3,
-  defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
-  factor: 1.5,
-  ignoredSteps: [],
-}
-
-/**
- * Enhanced retryFailedStep plugin that coordinates with other retry mechanisms
- *
- * This plugin provides step-level retries and coordinates with global retry settings
- * to avoid conflicts and provide predictable behavior.
- */
-export default config => {
-  config = Object.assign({}, defaultConfig, config)
-  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
-  const customWhen = config.when
-
-  let enableRetry = false
-
-  const when = err => {
-    if (!enableRetry) return false
-    if (store.debugMode) return false
-    if (!store.autoRetries) return false
-    if (customWhen) return customWhen(err)
-    return true
-  }
-  config.when = when
-
-  event.dispatcher.on(event.step.started, step => {
-    // if a step is ignored - return
-    for (const ignored of config.ignoredSteps) {
-      if (step.name === ignored) return
-      if (ignored instanceof RegExp) {
-        if (step.name.match(ignored)) return
-      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return
-    }
-    enableRetry = true // enable retry for a step
-  })
-
-  event.dispatcher.on(event.step.finished, () => {
-    enableRetry = false
-  })
-
-  event.dispatcher.on(event.test.before, test => {
-    // pass disableRetryFailedStep is a preferred way to disable retries
-    // test.disableRetryFailedStep is used for backward compatibility
-    if (test.opts.disableRetryFailedStep || test.disableRetryFailedStep) {
-      store.autoRetries = false
-      output.log(`[Step Retry] Disabled for test: ${test.title}`)
-      return // disable retry when a test is not active
-    }
-
-    // Check if step retries should be disabled due to higher priority scenario retries
-    const scenarioRetries = test.retries()
-    const stepRetryPriority = RETRY_PRIORITIES.STEP_PLUGIN
-    const scenarioPriority = test.opts.retryPriority || 0
-
-    if (scenarioRetries > 0 && config.deferToScenarioRetries !== false) {
-      // Scenario retries are configured with higher or equal priority
-      // Option 1: Disable step retries (conservative approach)
-      store.autoRetries = false
-      output.log(`[Step Retry] Deferred to scenario retries (${scenarioRetries} retries)`)
-      return
-
-      // Option 2: Reduce step retries to avoid excessive total retries
-      // const reducedStepRetries = Math.max(1, Math.floor(config.retries / scenarioRetries))
-      // config.retries = reducedStepRetries
-      // output.log(`[Step Retry] Reduced to ${reducedStepRetries} retries due to scenario retries (${scenarioRetries})`)
-    }
-
-    // this option is used to set the retries inside _before() block of helpers
-    store.autoRetries = true
-    test.opts.conditionalRetries = config.retries
-    test.opts.stepRetryPriority = stepRetryPriority
-
-    recorder.retry(config)
-
-    output.log(`[Step Retry] Enabled with ${config.retries} retries for test: ${test.title}`)
-  })
-
-  // Add coordination info for debugging
-  event.dispatcher.on(event.test.finished, test => {
-    if (test.state === 'passed' && test.opts.conditionalRetries && store.autoRetries) {
-      const stepRetries = test.opts.conditionalRetries || 0
-      const scenarioRetries = test.retries() || 0
-
-      if (stepRetries > 0 && scenarioRetries > 0) {
-        output.log(`[Retry Coordination] Test used both step retries (${stepRetries}) and scenario retries (${scenarioRetries})`)
-      }
-    }
-  })
-}