codeceptjs 4.0.0-beta.4 → 4.0.0-beta.6.esm-aria

package/lib/els.js

@@ -0,0 +1,160 @@
+import output from './output.js'
+import store from './store.js'
+import container from './container.js'
+import StepConfig from './step/config.js'
+import recordStep from './step/record.js'
+import FuncStep from './step/func.js'
+import { truth } from './assert/truth.js'
+import { isAsyncFunction, humanizeFunction } from './utils.js'
+
+function element(purpose, locator, fn) {
+  let stepConfig
+  if (arguments[arguments.length - 1] instanceof StepConfig) {
+    stepConfig = arguments[arguments.length - 1]
+  }
+
+  if (!fn || fn === stepConfig) {
+    fn = locator
+    locator = purpose
+    purpose = 'first element'
+  }
+
+  const step = prepareStep(purpose, locator, fn)
+  if (!step) return
+
+  return executeStep(
+    step,
+    async () => {
+      const els = await step.helper._locate(locator)
+      output.debug(`Found ${els.length} elements, using first element`)
+
+      return fn(els[0])
+    },
+    stepConfig,
+  )
+}
+
+function eachElement(purpose, locator, fn) {
+  if (!fn) {
+    fn = locator
+    locator = purpose
+    purpose = 'for each element'
+  }
+
+  const step = prepareStep(purpose, locator, fn)
+  if (!step) return
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator)
+    output.debug(`Found ${els.length} elements for each elements to iterate`)
+
+    const errs = []
+    let i = 0
+    for (const el of els) {
+      try {
+        await fn(el, i)
+      } catch (err) {
+        output.error(`eachElement: failed operation on element #${i} ${el}`)
+        errs.push(err)
+      }
+      i++
+    }
+
+    if (errs.length) {
+      throw errs[0]
+    }
+  })
+}
+
+function expectElement(locator, fn) {
+  const step = prepareStep('expect element to be', locator, fn)
+  if (!step) return
+
+  return executeStep(step, async () => {
+    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 assertion = truth(`element (${locator})`, fn.toString())
+    assertion.assert(result)
+  })
+}
+
+function expectAnyElement(locator, fn) {
+  const step = prepareStep('expect any element to be', locator, fn)
+  if (!step) return
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator)
+    output.debug(`Found ${els.length} elements, at least one should pass the assertion`)
+
+    const assertion = truth(`any element of (${locator})`, fn.toString())
+
+    let found = false
+    for (const el of els) {
+      const result = await fn(el)
+      if (result) {
+        found = true
+        break
+      }
+    }
+    if (!found) throw assertion.getException()
+  })
+}
+
+function expectAllElements(locator, fn) {
+  const step = prepareStep('expect all elements', locator, fn)
+  if (!step) return
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator)
+    output.debug(`Found ${els.length} elements, all should pass the assertion`)
+
+    let i = 1
+    for (const el of els) {
+      output.debug(`checking element #${i}: ${el}`)
+      const result = await fn(el)
+      const assertion = truth(`element #${i} of (${locator})`, humanizeFunction(fn))
+      assertion.assert(result)
+      i++
+    }
+  })
+}
+
+export { element, eachElement, expectElement, expectAnyElement, expectAllElements }
+
+export default {
+  element,
+  eachElement,
+  expectElement,
+  expectAnyElement,
+  expectAllElements,
+}
+
+function prepareStep(purpose, locator, fn) {
+  if (store.dryRun) return
+  const helpers = Object.values(container.helpers())
+
+  const helper = helpers.filter(h => !!h._locate)[0]
+
+  if (!helper) {
+    throw new Error('No helper enabled with _locate method with returns a list of elements.')
+  }
+
+  if (!isAsyncFunction(fn)) {
+    throw new Error('Async function should be passed into each element')
+  }
+
+  const isAssertion = purpose.startsWith('expect')
+
+  const step = new FuncStep(`${purpose} within "${locator}" ${isAssertion ? 'to be' : 'to'}`)
+  step.setHelper(helper)
+  step.setArguments([humanizeFunction(fn)]) // user defined function is a passed argument
+
+  return step
+}
+
+async function executeStep(step, action, stepConfig = {}) {
+  step.setCallable(action)
+  return recordStep(step, [stepConfig])
+}

package/lib/event.js

@@ -1,15 +1,16 @@
-const debug = require('debug')('codeceptjs:event');
-const events = require('events');
-const { error } = require('./output');
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:event')
+import events from 'events'
+import output from './output.js'
 
-const dispatcher = new events.EventEmitter();
+const dispatcher = new events.EventEmitter()
 
-dispatcher.setMaxListeners(50);
+dispatcher.setMaxListeners(50)
 /**
  * @namespace
  * @alias event
  */
