codeceptjs 4.0.0-rc.10 → 4.0.0-rc.15

package/lib/helper/extras/focusCheck.js

@@ -0,0 +1,43 @@
+import store from '../../store.js'
+import NonFocusedType from '../errors/NonFocusedType.js'
+
+const MODIFIER_PATTERN = /^(control|ctrl|meta|cmd|command|commandorcontrol|ctrlorcommand)/i
+const EDITING_KEYS = new Set(['a', 'c', 'x', 'v', 'z', 'y'])
+
+async function isNoElementFocused(helper) {
+  return helper.executeScript(() => {
+    const ae = document.activeElement
+    return !ae || ae === document.documentElement || (ae === document.body && !ae.isContentEditable)
+  })
+}
+
+export async function checkFocusBeforeType(helper) {
+  if (!helper.options.strict && !store.debugMode) return
+  if (!await isNoElementFocused(helper)) return
+
+  const message = 'No element is in focus. Use I.click() or I.focus() to activate an element before typing.'
+  if (helper.options.strict) throw new NonFocusedType(message)
+  helper.debugSection('Warning', message)
+}
+
+export async function checkFocusBeforePressKey(helper, originalKey) {
+  if (!helper.options.strict && !store.debugMode) return
+  if (!Array.isArray(originalKey)) return
+
+  let hasCtrlOrMeta = false
+  let actionKey = null
+  for (const k of originalKey) {
+    if (MODIFIER_PATTERN.test(k)) {
+      hasCtrlOrMeta = true
+    } else {
+      actionKey = k
+    }
+  }
+  if (!hasCtrlOrMeta || !actionKey || !EDITING_KEYS.has(actionKey.toLowerCase())) return
+
+  if (!await isNoElementFocused(helper)) return
+
+  const message = `No element is in focus. Key combination with "${originalKey.join('+')}" may not work as expected. Use I.click() or I.focus() first.`
+  if (helper.options.strict) throw new NonFocusedType(message)
+  helper.debugSection('Warning', message)
+}

package/lib/helper/extras/richTextEditor.js

