codeceptjs 3.6.7 → 4.0.0-beta.1

package/lib/assert/include.js

@@ -1,78 +1,79 @@
-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 * as output from '../output.js';
 
-const MAX_LINES = 10
+const MAX_LINES = 10;
 
 class InclusionAssertion extends Assertion {
   constructor(params) {
-    params.jar = params.jar || 'string'
+    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
-    }
-    super(comparator, params)
-    this.params.type = 'to include'
+      return haystack.indexOf(needle) >= 0;
+    };
+    super(comparator, params);
+    this.params.type = 'to include';
   }
 
   getException() {
-    const params = this.params
-    params.jar = template(params.jar, params)
-    const err = new AssertionFailedError(params, '{{customMessage}}expected {{jar}} {{type}} "{{needle}}"')
-    err.expected = params.needle
-    err.actual = params.haystack
+    const params = this.params;
+    params.jar = template(params.jar, params);
+    const err = new AssertionFailedError(params, '{{customMessage}}expected {{jar}} {{type}} "{{needle}}"');
+    err.expected = params.needle;
+    err.actual = params.haystack;
     if (Array.isArray(this.params.haystack)) {
-      this.params.haystack = this.params.haystack.join('\n___(next element)___\n')
+      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}}'))
-      return template(msg, this.params)
-    }
-    return err
+        .replace('{{jar}}', output.output.colors.bold('{{jar}}'))
+        .replace('{{needle}}', output.output.colors.bold('{{needle}}'));
+      return template(msg, this.params);
+    };
+    return err;
   }
 
   getFailedAssertion() {
-    const err = this.getException()
-    const lines = this.params.haystack.split('\n')
+    const err = this.getException();
+    const lines = this.params.haystack.split('\n');
     if (lines.length > MAX_LINES) {
-      const more = lines.length - MAX_LINES
-      err.actual = `${lines.slice(0, MAX_LINES).join('\n')}\n--( ${more} lines more )---`
+      const more = lines.length - MAX_LINES;
+      err.actual = `${lines.slice(0, MAX_LINES).join('\n')}\n--( ${more} lines more )---`;
     }
-    return err
+    return err;
   }
 
   getFailedNegation() {
-    this.params.type = 'not to include'
-    const err = this.getException()
-    const pattern = new RegExp(`^.*?\n?^.*?\n?^.*?${escapeRegExp(this.params.needle)}.*?$\n?.*$\n?.*$`, 'm')
-    const matched = this.params.haystack.match(pattern)
-    if (!matched) return err
-    err.actual = matched[0].replace(this.params.needle, output.colors.bold(this.params.needle))
-    err.actual = `------\n${err.actual}\n------`
-    return err
+    this.params.type = 'not to include';
+    const err = this.getException();
+    const pattern = new RegExp(`^.*?\n?^.*?\n?^.*?${escapeRegExp(this.params.needle)}.*?$\n?.*$\n?.*$`, 'm');
+    const matched = this.params.haystack.match(pattern);
+    if (!matched) return err;
+    err.actual = matched[0].replace(this.params.needle, output.output.colors.bold(this.params.needle));
+    err.actual = `------\n${err.actual}\n------`;
+    return err;
   }
 
   addAssertParams() {
-    this.params.needle = arguments[0]
-    this.params.haystack = arguments[1]
-    this.params.customMessage = arguments[2] ? `${arguments[2]}\n\n` : ''
+    this.params.needle = arguments[0];
+    this.params.haystack = arguments[1];
+    this.params.customMessage = arguments[2] ? `${arguments[2]}\n\n` : '';
   }
 }
 
-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 function includes(needleType) {
+  needleType = needleType || 'string';
+  return new InclusionAssertion({ jar: needleType });
 }
 
 function escapeRegExp(str) {
-  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&')
+  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+}
+
+export function fileIncludes(file) {
+  return new InclusionAssertion({ file, jar: 'file {{file}}' });
 }

package/lib/assert/throws.js