-module.exports = {
+export default {
   /**
    * @type {NodeJS.EventEmitter}
    * @constant
@@ -54,12 +55,16 @@ module.exports = {
    * @inner
    * @property {'hook.start'} started
    * @property {'hook.passed'} passed
+   * @property {'hook.failed'} failed
+   * @property {'hook.finished'} finished
    */
   hook: {
     started: 'hook.start',
     passed: 'hook.passed',
     failed: 'hook.failed',
+    finished: 'hook.finished',
   },
+
   /**
    * @type {object}
    * @constant
@@ -140,33 +145,33 @@ module.exports = {
    * @param {*} [param]
    */
   emit(event, param) {
-    let msg = `Emitted | ${event}`;
+    let msg = `Emitted | ${event}`
     if (param && param.toString()) {
-      msg += ` (${param.toString()})`;
+      msg += ` (${param.toString()})`
     }
-    debug(msg);
+    debug(msg)
     try {
-      this.dispatcher.emit.apply(this.dispatcher, arguments);
+      this.dispatcher.emit.apply(this.dispatcher, arguments)
     } catch (err) {
-      error(`Error processing ${event} event:`);
-      error(err.stack);
+      output.error(`Error processing ${event} event:`)
+      output.error(err.stack)
     }
   },
 
   /** for testing only! */
-  cleanDispatcher: () => {
-    let event;
+  cleanDispatcher() {
+    let event
     for (event in this.test) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.test[event])
     }
     for (event in this.suite) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.suite[event])
     }
     for (event in this.step) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.step[event])
     }
     for (event in this.all) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.all[event])
     }
   },
-};
+}

package/lib/globals.js

