codeceptjs 4.0.0-beta.1 → 4.0.0-beta.11.esm-aria

package/lib/cli.js

@@ -1,249 +0,0 @@
-import mocha from 'mocha';
-import ms from 'ms';
-import * as event from './event.js';
-import * as output from './output.js';
-import AssertionFailedError from './assert/error.js';
-import * as Codecept from './codecept.js';
-import container from './container.js';
-
-const { reporters: { Base } } = mocha;
-
-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.output.level(level);
-    const version = Codecept.version();
-    output.output.print(`CodeceptJS v${version} ${output.output.standWithUkraine()}`);
-    output.output.print(`Using test root "${global.codecept_dir}"`);
-
-    const showSteps = level >= 1;
-
-    if (level >= 2) {
-      output.output.print(output.output.styles.debug(`Helpers: ${Object.keys(container.helpers()).join(', ')}`));
-      output.output.print(output.output.styles.debug(`Plugins: ${Object.keys(container.plugins()).join(', ')}`));
-    }
-
-    runner.on('start', () => {
-      console.log();
-    });
-
-    runner.on('suite', (suite) => {
-      output.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.output.scenario.failed(test);
-      }
-      cursor.CR();
-      output.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.output.test.skipped(test);
-    });
-
-    runner.on('pass', (test) => {
-      if (showSteps && test.steps) {
-        return output.output.scenario.passed(test);
-      }
-      cursor.CR();
-      output.output.test.passed(test);
-    });
-
-    if (showSteps) {
-      runner.on('test', (test) => {
-        currentMetaStep = [];
-        if (test.steps) {
-          output.output.test.started(test);
-        }
-      });
-
-      if (!codeceptjsEventDispatchersRegistered) {
-        codeceptjsEventDispatchersRegistered = true;
-
-        event.dispatcher.on(event.bddStep.started, (step) => {
-          output.output.stepShift = 2;
-          output.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.output.stepShift = 3 + 2 * i;
-              if (!metaSteps[i]) continue;
-              // bdd steps are handled by bddStep.started
-              if (metaSteps[i].isBDD()) continue;
-              output.output.step(metaSteps[i]);
-            }
-          }
-          currentMetaStep = metaSteps;
-          output.output.stepShift = 3 + 2 * shift;
-          if (step.helper.constructor.name !== 'ExpectHelper') {
-            output.output.step(step);
-          }
-        });
-
-        event.dispatcher.on(event.step.finished, () => {
-          output.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.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;
-    console.log();
-
-    // passes
-    if (stats.failures) {
-      output.output.print(output.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.output.styles.bold('Scenario Steps')}:${scenarioTrace}\n`;
-        }
-
-        // display artifacts in debug mode
-        if (test?.artifacts && Object.keys(test.artifacts).length) {
-          log += `\n${output.output.styles.bold('Artifacts:')}`;
-          for (const artifact of Object.keys(test.artifacts)) {
-            log += `\n- ${artifact}: ${test.artifacts[artifact]}`;
-          }
-        }
-
-        let stack = err.stack ? err.stack.split('\n') : [];
-        if (stack[0] && stack[0].includes(err.message)) {
-          stack.shift();
-        }
-
-        if (output.output.level() < 3) {
-          stack = stack.slice(0, 3);
-        }
-
-        err.stack = `${stack.join('\n')}\n\n${output.output.colors.blue(log)}`;
-
-        // clone err object so stack trace adjustments won't affect test other reports
-        test.err = err;
-        return test;
-      });
-
-      const originalLog = Base.consoleLog;
-      Base.consoleLog = (...data) => {
-        failuresLog.push([...data]);
-        originalLog(...data);
-      };
-      Base.list(this.failures);
-      Base.consoleLog = originalLog;
-      console.log();
-    }
-
-    event.emit(event.all.failures, { failuresLog, stats });
-    output.output.result(stats.passes, stats.failures, stats.pending, ms(stats.duration));
-
-    if (stats.failures && output.output.level() < 3) {
-      output.output.print(output.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';
-}
-
-export default function cli(runner, opts) {
-  return new Cli(runner, opts);
-}

package/lib/dirname.js

@@ -1,5 +0,0 @@
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-export const __dirname = dirname(__filename);

package/lib/helper/Expect.js

@@ -1,425 +0,0 @@
-import * as chai from 'chai';
-import chai_json_schema from 'chai-json-schema';
-import chai_match_pattern from 'chai-match-pattern';
-import chai_exclude from 'chai-exclude';
-import chai_string from 'chai-string';
-import * as output from '../output.js';
-
-chai.use(chai_string);
-// @ts-ignore
-chai.use(chai_exclude);
-chai.use(chai_match_pattern);
-chai.use(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: {...},
- *     Expect: {},
- *   }
- *}
- * ```
- *
- * ## Methods
- */
-class ExpectHelper {
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
-  expectEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to equal "${JSON.stringify(expectedValue)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.equal(expectedValue);
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
-  expectNotEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to not equal "${JSON.stringify(expectedValue)}"`);
-    return chai.expect(actualValue, customErrorMsg).not.to.equal(expectedValue);
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-
-     */
-  expectDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to deep equal "${JSON.stringify(expectedValue)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.deep.equal(expectedValue);
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
-  expectNotDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to not deep equal "${JSON.stringify(expectedValue)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.not.deep.equal(expectedValue);
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToContain
-     * @param {*} [customErrorMsg]
-     */
-  expectContain(actualValue, expectedValueToContain, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to contain "${JSON.stringify(expectedValueToContain)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.contain(
-      expectedValueToContain,
-    );
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToNotContain
-     * @param {*} [customErrorMsg]
-     */
-  expectNotContain(
-    actualValue,
-    expectedValueToNotContain,
-    customErrorMsg = '',
-  ) {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to not contain "${JSON.stringify(expectedValueToNotContain)}"`);
-    return chai.expect(actualValue, customErrorMsg).not.to.contain(
-      expectedValueToNotContain,
-    );
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToStartWith
-     * @param {*} [customErrorMsg]
-     */
-  expectStartsWith(actualValue, expectedValueToStartWith, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to start with "${JSON.stringify(expectedValueToStartWith)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.startsWith(
-      expectedValueToStartWith,
-    );
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToNotStartWith
-     * @param {*} [customErrorMsg]
-     */
-  expectNotStartsWith(
-    actualValue,
-    expectedValueToNotStartWith,
-    customErrorMsg = '',
-  ) {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to not start with "${JSON.stringify(expectedValueToNotStartWith)}"`);
-    return chai.expect(actualValue, customErrorMsg).not.to.startsWith(
-      expectedValueToNotStartWith,
-    );
-  }
-
-  /**
-     * @param {*} actualValue
-     * @param {*} expectedValueToEndWith
-     * @param {*} [customErrorMsg]
-     */
-  expectEndsWith(actualValue, expectedValueToEndWith, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to end with "${JSON.stringify(expectedValueToEndWith)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.endsWith(
-      expectedValueToEndWith,
-    );
-  }
-
-  /**
-     * @param {*} actualValue
-     * @param {*} expectedValueToNotEndWith
-     * @param {*} [customErrorMsg]
-     */
-  expectNotEndsWith(
-    actualValue,
-    expectedValueToNotEndWith,
-    customErrorMsg = '',
-  ) {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to not end with "${JSON.stringify(expectedValueToNotEndWith)}"`);
-    return chai.expect(actualValue, customErrorMsg).not.to.endsWith(
-      expectedValueToNotEndWith,
-    );
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} jsonSchema
-     * @param {*} [customErrorMsg]
-     */
-  expectJsonSchema(targetData, jsonSchema, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to match this JSON schema "${JSON.stringify(jsonSchema)}"`);
-
-    return chai.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.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 chai.expect(targetData, customErrorMsg).to.be.jsonSchema(jsonSchema);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} propertyName
-     * @param {*} [customErrorMsg]
-     */
-  expectHasProperty(targetData, propertyName, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to have property: "${JSON.stringify(propertyName)}"`);
-    return chai.expect(targetData, customErrorMsg).to.have.property(propertyName);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} propertyName
-     * @param {*} [customErrorMsg]
-     */
-  expectHasAProperty(targetData, propertyName, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to have a property: "${JSON.stringify(propertyName)}"`);
-    return chai.expect(targetData, customErrorMsg).to.have.a.property(propertyName);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} type
-     * @param {*} [customErrorMsg]
-     */
-  expectToBeA(targetData, type, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be a "${JSON.stringify(type)}"`);
-    return chai.expect(targetData, customErrorMsg).to.be.a(type);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} type
-     * @param {*} [customErrorMsg]
-     */
-  expectToBeAn(targetData, type, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be an "${JSON.stringify(type)}"`);
-    return chai.expect(targetData, customErrorMsg).to.be.an(type);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} regex
-     * @param {*} [customErrorMsg]
-     */
-  expectMatchRegex(targetData, regex, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to match the regex "${JSON.stringify(regex)}"`);
-    return chai.expect(targetData, customErrorMsg).to.match(regex);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} length
-     * @param {*} [customErrorMsg]
-     */
-  expectLengthOf(targetData, length, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to have length of "${JSON.stringify(length)}"`);
-    return chai.expect(targetData, customErrorMsg).to.have.lengthOf(length);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} [customErrorMsg]
-     */
-  expectEmpty(targetData, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be empty`);
-    return chai.expect(targetData, customErrorMsg).to.be.empty;
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} [customErrorMsg]
-     */
-  expectTrue(targetData, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be true`);
-    return chai.expect(targetData, customErrorMsg).to.be.true;
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} [customErrorMsg]
-     */
-  expectFalse(targetData, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be false`);
-    return chai.expect(targetData, customErrorMsg).to.be.false;
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} aboveThan
-     * @param {*} [customErrorMsg]
-     */
-  expectAbove(targetData, aboveThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be above ${JSON.stringify(aboveThan)}`);
-    return chai.expect(targetData, customErrorMsg).to.be.above(aboveThan);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} belowThan
-     * @param {*} [customErrorMsg]
-     */
-  expectBelow(targetData, belowThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be below ${JSON.stringify(belowThan)}`);
-    return chai.expect(targetData, customErrorMsg).to.be.below(belowThan);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} lengthAboveThan
-     * @param {*} [customErrorMsg]
-     */
-  expectLengthAboveThan(targetData, lengthAboveThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to have length of above ${JSON.stringify(lengthAboveThan)}`);
-    return chai.expect(targetData, customErrorMsg).to.have.lengthOf.above(
-      lengthAboveThan,
-    );
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} lengthBelowThan
-     * @param {*} [customErrorMsg]
-     */
-  expectLengthBelowThan(targetData, lengthBelowThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to have length of below ${JSON.stringify(lengthBelowThan)}`);
-    return chai.expect(targetData, customErrorMsg).to.have.lengthOf.below(
-      lengthBelowThan,
-    );
-  }
-
-  /**
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
-  expectEqualIgnoreCase(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect and ingore case "${JSON.stringify(actualValue)}" to equal "${JSON.stringify(expectedValue)}"`);
-    return chai.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.output.step(`I expect members of "${JSON.stringify(actualValue)}" and "${JSON.stringify(expectedValue)}" arrays are deeply equal`);
-    return chai.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.output.step(`I expect "${JSON.stringify(superset)}" array to be a superset of "${JSON.stringify(set)}" array`);
-    return chai.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.output.step(`I expect members of "${JSON.stringify(actualValue)}" and "${JSON.stringify(expectedValue)}" JSON objects are deeply equal excluding properties: ${JSON.stringify(fieldsToExclude)}`);
-    return chai.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.output.step(`I expect "${JSON.stringify(actualValue)}" to match the ${JSON.stringify(expectedPattern)} pattern`);
-    return chai.expect(actualValue, customErrorMsg).to.matchPattern(expectedPattern);
-  }
-}
-
-export default ExpectHelper;