@@ -1,22 +1,20 @@
 function errorThrown(actual, expected) {
-  if (!expected) return null
-  if (!actual) throw new Error(`Expected ${expected} error to be thrown`)
-  const msg = actual.inspect ? actual.inspect() : actual.toString()
+  if (!expected) return null;
+  if (!actual) throw new Error(`Expected ${expected} error to be thrown`);
+  const msg = actual.inspect ? actual.inspect() : actual.toString();
   if (expected instanceof RegExp) {
-    if (msg.match(expected)) return null
-    throw new Error(`Expected error to be thrown with message matching ${expected} while '${msg}' caught`)
+    if (msg.match(expected)) return null;
+    throw new Error(`Expected error to be thrown with message matching ${expected} while '${msg}' caught`);
   }
   if (typeof expected === 'string') {
-    if (msg === expected) return null
-    throw new Error(`Expected error to be thrown with message ${expected} while '${msg}' caught`)
+    if (msg === expected) return null;
+    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
+  return null;
 }
 
-module.exports = errorThrown
+export default errorThrown;

package/lib/assert/truth.js

@@ -1,36 +1,39 @@
-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 * as output from '../output.js';
 
 class TruthAssertion extends Assertion {
   constructor(params) {
     super((value) => {
       if (Array.isArray(value)) {
-        return value.filter((val) => !!val).length > 0
+        return value.filter(val => !!val).length > 0;
       }
-      return !!value
-    }, params)
-    this.params.type = this.params.type || 'to be true'
+      return !!value;
+    }, params);
+    this.params.type = this.params.type || 'to be true';
   }
 
   getException() {
-    const err = new AssertionFailedError(this.params, '{{customMessage}}expected {{subject}} {{type}}')
+    const err = new AssertionFailedError(this.params, '{{customMessage}}expected {{subject}} {{type}}');
     err.cliMessage = () => {
-      const msg = err.template.replace('{{subject}}', output.colors.bold('{{subject}}'))
-      return template(msg, this.params)
-    }
-    return err
+      const msg = err.template
+        .replace('{{subject}}', output.colors.bold('{{subject}}'));
+      return template(msg, this.params);
+    };
+    return err;
   }
 
   addAssertParams() {
-    this.params.value = this.params.actual = arguments[0]
-    this.params.expected = true
-    this.params.customMessage = arguments[1] ? `${arguments[1]}\n\n` : ''
+    this.params.value = this.params.actual = arguments[0];
+    this.params.expected = true;
+    this.params.customMessage = arguments[1] ? `${arguments[1]}\n\n` : '';
   }
 }
 
