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

package/lib/assert/equal.js

@@ -1,7 +1,7 @@
-const Assertion = require('../assert')
-const AssertionFailedError = require('./error')
-const { template } = require('../utils')
-const output = require('../output')
+import Assertion from '../assert.js'
+import AssertionFailedError from './error.js'
+import { template } from '../utils.js'
+import output from '../output.js'
 
 class EqualityAssertion extends Assertion {
   constructor(params) {
@@ -18,10 +18,7 @@ class EqualityAssertion extends Assertion {
   getException() {
     const params = this.params
     params.jar = template(params.jar, params)
-    const err = new AssertionFailedError(
-      params,
-      '{{customMessage}}expected {{jar}} "{{expected}}" {{type}} "{{actual}}"',
-    )
+    const err = new AssertionFailedError(params, '{{customMessage}}expected {{jar}} "{{expected}}" {{type}} "{{actual}}"')
     err.showDiff = false
     if (typeof err.cliMessage === 'function') {
       err.message = err.cliMessage()
@@ -40,18 +37,16 @@ class EqualityAssertion extends Assertion {
   }
 }
 
-module.exports = {
-  Assertion: EqualityAssertion,
-  equals: (jar) => new EqualityAssertion({ jar }),
-  urlEquals: (baseUrl) => {
-    const assert = new EqualityAssertion({ jar: 'url of current page' })
-    assert.comparator = function (expected, actual) {
-      if (expected.indexOf('http') !== 0) {
-        actual = actual.slice(actual.indexOf(baseUrl) + baseUrl.length)
-      }
-      return actual === expected
+export { EqualityAssertion as Assertion }
+export const equals = jar => new EqualityAssertion({ jar })
+export const urlEquals = baseUrl => {
+  const assert = new EqualityAssertion({ jar: 'url of current page' })
+  assert.comparator = function (expected, actual) {
+    if (expected.indexOf('http') !== 0) {
+      actual = actual.slice(actual.indexOf(baseUrl) + baseUrl.length)
     }
-    return assert
-  },
-  fileEquals: (file) => new EqualityAssertion({ file, jar: 'contents of {{file}}' }),
+    return actual === expected
+  }
+  return assert
 }
+export const fileEquals = file => new EqualityAssertion({ file, jar: 'contents of {{file}}' })

package/lib/assert/error.js

@@ -1,4 +1,4 @@
-const subs = require('../utils').template
+import { template as subs } from '../utils.js'
 
 /**
  * Assertion errors, can provide a detailed error messages.
@@ -29,4 +29,4 @@ function AssertionFailedError(params, template) {
 AssertionFailedError.prototype = Object.create(Error.prototype)
 AssertionFailedError.constructor = AssertionFailedError
 
-module.exports = AssertionFailedError
+export default AssertionFailedError

package/lib/assert/include.js

@@ -1,7 +1,7 @@
-const Assertion = require('../assert')
-const AssertionFailedError = require('./error')
-const { template } = require('../utils')
-const output = require('../output')
+import Assertion from '../assert.js'
+import AssertionFailedError from './error.js'
+import { template } from '../utils.js'
+import output from '../output.js'
 
 const MAX_LINES = 10
 
@@ -10,7 +10,7 @@ class InclusionAssertion extends Assertion {
     params.jar = params.jar || 'string'
     const comparator = function (needle, haystack) {
       if (Array.isArray(haystack)) {
-        return haystack.filter((part) => part.indexOf(needle) >= 0).length > 0
+        return haystack.filter(part => part.indexOf(needle) >= 0).length > 0
       }
       return haystack.indexOf(needle) >= 0
     }
@@ -28,9 +28,7 @@ class InclusionAssertion extends Assertion {
       this.params.haystack = this.params.haystack.join('\n___(next element)___\n')
     }
     err.cliMessage = function () {
-      const msg = this.template
-        .replace('{{jar}}', output.colors.bold('{{jar}}'))
-        .replace('{{needle}}', output.colors.bold('{{needle}}'))
+      const msg = this.template.replace('{{jar}}', output.colors.bold('{{jar}}')).replace('{{needle}}', output.colors.bold('{{needle}}'))
       return template(msg, this.params)
     }
     return err
@@ -64,14 +62,12 @@ class InclusionAssertion extends Assertion {
   }
 }
 
-module.exports = {
-  Assertion: InclusionAssertion,
-  includes: (needleType) => {
-    needleType = needleType || 'string'
-    return new InclusionAssertion({ jar: needleType })
-  },
-  fileIncludes: (file) => new InclusionAssertion({ file, jar: 'file {{file}}' }),
+export { InclusionAssertion as Assertion }
+export const includes = needleType => {
+  needleType = needleType || 'string'
+  return new InclusionAssertion({ jar: needleType })
 }
+export const fileIncludes = file => new InclusionAssertion({ file, jar: 'file {{file}}' })
 
 function escapeRegExp(str) {
   return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&')

package/lib/assert/throws.js

@@ -11,12 +11,10 @@ function errorThrown(actual, expected) {
     throw new Error(`Expected error to be thrown with message ${expected} while '${msg}' caught`)
   }
   if (typeof expected === 'object') {
-    if (actual.constructor.name !== expected.constructor.name)
-      throw new Error(`Expected ${expected} error to be thrown but ${actual} was caught`)
-    if (expected.message && expected.message !== msg)
-      throw new Error(`Expected error to be thrown with message ${expected.message} while '${msg}' caught`)
+    if (actual.constructor.name !== expected.constructor.name) throw new Error(`Expected ${expected} error to be thrown but ${actual} was caught`)
+    if (expected.message && expected.message !== msg) throw new Error(`Expected error to be thrown with message ${expected.message} while '${msg}' caught`)
   }
   return null
 }
 
-module.exports = errorThrown
+export default errorThrown

package/lib/assert/truth.js

@@ -1,13 +1,13 @@
-const Assertion = require('../assert')
-const AssertionFailedError = require('./error')
-const { template } = require('../utils')
-const output = require('../output')
+import Assertion from '../assert.js'
+import AssertionFailedError from './error.js'
+import { template } from '../utils.js'
+import output from '../output.js'
 
 class TruthAssertion extends Assertion {
   constructor(params) {
-    super((value) => {
+    super(value => {
       if (Array.isArray(value)) {
-        return value.filter((val) => !!val).length > 0
+        return value.filter(val => !!val).length > 0
       }
       return !!value
     }, params)
@@ -30,7 +30,10 @@ class TruthAssertion extends Assertion {
   }
 }
 
-module.exports = {
+export { TruthAssertion as Assertion }
+export const truth = (subject, type) => new TruthAssertion({ subject, type })
+
+export default {
   Assertion: TruthAssertion,
   truth: (subject, type) => new TruthAssertion({ subject, type }),
 }

package/lib/assert.js

@@ -1,4 +1,4 @@
-const AssertionFailedError = require('./assert/error');
+import AssertionFailedError from './assert/error.js'
 
 /**
  * Abstract assertion class introduced for more verbose and customizable messages.
@@ -22,9 +22,9 @@ const AssertionFailedError = require('./assert/error');
  */
 class Assertion {
   constructor(comparator, params) {
-    this.comparator = comparator;
-    this.params = params || {};
-    this.params.customMessage = '';
+    this.comparator = comparator
+    this.params = params || {}
+    this.params.customMessage = ''
   }
 
   /**
@@ -32,10 +32,10 @@ class Assertion {
    * Fails if comparator function with provided arguments returns false
    */
   assert() {
-    this.addAssertParams.apply(this, arguments);
-    const result = this.comparator.apply(this.params, arguments);
-    if (result) return; // should increase global assertion counter
-    throw this.getFailedAssertion();
+    this.addAssertParams.apply(this, arguments)
+    const result = this.comparator.apply(this.params, arguments)
+    if (result) return // should increase global assertion counter
+    throw this.getFailedAssertion()
   }
 
   /**
@@ -43,10 +43,10 @@ class Assertion {
    * Fails if comparator function with provided arguments returns true
    */
   negate() {
-    this.addAssertParams.apply(this, arguments);
-    const result = this.comparator.apply(this.params, arguments);
-    if (!result) return; // should increase global assertion counter
-    throw this.getFailedNegation();
+    this.addAssertParams.apply(this, arguments)
+    const result = this.comparator.apply(this.params, arguments)
+    if (!result) return // should increase global assertion counter
+    throw this.getFailedNegation()
   }
 
   /**
@@ -55,18 +55,18 @@ class Assertion {
   addAssertParams() {}
 
   getException() {
-    return new AssertionFailedError(this.params, '');
+    return new AssertionFailedError(this.params, '')
   }
 
   getFailedNegation() {
-    const err = this.getException();
-    err.params.type = `not ${err.params.type}`;
-    return err;
+    const err = this.getException()
+    err.params.type = `not ${err.params.type}`
+    return err
   }
 
   getFailedAssertion() {
-    return this.getException();
+    return this.getException()
   }
 }
 
-module.exports = Assertion;
+export default Assertion

package/lib/codecept.js

@@ -1,14 +1,34 @@
-const { existsSync, readFileSync } = require('fs');
-const glob = require('glob');
-const fsPath = require('path');
-const { resolve } = require('path');
-
-const container = require('./container');
-const Config = require('./config');
-const event = require('./event');
-const runHook = require('./hooks');
-const output = require('./output');
-const { emptyFolder } = require('./utils');
+import { existsSync, readFileSync } from 'fs'
+import { globSync } from 'glob'
+import fsPath from 'path'
+import { resolve } from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+import { createRequire } from 'module'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const require = createRequire(import.meta.url)
+
+import Helper from '@codeceptjs/helper'
+import container from './container.js'
+import Config from './config.js'
+import event from './event.js'
+import runHook from './hooks.js'
+import ActorFactory from './actor.js'
+import output from './output.js'
+import { emptyFolder } from './utils.js'
+import { initCodeceptGlobals } from './globals.js'
+
+import storeListener from './listener/store.js'
+import stepsListener from './listener/steps.js'
+import configListener from './listener/config.js'
+import resultListener from './listener/result.js'
+import helpersListener from './listener/helpers.js'
+import globalTimeoutListener from './listener/globalTimeout.js'
+import globalRetryListener from './listener/globalRetry.js'
+import exitListener from './listener/exit.js'
+import emptyRunListener from './listener/emptyRun.js'
 
 /**
  * CodeceptJS runner
@@ -22,10 +42,10 @@ class Codecept {
    * @param {*} opts
    */
   constructor(config, opts) {
-    this.config = Config.create(config);
-    this.opts = opts;
-    this.testFiles = new Array(0);
-    this.requireModules(config.require);
+    this.config = Config.create(config)
+    this.opts = opts
+    this.testFiles = new Array(0)
+    this.requireModules(config.require)
   }
 
   /**
@@ -35,13 +55,13 @@ class Codecept {
    */
   requireModules(requiringModules) {
     if (requiringModules) {
-      requiringModules.forEach((requiredModule) => {
-        const isLocalFile = existsSync(requiredModule) || existsSync(`${requiredModule}.js`);
+      requiringModules.forEach(requiredModule => {
+        const isLocalFile = existsSync(requiredModule) || existsSync(`${requiredModule}.js`)
         if (isLocalFile) {
-          requiredModule = resolve(requiredModule);
+          requiredModule = resolve(requiredModule)
         }
-        require(requiredModule);
-      });
+        require(requiredModule)
+      })
     }
   }
 
@@ -51,11 +71,13 @@ class Codecept {
    *
    * @param {string} dir
    */
-  init(dir) {
-    this.initGlobals(dir);
+  async init(dir) {
+    await this.initGlobals(dir)
     // initializing listeners
-    container.create(this.config, this.opts);
-    this.runHooks();
+    await container.create(this.config, this.opts)
+    // Store container globally for easy access
+    global.container = container
+    await this.runHooks()
   }
 
   /**
@@ -63,56 +85,27 @@ class Codecept {
    *
    * @param {string} dir
    */
-  initGlobals(dir) {
-    global.codecept_dir = dir;
-    global.output_dir = fsPath.resolve(dir, this.config.output);
-
-    if (this.config.emptyOutputFolder) emptyFolder(global.output_dir);
-
-    if (!this.config.noGlobals) {
-      global.Helper = global.codecept_helper = require('@codeceptjs/helper');
-      global.actor = global.codecept_actor = require('./actor');
-      global.pause = require('./pause');
-      global.within = require('./within');
-      global.session = require('./session');
-      global.DataTable = require('./data/table');
-      global.locate = locator => require('./locator').build(locator);
-      global.inject = container.support;
-      global.share = container.share;
-      global.secret = require('./secret').secret;
-      global.codecept_debug = output.debug;
-      global.codeceptjs = require('./index'); // load all objects
-
-      // BDD
-      const stepDefinitions = require('./interfaces/bdd');
-      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 = this.config.maskSensitiveData || false;
-    }
+  async initGlobals(dir) {
+    await initCodeceptGlobals(dir, this.config, container)
   }
 
   /**
    * Executes hooks.
    */
-  runHooks() {
+  async runHooks() {
     // default hooks
-    runHook(require('./listener/steps'));
-    runHook(require('./listener/artifacts'));
-    runHook(require('./listener/config'));
-    runHook(require('./listener/helpers'));
-    runHook(require('./listener/retry'));
-    runHook(require('./listener/timeout'));
-    runHook(require('./listener/exit'));
+    runHook(storeListener)
+    runHook(stepsListener)
+    runHook(configListener)
+    runHook(resultListener)
+    runHook(helpersListener)
+    runHook(globalTimeoutListener)
+    runHook(globalRetryListener)
+    runHook(exitListener)
+    runHook(emptyRunListener)
 
     // custom hooks (previous iteration of plugins)
-    this.config.hooks.forEach(hook => runHook(hook));
+    this.config.hooks.forEach(hook => runHook(hook))
   }
 
   /**
@@ -120,7 +113,7 @@ class Codecept {
    *
    */
   async bootstrap() {
-    return runHook(this.config.bootstrap, 'bootstrap');
+    return runHook(this.config.bootstrap, 'bootstrap')
   }
 
   /**
@@ -128,7 +121,7 @@ class Codecept {
 
    */
   async teardown() {
-    return runHook(this.config.teardown, 'teardown');
+    return runHook(this.config.teardown, 'teardown')
   }
 
   /**
@@ -139,42 +132,44 @@ class Codecept {
   loadTests(pattern) {
     const options = {
       cwd: global.codecept_dir,
-    };
+    }
 
-    let patterns = [pattern];
+    let patterns = [pattern]
     if (!pattern) {
-      patterns = [];
+      patterns = []
 
       // If the user wants to test a specific set of test files as an array or string.
       if (this.config.tests && !this.opts.features) {
         if (Array.isArray(this.config.tests)) {
-          patterns.push(...this.config.tests);
+          patterns.push(...this.config.tests)
         } else {
-          patterns.push(this.config.tests);
+          patterns.push(this.config.tests)
         }
       }
 
-      if (this.config.gherkin.features && !this.opts.tests) {
+      if (this.config.gherkin && this.config.gherkin.features && !this.opts.tests) {
         if (Array.isArray(this.config.gherkin.features)) {
           this.config.gherkin.features.forEach(feature => {
-            patterns.push(feature);
-          });
+            patterns.push(feature)
+          })
         } else {
-          patterns.push(this.config.gherkin.features);
+          patterns.push(this.config.gherkin.features)
         }
       }
     }
 
     for (pattern of patterns) {
-      glob.sync(pattern, options).forEach((file) => {
-        if (file.includes('node_modules')) return;
-        if (!fsPath.isAbsolute(file)) {
-          file = fsPath.join(global.codecept_dir, file);
-        }
-        if (!this.testFiles.includes(fsPath.resolve(file))) {
-          this.testFiles.push(fsPath.resolve(file));
-        }
-      });
+      if (pattern) {
+        globSync(pattern, options).forEach(file => {
+          if (file.includes('node_modules')) return
+          if (!fsPath.isAbsolute(file)) {
+            file = fsPath.join(global.codecept_dir, file)
+          }
+          if (!this.testFiles.includes(fsPath.resolve(file))) {
+            this.testFiles.push(fsPath.resolve(file))
+          }
+        })
+      }
     }
   }
 
@@ -185,34 +180,50 @@ class Codecept {
    * @returns {Promise<void>}
    */
   async run(test) {
+    await container.started()
+
+    // Ensure translations are loaded for Gherkin features
+    try {
+      const { loadTranslations } = await import('./mocha/gherkin.js')
+      await loadTranslations()
+    } catch (e) {
+      // Ignore if gherkin module not available
+    }
+
     return new Promise((resolve, reject) => {
-      const mocha = container.mocha();
-      mocha.files = this.testFiles;
+      const mocha = container.mocha()
+      mocha.files = this.testFiles
+
       if (test) {
         if (!fsPath.isAbsolute(test)) {
-          test = fsPath.join(global.codecept_dir, test);
+          test = fsPath.join(global.codecept_dir, test)
         }
-        mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test);
+        const testBasename = fsPath.basename(test, '.js')
+        const testFeatureBasename = fsPath.basename(test, '.feature')
+        mocha.files = mocha.files.filter(t => {
+          return fsPath.basename(t, '.js') === testBasename || fsPath.basename(t, '.feature') === testFeatureBasename || t === test
+        })
       }
+
       const done = () => {
-        event.emit(event.all.result, this);
-        event.emit(event.all.after, this);
-        resolve();
-      };
+        event.emit(event.all.result, container.result())
+        event.emit(event.all.after, this)
+        resolve()
+      }
 
       try {
-        event.emit(event.all.before, this);
-        mocha.run(() => done());
+        event.emit(event.all.before, this)
+        mocha.run(() => done())
       } catch (e) {
-        output.error(e.stack);
-        reject(e);
+        output.error(e.stack)
+        reject(e)
       }
-    });
+    })
   }
 
   static version() {
-    return JSON.parse(readFileSync(`${__dirname}/../package.json`, 'utf8')).version;
+    return JSON.parse(readFileSync(`${__dirname}/../package.json`, 'utf8')).version
   }
 }
 
-module.exports = Codecept;
+export default Codecept