@@ -0,0 +1,141 @@
+/**
+ * Global variables initialization module
+ *
+ * Centralizes all global variable setup for CodeceptJS from codecept.js and mocha/ui.js
+ */
+
+import fsPath from 'path'
+import ActorFactory from './actor.js'
+import output from './output.js'
+import locator from './locator.js'
+
+/**
+ * Initialize CodeceptJS core globals
+ * Called from Codecept.initGlobals()
+ */
+export async function initCodeceptGlobals(dir, config, container) {
+  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
+  global.pause = async (...args) => {
+    const pauseModule = await import('./pause.js')
+    return (pauseModule.default || pauseModule)(...args)
+  }
+
+  global.within = async (...args) => {
+    return (await import('./effects.js')).within(...args)
+  }
+
+  global.session = async (...args) => {
+    const sessionModule = await import('./session.js')
+    return (sessionModule.default || sessionModule)(...args)
+  }
+
+  const dataTableModule = await import('./data/table.js')
+  global.DataTable = dataTableModule.default || dataTableModule
+
+  global.locate = locatorQuery => {
+    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
+
+  // BDD step definitions
+  const stepDefinitionsModule = await import('./mocha/bdd.js')
+  const stepDefinitions = stepDefinitionsModule.default || stepDefinitionsModule
+  global.Given = stepDefinitions.Given
+  global.When = stepDefinitions.When
+  global.Then = stepDefinitions.Then
+  global.DefineParameterType = stepDefinitions.defineParameterType
+
+  // debug mode
+  global.debugMode = false
+
+  // mask sensitive data
+  global.maskSensitiveData = config.maskSensitiveData || false
+
+}
+
+/**
+ * Initialize Mocha test framework globals (Feature, Scenario, etc.)
+ * Called from mocha/ui.js pre-require event
+ */
+export function initMochaGlobals(context) {
+  // Mocha test framework globals
+  global.BeforeAll = context.BeforeAll
+  global.AfterAll = context.AfterAll
+  global.Feature = context.Feature
+  global.xFeature = context.xFeature
+  global.BeforeSuite = context.BeforeSuite
+  global.AfterSuite = context.AfterSuite
+  global.Background = context.Background
+  global.Before = context.Before
+  global.After = context.After
+  global.Scenario = context.Scenario
+  global.xScenario = context.xScenario
+}
+
+/**
+ * Clear all CodeceptJS globals (useful for testing/cleanup)
+ */
+export function clearGlobals() {
+  getGlobalNames().forEach(name => delete global[name]);
+}
+
+/**
+ * Get list of all CodeceptJS global variable names
+ */
+export function getGlobalNames() {
+  return [
+    'codecept_dir',
+    'output_dir',
+    'actor',
+    'codecept_actor',
+    'Actor',
+    'pause',
+    'within',
+    'session',
+    'DataTable',
+    'locate',
+    'inject',
+    'share',
+    'secret',
+    'codecept_debug',
+    'codeceptjs',
+    'Given',
+    'When',
+    'Then',
+    'DefineParameterType',
+    'debugMode',
+    'maskSensitiveData',
+    'BeforeAll',
+    'AfterAll',
+    'Feature',
+    'xFeature',
+    'BeforeSuite',
+    'AfterSuite',
+    'Background',
+    'Before',
+    'After',
+    'Scenario',
+    'xScenario',
+    'container'
+  ]
+}

package/lib/heal.js

@@ -1,122 +1,125 @@
-const debug = require('debug')('codeceptjs:heal');
-const colors = require('chalk');
-const Container = require('./container');
-const recorder = require('./recorder');
-const output = require('./output');
-const event = require('./event');
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:heal')
+import colors from 'chalk'
+import recorder from './recorder.js'
+import output from './output.js'
+import event from './event.js'
 
 /**
  * @class
  */
 class Heal {
   constructor() {
-    this.recipes = {};
-    this.fixes = [];
-    this.prepareFns = [];
-    this.contextName = null;
-    this.numHealed = 0;
+    this.recipes = {}
+    this.fixes = []
+    this.prepareFns = []
+    this.contextName = null
+    this.numHealed = 0
   }
 
   clear() {
-    this.recipes = {};
-    this.fixes = [];
-    this.prepareFns = [];
-    this.contextName = null;
-    this.numHealed = 0;
+    this.recipes = {}
+    this.fixes = []
+    this.prepareFns = []
+    this.contextName = null
+    this.numHealed = 0
   }
 
   addRecipe(name, opts = {}) {
-    if (!opts.priority) opts.priority = 0;
+    if (!opts.priority) opts.priority = 0
 
-    if (!opts.fn) throw new Error(`Recipe ${name} should have a function 'fn' to execute`);
+    if (!opts.fn) throw new Error(`Recipe ${name} should have a function 'fn' to execute`)
 
-    this.recipes[name] = opts;
+    this.recipes[name] = opts
   }
 
   connectToEvents() {
-    event.dispatcher.on(event.suite.before, (suite) => {
-      this.contextName = suite.title;
-    });
+    event.dispatcher.on(event.suite.before, suite => {
+      this.contextName = suite.title
+    })
 
-    event.dispatcher.on(event.test.started, (test) => {
-      this.contextName = test.fullTitle();
-    });
+    event.dispatcher.on(event.test.started, test => {
+      this.contextName = test.fullTitle()
+    })
 
     event.dispatcher.on(event.test.finished, () => {
-      this.contextName = null;
-    });
+      this.contextName = null
+    })
   }
 
   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.name)).length > 0
   }
 
   async getCodeSuggestions(context) {
-    const suggestions = [];
-    const recipes = matchRecipes(this.recipes, this.contextName);
+    const suggestions = []
+    const recipes = matchRecipes(this.recipes, this.contextName)
 
-    debug('Recipes', recipes);
+    debug('Recipes', recipes)
 
-    const currentOutputLevel = output.level();
-    output.level(0);
+    const currentOutputLevel = output.level()
+    output.level(0)
 
-    for (const [property, prepareFn] of Object.entries(recipes.map(r => r.prepare).filter(p => !!p).reduce((acc, obj) => ({ ...acc, ...obj }), {}))) {
-      if (!prepareFn) continue;
+    for (const [property, prepareFn] of Object.entries(
+      recipes
+        .map(r => r.prepare)
+        .filter(p => !!p)
+        .reduce((acc, obj) => ({ ...acc, ...obj }), {}),
+    )) {
+      if (!prepareFn) continue
 
-      if (context[property]) continue;
-      context[property] = await prepareFn(Container.support());
+      if (context[property]) continue
+      context[property] = await prepareFn(global.inject())
     }
 
-    output.level(currentOutputLevel);
+    output.level(currentOutputLevel)
 
     for (const recipe of recipes) {
-      let snippets = await recipe.fn(context);
-      if (!Array.isArray(snippets)) snippets = [snippets];
+      let snippets = await recipe.fn(context)
+      if (!Array.isArray(snippets)) snippets = [snippets]
 
       suggestions.push({
         name: recipe.name,
         snippets,
-      });
+      })
     }
 
-    return suggestions.filter(s => !isBlank(s.snippets));
+    return suggestions.filter(s => !isBlank(s.snippets))
   }
 
   async healStep(failedStep, error, failureContext = {}) {
-    output.debug(`Trying to heal ${failedStep.toCode()} step`);
+    output.debug(`Trying to heal ${failedStep.toCode()} step`)
 
     Object.assign(failureContext, {
       error,
       step: failedStep,
       prevSteps: failureContext?.test?.steps?.slice(0, -1) || [],
-    });
+    })
 
