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

package/lib/cli.js

@@ -1,256 +0,0 @@
-const { reporters: { Base } } = require('mocha');
-const ms = require('ms');
-const event = require('./event');
-const AssertionFailedError = require('./assert/error');
-const output = require('./output');
-const { MetaStep } = require('./step');
-
-const cursor = Base.cursor;
-let currentMetaStep = [];
-let codeceptjsEventDispatchersRegistered = false;
-
-class Cli extends Base {
-  constructor(runner, opts) {
-    super(runner);
-    let level = 0;
-    this.loadedTests = [];
-    opts = opts.reporterOptions || opts;
-    if (opts.steps) level = 1;
-    if (opts.debug) level = 2;
-    if (opts.verbose) level = 3;
-    output.level(level);
-    output.print(`CodeceptJS v${require('./codecept').version()} ${output.standWithUkraine()}`);
-    output.print(`Using test root "${global.codecept_dir}"`);
-
-    const showSteps = level >= 1;
-
-    if (level >= 2) {
-      const Containter = require('./container');
-      output.print(output.styles.debug(`Helpers: ${Object.keys(Containter.helpers()).join(', ')}`));
-      output.print(output.styles.debug(`Plugins: ${Object.keys(Containter.plugins()).join(', ')}`));
-    }
-
-    runner.on('start', () => {
-      console.log();
-    });
-
-    runner.on('suite', (suite) => {
-      output.suite.started(suite);
-    });
-
-    runner.on('fail', (test) => {
-      if (test.ctx.currentTest) {
-        this.loadedTests.push(test.ctx.currentTest.uid);
-      }
-      if (showSteps && test.steps) {
-        return output.scenario.failed(test);
-      }
-      cursor.CR();
-      output.test.failed(test);
-    });
-
-    runner.on('pending', (test) => {
-      if (test.parent && test.parent.pending) {
-        const suite = test.parent;
-        const skipInfo = suite.opts.skipInfo || {};
-        skipTestConfig(test, skipInfo.message);
-      } else {
-        skipTestConfig(test, null);
-      }
-      this.loadedTests.push(test.uid);
-      cursor.CR();
-      output.test.skipped(test);
-    });
-
-    runner.on('pass', (test) => {
-      if (showSteps && test.steps) {
-        return output.scenario.passed(test);
-      }
-      cursor.CR();
-      output.test.passed(test);
-    });
-
-    if (showSteps) {
-      runner.on('test', (test) => {
-        currentMetaStep = [];
-        if (test.steps) {
-          output.test.started(test);
-        }
-      });
-
-      if (!codeceptjsEventDispatchersRegistered) {
-        codeceptjsEventDispatchersRegistered = true;
-
-        event.dispatcher.on(event.bddStep.started, (step) => {
-          output.stepShift = 2;
-          output.step(step);
-        });
-
-        event.dispatcher.on(event.step.started, (step) => {
-          let processingStep = step;
-          const metaSteps = [];
-          while (processingStep.metaStep) {
-            metaSteps.unshift(processingStep.metaStep);
-            processingStep = processingStep.metaStep;
-          }
-          const shift = metaSteps.length;
-
-          for (let i = 0; i < Math.max(currentMetaStep.length, metaSteps.length); i++) {
-            if (currentMetaStep[i] !== metaSteps[i]) {
-              output.stepShift = 3 + 2 * i;
-              if (!metaSteps[i]) continue;
-              // bdd steps are handled by bddStep.started
-              if (metaSteps[i].isBDD()) continue;
-              output.step(metaSteps[i]);
-            }
-          }
-          currentMetaStep = metaSteps;
-          output.stepShift = 3 + 2 * shift;
-          if (step.helper.constructor.name !== 'ExpectHelper') {
-            output.step(step);
-          }
-        });
-
-        event.dispatcher.on(event.step.finished, () => {
-          output.stepShift = 0;
-        });
-      }
-    }
-
-    runner.on('suite end', suite => {
-      let skippedCount = 0;
-      const grep = runner._grep;
-      for (const test of suite.tests) {
-        if (!test.state && !this.loadedTests.includes(test.uid)) {
-          if (matchTest(grep, test.title)) {
-            if (!test.opts) {
-              test.opts = {};
-            }
-            if (!test.opts.skipInfo) {
-              test.opts.skipInfo = {};
-            }
-            skipTestConfig(test, 'Skipped due to failure in \'before\' hook');
-            output.test.skipped(test);
-            skippedCount += 1;
-          }
-        }
-      }
-
-      this.stats.pending += skippedCount;
-      this.stats.tests += skippedCount;
-    });
-
-    runner.on('end', this.result.bind(this));
-  }
-
-  result() {
-    const stats = this.stats;
-    stats.failedHooks = 0;
-    console.log();
-
-    // passes
-    if (stats.failures) {
-      output.print(output.styles.bold('-- FAILURES:'));
-    }
-
-    const failuresLog = [];
-
-    // failures
-    if (stats.failures) {
-      // append step traces
-      this.failures.map((test) => {
-        const err = test.err;
-
-        let log = '';
-
-        if (err instanceof AssertionFailedError) {
-          err.message = err.inspect();
-        }
-
-        const steps = test.steps || (test.ctx && test.ctx.test.steps);
-
-        if (steps && steps.length) {
-          let scenarioTrace = '';
-          steps.reverse().forEach((step) => {
-            const line = `- ${step.toCode()} ${step.line()}`;
-            // if (step.status === 'failed') line = '' + line;
-            scenarioTrace += `\n${line}`;
-          });
-          log += `${output.styles.bold('Scenario Steps')}:${scenarioTrace}\n`;
-        }
-
-        // display artifacts in debug mode
-        if (test?.artifacts && Object.keys(test.artifacts).length) {
-          log += `\n${output.styles.bold('Artifacts:')}`;
-          for (const artifact of Object.keys(test.artifacts)) {
-            log += `\n- ${artifact}: ${test.artifacts[artifact]}`;
-          }
-        }
-
-        try {
-          let stack = err.stack ? err.stack.split('\n') : [];
-          if (stack[0] && stack[0].includes(err.message)) {
-            stack.shift();
-          }
-
-          if (output.level() < 3) {
-            stack = stack.slice(0, 3);
-          }
-
-          err.stack = `${stack.join('\n')}\n\n${output.colors.blue(log)}`;
-
-          // clone err object so stack trace adjustments won't affect test other reports
-          test.err = err;
-          return test;
-        } catch (e) {
-          throw Error(e);
-        }
-      });
-
-      const originalLog = Base.consoleLog;
-      Base.consoleLog = (...data) => {
-        failuresLog.push([...data]);
-        originalLog(...data);
-      };
-      Base.list(this.failures);
-      Base.consoleLog = originalLog;
-      console.log();
-    }
-
-    this.failures.forEach((failure) => {
-      if (failure.constructor.name === 'Hook') {
-        stats.failedHooks += 1
-      }
-    })
-    event.emit(event.all.failures, { failuresLog, stats });
-    output.result(stats.passes, stats.failures, stats.pending, ms(stats.duration), stats.failedHooks);
-
-    if (stats.failures && output.level() < 3) {
-      output.print(output.styles.debug('Run with --verbose flag to see complete NodeJS stacktrace'));
-    }
-  }
-}
-
-function matchTest(grep, test) {
-  if (grep) {
-    return grep.test(test);
-  }
-  return true;
-}
-
-function skipTestConfig(test, message) {
-  if (!test.opts) {
-    test.opts = {};
-  }
-  if (!test.opts.skipInfo) {
-    test.opts.skipInfo = {};
-  }
-  test.opts.skipInfo.message = test.opts.skipInfo.message || message;
-  test.opts.skipInfo.isFastSkipped = true;
-  event.emit(event.test.skipped, test);
-  test.state = 'skipped';
-}
-
-module.exports = function (runner, opts) {
-  return new Cli(runner, opts);
-};

