codeceptjs 4.0.0-beta.1 → 4.0.0-beta.3

package/lib/assert/include.js

@@ -1,79 +1,78 @@
-import Assertion from '../assert.js';
-import AssertionFailedError from './error.js';
-import { template } from '../utils.js';
-import * as output from '../output.js';
+const Assertion = require('../assert')
+const AssertionFailedError = require('./error')
+const { template } = require('../utils')
+const output = require('../output')
 
-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.output.colors.bold('{{jar}}'))
-        .replace('{{needle}}', output.output.colors.bold('{{needle}}'));
-      return template(msg, this.params);
-    };
-    return err;
+        .replace('{{jar}}', output.colors.bold('{{jar}}'))
+        .replace('{{needle}}', 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.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.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` : ''
   }
 }
 
-export { InclusionAssertion as Assertion };
-export function includes(needleType) {
-  needleType = needleType || 'string';
-  return new InclusionAssertion({ jar: needleType });
+module.exports = {
+  Assertion: InclusionAssertion,
+  includes: (needleType) => {
+    needleType = needleType || 'string'
+    return new InclusionAssertion({ jar: needleType })
+  },
+  fileIncludes: (file) => new InclusionAssertion({ file, jar: 'file {{file}}' }),
 }
 
 function escapeRegExp(str) {
-  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
-}
-
-export function fileIncludes(file) {
-  return new InclusionAssertion({ file, jar: 'file {{file}}' });
+  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&')
 }

package/lib/assert/throws.js

@@ -1,20 +1,22 @@
 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
 }
 
-export default errorThrown;
+module.exports = errorThrown

package/lib/assert/truth.js

@@ -1,39 +1,36 @@
-import Assertion from '../assert.js';
-import AssertionFailedError from './error.js';
-import { template } from '../utils.js';
-import * as output from '../output.js';
+const Assertion = require('../assert')
+const AssertionFailedError = require('./error')
+const { template } = require('../utils')
+const output = require('../output')
 
 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` : ''
   }
 }
 
-export function truth(subject, type) {
-  return new TruthAssertion({ subject, type });
-}
-export default {
+module.exports = {
   Assertion: TruthAssertion,
-};
+  truth: (subject, type) => new TruthAssertion({ subject, type }),
+}

package/lib/assert.js

@@ -1,4 +1,4 @@
-import AssertionFailedError from './assert/error.js';
+const AssertionFailedError = require('./assert/error');
 
 /**
  * Abstract assertion class introduced for more verbose and customizable messages.
@@ -20,7 +20,7 @@ import AssertionFailedError from './assert/error.js';
  * to get more customizable exception messages.
  *
  */
-export default class Assertion {
+class Assertion {
   constructor(comparator, params) {
     this.comparator = comparator;
     this.params = params || {};
@@ -68,3 +68,5 @@ export default class Assertion {
     return this.getException();
   }
 }
+
+module.exports = Assertion;

package/lib/cli.js

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