-    const suggestions = await this.getCodeSuggestions(failureContext);
+    const suggestions = await this.getCodeSuggestions(failureContext)
 
     if (suggestions.length === 0) {
-      debug('No healing suggestions found');
-      throw error;
+      debug('No healing suggestions found')
+      throw error
     }
 
-    output.debug(`Received ${suggestions.length} suggestion${suggestions.length === 1 ? '' : 's'}`);
+    output.debug(`Received ${suggestions.length} suggestion${suggestions.length === 1 ? '' : 's'}`)
 
-    debug(suggestions);
+    debug(suggestions)
 
     for (const suggestion of suggestions) {
       for (const codeSnippet of suggestion.snippets) {
         try {
-          debug('Executing', codeSnippet);
-          recorder.catch((e) => {
-            debug(e);
-          });
+          debug('Executing', codeSnippet)
+          recorder.catch(e => {
+            debug(e)
+          })
 
           if (typeof codeSnippet === 'string') {
-            const I = Container.support('I');
-            await eval(codeSnippet); // eslint-disable-line
+            const I = global.container.support('I')
+            await eval(codeSnippet)
           } else if (typeof codeSnippet === 'function') {
-            await codeSnippet(Container.support());
+            await codeSnippet(global.container.support())
           }
 
           this.fixes.push({
@@ -124,49 +127,54 @@ class Heal {
             test: failureContext?.test,
             step: failedStep,
             snippet: codeSnippet,
-          });
+          })
+
+          if (failureContext?.test) {
+            const test = failureContext.test
+            let note = `This test was healed by '${suggestion.name}'`
+            note += `\n\nReplace the failed code:\n\n`
+            note += colors.red(`- ${failedStep.toCode()}\n`)
+            note += colors.green(`+ ${codeSnippet}\n`)
+            test.addNote('heal', note)
+            test.meta.healed = true
+          }
 
-          recorder.add('healed', () => output.print(colors.bold.green(`  Code healed successfully by ${suggestion.name}`), colors.gray('(no errors thrown)')));
-          this.numHealed++;
+          recorder.add('healed', () => output.print(colors.bold.green(`  Code healed successfully by ${suggestion.name}`), colors.gray('(no errors thrown)')))
+          this.numHealed++
           // recorder.session.restore();
-          return;
+          return
         } catch (err) {
-          debug('Failed to execute code', err);
-          recorder.ignoreErr(err); // healing did not help
-          recorder.catchWithoutStop(err);
-          await recorder.promise(); // wait for all promises to resolve
+          debug('Failed to execute code', err)
+          recorder.ignoreErr(err) // healing did not help
+          recorder.catchWithoutStop(err)
+          await recorder.promise() // wait for all promises to resolve
         }
       }
     }
-    output.debug(`Couldn't heal the code for ${failedStep.toCode()}`);
-    recorder.throw(error);
+    output.debug(`Couldn't heal the code for ${failedStep.toCode()}`)
+    recorder.throw(error)
   }
 
-  static setDefaultHealers() {
-    require('./template/heal');
+  static async setDefaultHealers() {
+    await import('./template/heal.js')
   }
 }
 
-const heal = new Heal();
+const heal = new Heal()
 
-module.exports = heal;
+export default heal
 
 function matchRecipes(recipes, contextName) {
   return Object.entries(recipes)
     .filter(([, recipe]) => !contextName || !recipe.grep || new RegExp(recipe.grep).test(contextName))
     .sort(([, a], [, b]) => a.priority - b.priority)
     .map(([name, recipe]) => {
-      recipe.name = name;
-      return recipe;
+      recipe.name = name
+      return recipe
     })
-    .filter(r => !!r.fn);
+    .filter(r => !!r.fn)
 }
 
 function isBlank(value) {
-  return (
-    value == null
-      || (Array.isArray(value) && value.length === 0)
-      || (typeof value === 'object' && Object.keys(value).length === 0)
-      || (typeof value === 'string' && value.trim() === '')
-  );
+  return value == null || (Array.isArray(value) && value.length === 0) || (typeof value === 'object' && Object.keys(value).length === 0) || (typeof value === 'string' && value.trim() === '')
 }

package/lib/helper/AI.js

@@ -1,15 +1,16 @@
-const Helper = require('@codeceptjs/helper')
+const HelperModule = require('@codeceptjs/helper')
 const ora = require('ora-classic')
 const fs = require('fs')
 const path = require('path')
 const ai = require('../ai')
-const standardActingHelpers = require('../plugin/standardActingHelpers')
 const Container = require('../container')
 const { splitByChunks, minifyHtml } = require('../html')
 const { beautify } = require('../utils')
 const output = require('../output')
 const { registerVariable } = require('../pause')
 
+const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
+
 const gtpRole = {
   user: 'user',
 }