-module.exports = {
-  Assertion: TruthAssertion,
-  truth: (subject, type) => new TruthAssertion({ subject, type }),
+export function truth(subject, type) {
+  return new TruthAssertion({ subject, type });
 }
+export default {
+  Assertion: TruthAssertion,
+};

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.
@@ -20,7 +20,7 @@ const AssertionFailedError = require('./assert/error');
  * to get more customizable exception messages.
  *
  */
-class Assertion {
+export default class Assertion {
   constructor(comparator, params) {
     this.comparator = comparator;
     this.params = params || {};
@@ -68,5 +68,3 @@ class Assertion {
     return this.getException();
   }
 }
-
-module.exports = Assertion;

package/lib/cli.js

@@ -1,9 +1,12 @@
-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');
+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 = [];
@@ -18,16 +21,16 @@ class Cli extends Base {
     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}"`);
+    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) {
-      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(', ')}`));
+      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', () => {
@@ -35,7 +38,7 @@ class Cli extends Base {
     });
 
     runner.on('suite', (suite) => {
-      output.suite.started(suite);
+      output.output.suite.started(suite);
     });
 
     runner.on('fail', (test) => {
@@ -43,10 +46,10 @@ class Cli extends Base {
         this.loadedTests.push(test.ctx.currentTest.uid);
       }
       if (showSteps && test.steps) {
-        return output.scenario.failed(test);
+        return output.output.scenario.failed(test);
       }
       cursor.CR();
-      output.test.failed(test);
+      output.output.test.failed(test);
     });
 
     runner.on('pending', (test) => {
@@ -59,22 +62,22 @@ class Cli extends Base {
       }
       this.loadedTests.push(test.uid);
       cursor.CR();
-      output.test.skipped(test);
+      output.output.test.skipped(test);
     });
 
     runner.on('pass', (test) => {
       if (showSteps && test.steps) {
-        return output.scenario.passed(test);
+        return output.output.scenario.passed(test);
       }
       cursor.CR();
-      output.test.passed(test);
+      output.output.test.passed(test);
     });
 
     if (showSteps) {
       runner.on('test', (test) => {
         currentMetaStep = [];
         if (test.steps) {
-          output.test.started(test);
+          output.output.test.started(test);
         }
       });
 
@@ -82,8 +85,8 @@ class Cli extends Base {
         codeceptjsEventDispatchersRegistered = true;
 
         event.dispatcher.on(event.bddStep.started, (step) => {
-          output.stepShift = 2;
-          output.step(step);
+          output.output.stepShift = 2;
+          output.output.step(step);
         });
 
         event.dispatcher.on(event.step.started, (step) => {
@@ -97,22 +100,22 @@ class Cli extends Base {
 
           for (let i = 0; i < Math.max(currentMetaStep.length, metaSteps.length); i++) {
             if (currentMetaStep[i] !== metaSteps[i]) {
-              output.stepShift = 3 + 2 * i;
+              output.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]);
+              output.output.step(metaSteps[i]);
             }
           }
           currentMetaStep = metaSteps;
-          output.stepShift = 3 + 2 * shift;
+          output.output.stepShift = 3 + 2 * shift;
           if (step.helper.constructor.name !== 'ExpectHelper') {
-            output.step(step);
+            output.output.step(step);
           }
         });
 
         event.dispatcher.on(event.step.finished, () => {
-          output.stepShift = 0;
+          output.output.stepShift = 0;
         });
       }
     }
@@ -130,7 +133,7 @@ class Cli extends Base {
               test.opts.skipInfo = {};
             }
             skipTestConfig(test, 'Skipped due to failure in \'before\' hook');
-            output.test.skipped(test);
+            output.output.test.skipped(test);
             skippedCount += 1;
           }
         }
@@ -145,12 +148,11 @@ class Cli extends Base {
 
   result() {
     const stats = this.stats;
-    stats.failedHooks = 0;
     console.log();
 
     // passes
     if (stats.failures) {
-      output.print(output.styles.bold('-- FAILURES:'));
+      output.output.print(output.output.styles.bold('-- FAILURES:'));
     }
 
     const failuresLog = [];
@@ -176,35 +178,31 @@ class Cli extends Base {
             // if (step.status === 'failed') line = '' + line;
             scenarioTrace += `\n${line}`;
           });
-          log += `${output.styles.bold('Scenario Steps')}:${scenarioTrace}\n`;
+          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.styles.bold('Artifacts:')}`;
+          log += `\n${output.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();
-          }
+        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);
-          }
+        if (output.output.level() < 3) {
+          stack = stack.slice(0, 3);
+        }
 
-          err.stack = `${stack.join('\n')}\n\n${output.colors.blue(log)}`;
+        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;
-        } catch (e) {
-          throw Error(e);
-        }
+        // clone err object so stack trace adjustments won't affect test other reports
+        test.err = err;
+        return test;
       });
 
       const originalLog = Base.consoleLog;
@@ -217,17 +215,11 @@ class Cli extends Base {
       console.log();
     }
 
-    this.failures.forEach((failure) => {
-      if (failure.constructor.name === 'Hook') {
-        stats.failures -= stats.failures
-        stats.failedHooks += 1
-      }
-    })
     event.emit(event.all.failures, { failuresLog, stats });
-    output.result(stats.passes, stats.failures, stats.pending, ms(stats.duration), stats.failedHooks);
+    output.output.result(stats.passes, stats.failures, stats.pending, ms(stats.duration));
 
-    if (stats.failures && output.level() < 3) {
-      output.print(output.styles.debug('Run with --verbose flag to see complete NodeJS stacktrace'));
+    if (stats.failures && output.output.level() < 3) {
+      output.output.print(output.output.styles.debug('Run with --verbose flag to see complete NodeJS stacktrace'));
     }
   }
 }
@@ -252,6 +244,6 @@ function skipTestConfig(test, message) {
   test.state = 'skipped';
 }
 
-module.exports = function (runner, opts) {
+export default function cli(runner, opts) {
   return new Cli(runner, opts);
-};
+}