@@ -0,0 +1,115 @@
+import WebElement from '../../element/WebElement.js'
+
+const MARKER = 'data-codeceptjs-rte-target'
+
+const EDITOR = {
+  STANDARD: 'standard',
+  IFRAME: 'iframe',
+  CONTENTEDITABLE: 'contenteditable',
+  HIDDEN_TEXTAREA: 'hidden-textarea',
+}
+
+function detectAndMark(el, opts) {
+  const marker = opts.marker
+  const kinds = opts.kinds
+  const CE = '[contenteditable="true"], [contenteditable=""]'
+  const MAX_HIDDEN_ASCENT = 3
+
+  function mark(kind, target) {
+    document.querySelectorAll('[' + marker + ']').forEach(n => n.removeAttribute(marker))
+    if (target && target.nodeType === 1) target.setAttribute(marker, '1')
+    return kind
+  }
+
+  if (!el || el.nodeType !== 1) return mark(kinds.STANDARD, el)
+
+  const tag = el.tagName
+  if (tag === 'IFRAME') return mark(kinds.IFRAME, el)
+  if (el.isContentEditable) return mark(kinds.CONTENTEDITABLE, el)
+
+  const canSearchDescendants = tag !== 'INPUT' && tag !== 'TEXTAREA'
+  if (canSearchDescendants) {
+    const iframe = el.querySelector('iframe')
+    if (iframe) return mark(kinds.IFRAME, iframe)
+    const ce = el.querySelector(CE)
+    if (ce) return mark(kinds.CONTENTEDITABLE, ce)
+    const textarea = el.querySelector('textarea')
+    if (textarea) return mark(kinds.HIDDEN_TEXTAREA, textarea)
+  }
+
+  const style = window.getComputedStyle(el)
+  const isHidden =
+    el.offsetParent === null ||
+    (el.offsetWidth === 0 && el.offsetHeight === 0) ||
+    style.display === 'none' ||
+    style.visibility === 'hidden'
+  if (!isHidden) return mark(kinds.STANDARD, el)
+
+  const isFormHidden = tag === 'INPUT' && el.type === 'hidden'
+  if (isFormHidden) return mark(kinds.STANDARD, el)
+
+  let scope = el.parentElement
+  for (let depth = 0; scope && depth < MAX_HIDDEN_ASCENT; depth++, scope = scope.parentElement) {
+    const iframeNear = scope.querySelector('iframe')
+    if (iframeNear) return mark(kinds.IFRAME, iframeNear)
+    const ceNear = scope.querySelector(CE)
+    if (ceNear) return mark(kinds.CONTENTEDITABLE, ceNear)
+    const textareaNear = [...scope.querySelectorAll('textarea')].find(t => t !== el)
+    if (textareaNear) return mark(kinds.HIDDEN_TEXTAREA, textareaNear)
+  }
+
+  return mark(kinds.STANDARD, el)
+}
+
+function selectAllInEditable(el) {
+  const doc = el.ownerDocument
+  const win = doc.defaultView
+  el.focus()
+  const range = doc.createRange()
+  range.selectNodeContents(el)
+  const sel = win.getSelection()
+  sel.removeAllRanges()
+  sel.addRange(range)
+}
+
+function unmarkAll(marker) {
+  document.querySelectorAll('[' + marker + ']').forEach(n => n.removeAttribute(marker))
+}
+
+async function findMarked(helper) {
+  const root = helper.page || helper.browser
+  const raw = await root.$('[' + MARKER + ']')
+  return new WebElement(raw, helper)
+}
+
+async function clearMarker(helper) {
+  if (helper.page) return helper.page.evaluate(unmarkAll, MARKER)
+  return helper.executeScript(unmarkAll, MARKER)
+}
+
+export async function fillRichEditor(helper, el, value) {
+  const source = el instanceof WebElement ? el : new WebElement(el, helper)
+  const kind = await source.evaluate(detectAndMark, { marker: MARKER, kinds: EDITOR })
+  if (kind === EDITOR.STANDARD) return false
+
+  const target = await findMarked(helper)
+  const delay = helper.options.pressKeyDelay
+
+  if (kind === EDITOR.IFRAME) {
+    await target.inIframe(async body => {
+      await body.evaluate(selectAllInEditable)
+      await body.typeText(value, { delay })
+    })
+  } else if (kind === EDITOR.HIDDEN_TEXTAREA) {
+    await target.focus()
+    await target.selectAllAndDelete()
+    await target.typeText(value, { delay })
+  } else if (kind === EDITOR.CONTENTEDITABLE) {
+    await target.click()
+    await target.evaluate(selectAllInEditable)
+    await target.typeText(value, { delay })
+  }
+
+  await clearMarker(helper)
+  return true
+}

package/lib/history.js

@@ -2,6 +2,7 @@ import colors from 'chalk'
 import fs from 'fs'
 import path from 'path'
 import output from './output.js'