package/lib/helper/ExpectHelper.js

@@ -1,391 +0,0 @@
-const output = require('../output')
-
-let expect
-
-import('chai').then((chai) => {
-  expect = chai.expect
-  chai.use(require('chai-string'))
-  // @ts-ignore
-  chai.use(require('chai-exclude'))
-  chai.use(require('chai-match-pattern'))
-  chai.use(require('chai-json-schema'))
-})
-
-/**
- * This helper allows performing assertions based on Chai.
- *
- * ### Examples
- *
- * Zero-configuration when paired with other helpers like REST, Playwright:
- *
- * ```js
- * // inside codecept.conf.js
- *{
- *   helpers: {
- *     Playwright: {...},
- *     ExpectHelper: {},
- *   }
- *}
- * ```
- *
- * ## Methods
- */
-class ExpectHelper {
-  /**
-   *
-   * @param {*} actualValue
-   * @param {*} expectedValue
-   * @param {*} [customErrorMsg]
-   */
-  expectEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to equal "${JSON.stringify(expectedValue)}"`)
-    return expect(actualValue, customErrorMsg).to.equal(expectedValue)
-  }
-
-  /**
-   *
-   * @param {*} actualValue
-   * @param {*} expectedValue
-   * @param {*} [customErrorMsg]
-   */
-  expectNotEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to not equal "${JSON.stringify(expectedValue)}"`)
-    return expect(actualValue, customErrorMsg).not.to.equal(expectedValue)
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-
-     */
-  expectDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to deep equal "${JSON.stringify(expectedValue)}"`)
-    return expect(actualValue, customErrorMsg).to.deep.equal(expectedValue)
-  }
-
-  /**
-   *
-   * @param {*} actualValue
-   * @param {*} expectedValue
-   * @param {*} [customErrorMsg]
-   */
-  expectNotDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to not deep equal "${JSON.stringify(expectedValue)}"`)
-    return expect(actualValue, customErrorMsg).to.not.deep.equal(expectedValue)
-  }
-
-  /**
-   *
-   * @param {*} actualValue
-   * @param {*} expectedValueToContain
-   * @param {*} [customErrorMsg]
-   */
-  expectContain(actualValue, expectedValueToContain, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to contain "${JSON.stringify(expectedValueToContain)}"`)
-    return expect(actualValue, customErrorMsg).to.contain(expectedValueToContain)
-  }
-
-  /**
-   *
-   * @param {*} actualValue
-   * @param {*} expectedValueToNotContain
-   * @param {*} [customErrorMsg]
-   */
-  expectNotContain(actualValue, expectedValueToNotContain, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(
-      `I expect "${JSON.stringify(actualValue)}" to not contain "${JSON.stringify(expectedValueToNotContain)}"`,
-    )
-    return expect(actualValue, customErrorMsg).not.to.contain(expectedValueToNotContain)
-  }
-
-  /**
-   *
-   * @param {*} actualValue
-   * @param {*} expectedValueToStartWith
-   * @param {*} [customErrorMsg]
-   */
-  expectStartsWith(actualValue, expectedValueToStartWith, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to start with "${JSON.stringify(expectedValueToStartWith)}"`)
-    return expect(actualValue, customErrorMsg).to.startsWith(expectedValueToStartWith)
-  }
-
-  /**
-   *
-   * @param {*} actualValue
-   * @param {*} expectedValueToNotStartWith
-   * @param {*} [customErrorMsg]
-   */
-  expectNotStartsWith(actualValue, expectedValueToNotStartWith, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(
-      `I expect "${JSON.stringify(actualValue)}" to not start with "${JSON.stringify(expectedValueToNotStartWith)}"`,
-    )
-    return expect(actualValue, customErrorMsg).not.to.startsWith(expectedValueToNotStartWith)
-  }
-
-  /**
-   * @param {*} actualValue
-   * @param {*} expectedValueToEndWith
-   * @param {*} [customErrorMsg]
-   */
-  expectEndsWith(actualValue, expectedValueToEndWith, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to end with "${JSON.stringify(expectedValueToEndWith)}"`)
-    return expect(actualValue, customErrorMsg).to.endsWith(expectedValueToEndWith)
-  }
-
-  /**
-   * @param {*} actualValue
-   * @param {*} expectedValueToNotEndWith
-   * @param {*} [customErrorMsg]
-   */
-  expectNotEndsWith(actualValue, expectedValueToNotEndWith, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(
-      `I expect "${JSON.stringify(actualValue)}" to not end with "${JSON.stringify(expectedValueToNotEndWith)}"`,
-    )
-    return expect(actualValue, customErrorMsg).not.to.endsWith(expectedValueToNotEndWith)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} jsonSchema
-   * @param {*} [customErrorMsg]
-   */
-  expectJsonSchema(targetData, jsonSchema, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to match this JSON schema "${JSON.stringify(jsonSchema)}"`)
-
-    return expect(targetData, customErrorMsg).to.be.jsonSchema(jsonSchema)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} jsonSchema
-   * @param {*} [customErrorMsg]
-   * @param {*} [ajvOptions] Pass AJV options
-   */
-  expectJsonSchemaUsingAJV(targetData, jsonSchema, customErrorMsg = '', ajvOptions = { allErrors: true }) {
-    // @ts-ignore
-    output.step(
-      `I expect "${JSON.stringify(targetData)}" to match this JSON schema using AJV "${JSON.stringify(jsonSchema)}"`,
-    )
-    chai.use(require('chai-json-schema-ajv').create(ajvOptions))
-    return expect(targetData, customErrorMsg).to.be.jsonSchema(jsonSchema)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} propertyName
-   * @param {*} [customErrorMsg]
-   */
-  expectHasProperty(targetData, propertyName, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to have property: "${JSON.stringify(propertyName)}"`)
-    return expect(targetData, customErrorMsg).to.have.property(propertyName)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} propertyName
-   * @param {*} [customErrorMsg]
-   */
-  expectHasAProperty(targetData, propertyName, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to have a property: "${JSON.stringify(propertyName)}"`)
-    return expect(targetData, customErrorMsg).to.have.a.property(propertyName)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} type
-   * @param {*} [customErrorMsg]
-   */
-  expectToBeA(targetData, type, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be a "${JSON.stringify(type)}"`)
-    return expect(targetData, customErrorMsg).to.be.a(type)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} type
-   * @param {*} [customErrorMsg]
-   */
-  expectToBeAn(targetData, type, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be an "${JSON.stringify(type)}"`)
-    return expect(targetData, customErrorMsg).to.be.an(type)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} regex
-   * @param {*} [customErrorMsg]
-   */
-  expectMatchRegex(targetData, regex, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to match the regex "${JSON.stringify(regex)}"`)
-    return expect(targetData, customErrorMsg).to.match(regex)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} length
-   * @param {*} [customErrorMsg]
-   */
-  expectLengthOf(targetData, length, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to have length of "${JSON.stringify(length)}"`)
-    return expect(targetData, customErrorMsg).to.have.lengthOf(length)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} [customErrorMsg]
-   */
-  expectEmpty(targetData, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be empty`)
-    return expect(targetData, customErrorMsg).to.be.empty
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} [customErrorMsg]
-   */
-  expectTrue(targetData, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be true`)
-    return expect(targetData, customErrorMsg).to.be.true
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} [customErrorMsg]
-   */
-  expectFalse(targetData, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be false`)
-    return expect(targetData, customErrorMsg).to.be.false
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} aboveThan
-   * @param {*} [customErrorMsg]
-   */
-  expectAbove(targetData, aboveThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be above ${JSON.stringify(aboveThan)}`)
-    return expect(targetData, customErrorMsg).to.be.above(aboveThan)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} belowThan
-   * @param {*} [customErrorMsg]
-   */
-  expectBelow(targetData, belowThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be below ${JSON.stringify(belowThan)}`)
-    return expect(targetData, customErrorMsg).to.be.below(belowThan)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} lengthAboveThan
-   * @param {*} [customErrorMsg]
-   */
-  expectLengthAboveThan(targetData, lengthAboveThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to have length of above ${JSON.stringify(lengthAboveThan)}`)
-    return expect(targetData, customErrorMsg).to.have.lengthOf.above(lengthAboveThan)
-  }
-
-  /**
-   * @param {*} targetData
-   * @param {*} lengthBelowThan
-   * @param {*} [customErrorMsg]
-   */
-  expectLengthBelowThan(targetData, lengthBelowThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to have length of below ${JSON.stringify(lengthBelowThan)}`)
-    return expect(targetData, customErrorMsg).to.have.lengthOf.below(lengthBelowThan)
-  }
-
-  /**
-   * @param {*} actualValue
-   * @param {*} expectedValue
-   * @param {*} [customErrorMsg]
-   */
-  expectEqualIgnoreCase(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect and ingore case "${JSON.stringify(actualValue)}" to equal "${JSON.stringify(expectedValue)}"`)
-    return expect(actualValue, customErrorMsg).to.equalIgnoreCase(expectedValue)
-  }
-
-  /**
-   * expects members of two arrays are deeply equal
-   * @param {*} actualValue
-   * @param {*} expectedValue
-   * @param {*} [customErrorMsg]
-   */
-  expectDeepMembers(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(
-      `I expect members of "${JSON.stringify(actualValue)}" and "${JSON.stringify(expectedValue)}" arrays are deeply equal`,
-    )
-    return expect(actualValue, customErrorMsg).to.have.deep.members(expectedValue)
-  }
-
-  /**
-   * expects an array to be a superset of another array
-   * @param {*} superset
-   * @param {*} set
-   * @param {*} [customErrorMsg]
-   */
-  expectDeepIncludeMembers(superset, set, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(superset)}" array to be a superset of "${JSON.stringify(set)}" array`)
-    return expect(superset, customErrorMsg).to.deep.include.members(set)
-  }
-
-  /**
-   * expects members of two JSON objects are deeply equal excluding some properties
-   * @param {*} actualValue
-   * @param {*} expectedValue
-   * @param {*} fieldsToExclude
-   * @param {*} [customErrorMsg]
-   */
-  expectDeepEqualExcluding(actualValue, expectedValue, fieldsToExclude, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(
-      `I expect members of "${JSON.stringify(actualValue)}" and "${JSON.stringify(expectedValue)}" JSON objects are deeply equal excluding properties: ${JSON.stringify(fieldsToExclude)}`,
-    )
-    return expect(actualValue, customErrorMsg).excludingEvery(fieldsToExclude).to.deep.equal(expectedValue)
-  }
-
-  /**
-   * expects a JSON object matches a provided pattern
-   * @param {*} actualValue
-   * @param {*} expectedPattern
-   * @param {*} [customErrorMsg]
-   */
-  expectMatchesPattern(actualValue, expectedPattern, customErrorMsg = '') {
-    // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to match the ${JSON.stringify(expectedPattern)} pattern`)
-    return expect(actualValue, customErrorMsg).to.matchPattern(expectedPattern)
-  }
-}
-
-module.exports = ExpectHelper