+import store from './store.js'
 
 /**
  * REPL history records REPL commands and stores them in
@@ -9,8 +10,8 @@ import output from './output.js'
  */
 class ReplHistory {
   constructor() {
-    if (global.output_dir) {
-      this.historyFile = path.join(global.output_dir, 'cli-history')
+    if (store.outputDir) {
+      this.historyFile = path.join(store.outputDir, 'cli-history')
     }
     this.commands = []
   }

package/lib/listener/config.js

@@ -2,16 +2,18 @@ import event from '../event.js'
 import recorder from '../recorder.js'
 import { deepMerge, deepClone, ucfirst } from '../utils.js'
 import output from '../output.js'
+import container from '../container.js'
 
 /**
  * Enable Helpers to listen to test events
  */
+let initialized = false
+
 export default function () {
-  // Use global flag to prevent duplicate initialization across module re-imports
-  if (global.__codeceptConfigListenerInitialized) {
+  if (initialized) {
     return
   }
-  global.__codeceptConfigListenerInitialized = true
+  initialized = true
 
   enableDynamicConfigFor('suite')
   enableDynamicConfigFor('test')
@@ -20,7 +22,7 @@ export default function () {
     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()
+      const helpers = container.helpers()
 
       function updateHelperConfig(helper, config) {
         // Guard against undefined or invalid helpers

package/lib/listener/emptyRun.js

@@ -1,6 +1,7 @@
 import figures from 'figures'
 import event from '../event.js'
 import output from '../output.js'
+import container from '../container.js'
 import { searchWithFusejs } from '../utils.js'
 
 export default function () {
@@ -12,7 +13,7 @@ export default function () {
 
   event.dispatcher.on(event.all.result, () => {
     if (isEmptyRun) {
-      const mocha = global.container.mocha()
+      const mocha = container.mocha()
 
       if (mocha.options.grep) {
         output.print()

package/lib/listener/helpers.js

@@ -3,11 +3,12 @@ import event from '../event.js'
 import recorder from '../recorder.js'
 import store from '../store.js'
 import output from '../output.js'
+import container from '../container.js'
 /**
  * Enable Helpers to listen to test events
  */
 export default function () {
-  const helpers = global.container.helpers()
+  const helpers = container.helpers()
 
   const runHelpersHook = (hook, param) => {
     if (store.dryRun) return
@@ -29,11 +30,13 @@ export default function () {
   event.dispatcher.on(event.suite.before, suite => {
     // if (suite.parent) return; // only for root suite
     runAsyncHelpersHook('_beforeSuite', suite, true)
+    recorder.catch()
   })
 
   event.dispatcher.on(event.suite.after, suite => {
     // if (suite.parent) return; // only for root suite
     runAsyncHelpersHook('_afterSuite', suite, true)
+    recorder.catch()
   })
 
   event.dispatcher.on(event.test.started, test => {

package/lib/listener/mocha.js

@@ -1,10 +1,11 @@
 import event from '../event.js'
+import container from '../container.js'
 
 export default function () {
   let mocha
 
   event.dispatcher.on(event.all.before, () => {
-    mocha = global.container.mocha()
+    mocha = container.mocha()
   })
 
   event.dispatcher.on(event.test.passed, test => {

package/lib/listener/pageobjects.js

@@ -0,0 +1,43 @@
+import event from '../event.js'
+import recorder from '../recorder.js'
+import store from '../store.js'
+import container from '../container.js'
+import { resetBeforeCalledSet, getBeforeCalledSet } from '../container.js'
+
+export default function () {
+  const runAsyncSupportHook = (hook, param, force) => {
+    if (store.dryRun) return
+    const support = container.supportObjects()
+    Object.keys(support).forEach(key => {
+      if (key === 'I') return
+      const obj = support[key]
+      if (!obj || typeof obj !== 'object' || !obj[hook]) return
+      recorder.add(`pageobject ${key}.${hook}()`, () => obj[hook](param), force, false)
+    })
+  }
+
+  event.dispatcher.on(event.test.started, () => {
+    resetBeforeCalledSet()
+  })
+
+  event.dispatcher.on(event.test.after, () => {
+    if (store.dryRun) return
+    const support = container.supportObjects()
+    const called = getBeforeCalledSet()
+    called.forEach(name => {
+      const obj = support[name]
+      if (obj && obj._after) {
+        recorder.add(`pageobject ${name}._after()`, () => obj._after(), true, false)
+      }
+    })
+    recorder.catchWithoutStop(() => {})
+  })
+
+  event.dispatcher.on(event.suite.after, suite => {
+    runAsyncSupportHook('_afterSuite', suite, true)
+  })
+
+  event.dispatcher.on(event.suite.before, suite => {
+    runAsyncSupportHook('_beforeSuite', suite, true)
+  })
+}

package/lib/listener/result.js

@@ -1,11 +1,12 @@
 import event from '../event.js'
+import container from '../container.js'
 
 export default function () {
   event.dispatcher.on(event.hook.failed, err => {
-    global.container.result().addStats({ failedHooks: 1 })
+    container.result().addStats({ failedHooks: 1 })
   })
 
   event.dispatcher.on(event.test.before, test => {
-    global.container.result().addTest(test)
+    container.result().addTest(test)
   })
 }

package/lib/locator.js

@@ -381,9 +381,121 @@ class Locator {
     return new Locator({ xpath })
   }
 
+  /**
+   * Find an element with all of the provided CSS classes (word-exact match).
+   * Accepts variadic class names; all must be present.
+   *
+   * Example:
+   *   locate('button').withClass('btn-primary', 'btn-lg')
+   *
+   * @param {...string} classes
+   * @returns {Locator}
+   */
+  withClass(...classes) {
+    if (!classes.length) return this
+    const predicates = classes.map(c => `contains(concat(' ', normalize-space(@class), ' '), ' ${c} ')`)
+    const xpath = sprintf('%s[%s]', this.toXPath(), predicates.join(' and '))
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Find an element with none of the provided CSS classes.
+   *
+   * Example:
+   *   locate('tr').withoutClass('deleted')
+   *
+   * @param {...string} classes
+   * @returns {Locator}
+   */
+  withoutClass(...classes) {
+    if (!classes.length) return this
+    const predicates = classes.map(c => `not(contains(concat(' ', normalize-space(@class), ' '), ' ${c} '))`)
+    const xpath = sprintf('%s[%s]', this.toXPath(), predicates.join(' and '))
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Find an element that does NOT contain the provided text.
+   * @param {string} text
+   * @returns {Locator}
+   */
+  withoutText(text) {
+    text = xpathLocator.literal(text)
+    const xpath = sprintf('%s[%s]', this.toXPath(), `not(contains(., ${text}))`)
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Find an element that does NOT have any of the provided attribute/value pairs.
+   * @param {Object.<string, string>} attributes
+   * @returns {Locator}
+   */
+  withoutAttr(attributes) {
+    const operands = []
+    for (const attr of Object.keys(attributes)) {
+      operands.push(`not(@${attr} = ${xpathLocator.literal(attributes[attr])})`)
+    }
+    const xpath = sprintf('%s[%s]', this.toXPath(), operands.join(' and '))
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Find an element that has no direct child matching the provided locator.
+   * @param {CodeceptJS.LocatorOrString} locator
+   * @returns {Locator}
+   */
+  withoutChild(locator) {
+    const xpath = sprintf('%s[not(./child::%s)]', this.toXPath(), convertToSubSelector(locator))
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Find an element that has no descendant matching the provided locator.
+   *
+   * Example:
+   *   locate('button').withoutDescendant('svg')
+   *
+   * @param {CodeceptJS.LocatorOrString} locator
+   * @returns {Locator}
+   */
+  withoutDescendant(locator) {
+    const xpath = sprintf('%s[not(./descendant::%s)]', this.toXPath(), convertToSubSelector(locator))
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Append a raw XPath predicate. Escape hatch for expressions not covered by the DSL.
+   * Argument is inserted as-is inside `[ ]`; quoting/escaping is the caller's responsibility.
+   *
+   * Example:
+   *   locate('input').and('@type="text" or @type="email"')
+   *
+   * @param {string} xpathExpression
+   * @returns {Locator}
+   */
+  and(xpathExpression) {
+    const xpath = sprintf('%s[%s]', this.toXPath(), xpathExpression)
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Append a negated raw XPath predicate: `[not(expr)]`.
+   *
+   * Example:
+   *   locate('button').andNot('.//svg')   // button without a descendant svg
+   *
+   * @param {string} xpathExpression
+   * @returns {Locator}
+   */
+  andNot(xpathExpression) {
+    const xpath = sprintf('%s[not(%s)]', this.toXPath(), xpathExpression)
+    return new Locator({ xpath })
+  }
+
   /**
    * @param {String} text
    * @returns {Locator}
+   * @deprecated Use {@link Locator#withClass} for word-exact class matching, or {@link Locator#withAttrContains} for substring matching.
    */
   withClassAttr(text) {
     const xpath = sprintf('%s[%s]', this.toXPath(), `contains(@class, '${text}')`)

package/lib/mocha/cli.js

@@ -8,6 +8,7 @@ import { dirname, join } from 'path'
 import event from '../event.js'
 import AssertionFailedError from '../assert/error.js'
 import output from '../output.js'
+import store from '../store.js'
 import test, { cloneTest } from './test.js'
 import { fixErrorStack } from '../utils/typescript.js'
 
@@ -41,7 +42,7 @@ class Cli extends Base {
     if (opts.verbose) level = 3
     output.level(level)
     output.print(`CodeceptJS v${codeceptVersion} ${output.standWithUkraine()}`)
-    output.print(`Using test root "${global.codecept_dir}"`)
+    output.print(`Using test root "${store.codeceptDir}"`)
 
     const showSteps = level >= 1
 
@@ -213,6 +214,7 @@ class Cli extends Base {
       }
 
       // append step traces
+      const Container = await getContainer()
       this.failures = this.failures.map(test => {
         // we will change the stack trace, so we need to clone the test
         const err = test.err
@@ -275,7 +277,7 @@ class Cli extends Base {
         }
 
         try {
-          const fileMapping = global.container?.tsFileMapping?.()
+          const fileMapping = Container?.tsFileMapping?.()
           if (fileMapping) {
             fixErrorStack(err, fileMapping)
           }

package/lib/mocha/factory.js

@@ -8,6 +8,7 @@ import output from '../output.js'
 import scenarioUiFunction from './ui.js'
 import { initMochaGlobals } from '../globals.js'
 import { fixErrorStack } from '../utils/typescript.js'
+import container from '../container.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = fsPath.dirname(__filename)
@@ -35,7 +36,7 @@ class MochaFactory {
           // Handle ECONNREFUSED without dynamic import for now
           err = new Error('Connection refused: ' + err.toString())
         }
-        const fileMapping = global.container?.tsFileMapping?.()
+        const fileMapping = container?.tsFileMapping?.()
         if (fileMapping) {
           fixErrorStack(err, fileMapping)
         }

package/lib/mocha/scenarioConfig.js

@@ -1,4 +1,5 @@
 import { isAsyncFunction } from '../utils.js'
+import store from '../store.js'
 
 /** @class */
 class ScenarioConfig {
@@ -40,7 +41,7 @@ class ScenarioConfig {
    * @returns {this}
    */
   retry(retries) {
-    if (process.env.SCENARIO_ONLY) retries = -retries
+    if (store.scenarioOnly) retries = -retries
     this.test.retries(retries)
     return this
   }

package/lib/mocha/ui.js

@@ -9,13 +9,12 @@ import { HookConfig, AfterSuiteHook, AfterHook, BeforeSuiteHook, BeforeHook } fr
 import { initMochaGlobals } from '../globals.js'
 import common from 'mocha/lib/interfaces/common.js'
 import container from '../container.js'
+import store from '../store.js'
 
 const setContextTranslation = context => {
-  // Try global container first, then local container instance
-  const containerToUse = global.container || container
-  if (!containerToUse) return
+  if (!container) return
 
-  const translation = containerToUse.translation?.() || containerToUse.translation
+  const translation = container.translation?.() || container.translation
   const contexts = translation?.value?.('contexts')
 
   if (contexts) {
@@ -119,7 +118,7 @@ export default function (suite) {
     context.Feature.only = function (title, opts) {
       const reString = `^${escapeRe(`${title}:`)}`
       mocha.grep(new RegExp(reString))
-      process.env.FEATURE_ONLY = true
+      store.featureOnly = true
       return context.Feature(title, opts)
     }
 
@@ -171,7 +170,7 @@ export default function (suite) {
     context.Scenario.only = function (title, opts, fn) {
       const reString = `^${escapeRe(`${suites[0].title}: ${title}`.replace(/( \| {.+})?$/g, ''))}`
       mocha.grep(new RegExp(reString))
-      process.env.SCENARIO_ONLY = true
+      store.scenarioOnly = true
       return addScenario(title, opts, fn)
     }
 

package/lib/plugin/aiTrace.js

@@ -4,6 +4,7 @@ import { mkdirp } from 'mkdirp'
 import path from 'path'
 import { fileURLToPath } from 'url'
 
+import store from '../store.js'
 import Container from '../container.js'
 import recorder from '../recorder.js'
 import event from '../event.js'
@@ -16,7 +17,7 @@ const supportedHelpers = Container.STANDARD_ACTING_HELPERS
 const defaultConfig = {
   deleteSuccessful: false,
   fullPageScreenshots: false,
-  output: global.output_dir,
+  output: store.outputDir,
   captureHTML: true,
   captureARIA: true,
   captureBrowserLogs: true,
@@ -84,7 +85,7 @@ export default function (config) {
   let testFailed = false
   let firstFailedStepSaved = false
 
-  const reportDir = config.output ? path.resolve(global.codecept_dir, config.output) : defaultConfig.output
+  const reportDir = config.output ? path.resolve(store.codeceptDir, config.output) : defaultConfig.output
 
   if (config.captureDebugOutput) {
     const originalDebug = output.debug
@@ -437,7 +438,7 @@ export default function (config) {
     const traceFile = path.join(dir, 'trace.md')
     fs.writeFileSync(traceFile, markdown)
 
-    output.print(`🤖 AI Trace: ${colors.white.bold(`file://${traceFile}`)}`)
+    output.print(`Trace Saved: file://${traceFile}`)
 
     if (!test.artifacts) test.artifacts = {}
     test.artifacts.aiTrace = traceFile

package/lib/plugin/analyze.js

@@ -353,7 +353,7 @@ function serializeError(error) {
     errorMessage +=
       '\n' +
       error.stack
-        .replace(global.codecept_dir || '', '.')
+        .replace(store.codeceptDir || '', '.')
         .split('\n')
         .map(line => line.replace(ansiRegExp(), ''))
         .slice(0, 5)

package/lib/plugin/auth.js

@@ -321,7 +321,7 @@ export default function (config) {
       }
       if (config.saveToFile) {
         output.debug(`Saved user session into file for ${name}`)
-        fs.writeFileSync(path.join(global.output_dir, `${name}_session.json`), JSON.stringify(cookies))
+        fs.writeFileSync(path.join(store.outputDir, `${name}_session.json`), JSON.stringify(cookies))
       }
       store[`${name}_session`] = cookies
     }
@@ -377,7 +377,7 @@ export default function (config) {
       }
 
       if (!config.saveToFile) return
-      const cookieFile = path.join(global.output_dir, `${name}_session.json`)
+      const cookieFile = path.join(store.outputDir, `${name}_session.json`)
 
       if (!fileExists(cookieFile)) {
         return
@@ -412,7 +412,7 @@ export default function (config) {
 
 function loadCookiesFromFile(config) {
   for (const name in config.users) {
-    const fileName = path.join(global.output_dir, `${name}_session.json`)
+    const fileName = path.join(store.outputDir, `${name}_session.json`)
     if (!fileExists(fileName)) continue
     const data = fs.readFileSync(fileName).toString()
     try {

package/lib/plugin/pageInfo.js

@@ -6,6 +6,7 @@ import recorder from '../recorder.js'
 import event from '../event.js'
 import { scanForErrorMessages } from '../html.js'
 import { output } from '../index.js'
+import store from '../store.js'
 import { humanizeString, ucfirst } from '../utils.js'
 import { testToFileName } from '../mocha/test.js'
 const defaultConfig = {
@@ -92,7 +93,7 @@ export default function (config = {}) {
     recorder.add('Save page info', () => {
       test.addNote('pageInfo', pageStateToMarkdown(pageState))
 
-      const pageStateFileName = path.join(global.output_dir, `${testToFileName(test)}.pageInfo.md`)
+      const pageStateFileName = path.join(store.outputDir, `${testToFileName(test)}.pageInfo.md`)
       fs.writeFileSync(pageStateFileName, pageStateToMarkdown(pageState))
       test.artifacts.pageInfo = pageStateFileName
       return pageState