codeceptjs 4.0.0-beta.3 → 4.0.0-beta.5

package/lib/listener/timeout.js

@@ -1,109 +0,0 @@
-const event = require('../event')
-const output = require('../output')
-const recorder = require('../recorder')
-const Config = require('../config')
-const { timeouts } = require('../store')
-const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER
-
-module.exports = function () {
-  let timeout
-  let suiteTimeout = []
-  let currentTest
-  let currentTimeout
-
-  if (!timeouts) {
-    console.log('Timeouts were disabled')
-    return
-  }
-
-  event.dispatcher.on(event.suite.before, (suite) => {
-    suiteTimeout = []
-    let timeoutConfig = Config.get('timeout')
-
-    if (timeoutConfig) {
-      if (!Number.isNaN(+timeoutConfig)) {
-        checkForSeconds(timeoutConfig)
-        suiteTimeout.push(timeoutConfig)
-      }
-
-      if (!Array.isArray(timeoutConfig)) {
-        timeoutConfig = [timeoutConfig]
-      }
-
-      for (const config of timeoutConfig.filter((c) => !!c.Feature)) {
-        if (config.grep) {
-          if (!suite.title.includes(config.grep)) continue
-        }
-        suiteTimeout.push(config.Feature)
-      }
-    }
-
-    if (suite.totalTimeout) suiteTimeout.push(suite.totalTimeout)
-    output.log(`Timeouts: ${suiteTimeout}`)
-  })
-
-  event.dispatcher.on(event.test.before, (test) => {
-    currentTest = test
-    let testTimeout = null
-
-    let timeoutConfig = Config.get('timeout')
-
-    if (typeof timeoutConfig === 'object' || Array.isArray(timeoutConfig)) {
-      if (!Array.isArray(timeoutConfig)) {
-        timeoutConfig = [timeoutConfig]
-      }
-
-      for (const config of timeoutConfig.filter((c) => !!c.Scenario)) {
-        console.log('Test Timeout', config, test.title.includes(config.grep))
-        if (config.grep) {
-          if (!test.title.includes(config.grep)) continue
-        }
-        testTimeout = config.Scenario
-      }
-    }
-
-    timeout = test.totalTimeout || testTimeout || suiteTimeout[suiteTimeout.length - 1]
-    if (!timeout) return
-    currentTimeout = timeout
-    output.debug(`Test Timeout: ${timeout}s`)
-    timeout *= 1000
-  })
-
-  event.dispatcher.on(event.test.passed, (test) => {
-    currentTest = null
-  })
-
-  event.dispatcher.on(event.test.failed, (test) => {
-    currentTest = null
-  })
-
-  event.dispatcher.on(event.step.before, (step) => {
-    if (typeof timeout !== 'number') return
-
-    if (timeout < 0) {
-      step.setTimeout(0.01, TIMEOUT_ORDER.testOrSuite)
-    } else {
-      step.setTimeout(timeout, TIMEOUT_ORDER.testOrSuite)
-    }
-  })
-
-  event.dispatcher.on(event.step.finished, (step) => {
-    if (typeof timeout === 'number' && !Number.isNaN(timeout)) timeout -= step.duration
-
-    if (typeof timeout === 'number' && timeout <= 0 && recorder.isRunning()) {
-      if (currentTest && currentTest.callback) {
-        recorder.reset()
-        // replace mocha timeout with custom timeout
-        currentTest.timeout(0)
-        currentTest.callback(new Error(`Timeout ${currentTimeout}s exceeded (with Before hook)`))
-        currentTest.timedOut = true
-      }
-    }
-  })
-}
-
-function checkForSeconds(timeout) {
-  if (timeout >= 1000) {
-    console.log(`Warning: Timeout was set to ${timeout}secs.\nGlobal timeout should be specified in seconds.`)
-  }
-}

package/lib/mochaFactory.js

@@ -1,113 +0,0 @@
-const Mocha = require('mocha');
-const fsPath = require('path');
-const fs = require('fs');
-const reporter = require('./cli');
-const gherkinParser = require('./interfaces/gherkin');
-const output = require('./output');
-const { genTestId } = require('./utils');
-const ConnectionRefused = require('./helper/errors/ConnectionRefused');
-
-const scenarioUi = fsPath.join(__dirname, './ui.js');
-
-let mocha;
-
-class MochaFactory {
-  static create(config, opts) {
-    mocha = new Mocha(Object.assign(config, opts));
-    output.process(opts.child);
-    mocha.ui(scenarioUi);
-
-    Mocha.Runner.prototype.uncaught = function (err) {
-      if (err) {
-        if (err.toString().indexOf('ECONNREFUSED') >= 0) {
-          err = new ConnectionRefused(err);
-        }
-        output.error(err);
-        output.print(err.stack);
-        process.exit(1);
-      }
-      output.error('Uncaught undefined exception');
-      process.exit(1);
-    };
-
-    mocha.loadFiles = (fn) => {
-      // load features
-      if (mocha.suite.suites.length === 0) {
-        mocha.files
-          .filter(file => file.match(/\.feature$/))
-          .forEach(file => mocha.suite.addSuite(gherkinParser(fs.readFileSync(file, 'utf8'), file)));
-
-        // remove feature files
-        mocha.files = mocha.files.filter(file => !file.match(/\.feature$/));
-
-        Mocha.prototype.loadFiles.call(mocha, fn);
-
-        // add ids for each test and check uniqueness
-        const dupes = [];
-        let missingFeatureInFile = [];
-        const seenTests = [];
-        mocha.suite.eachTest(test => {
-          test.uid = genTestId(test);
-
-          const name = test.fullTitle();
-          if (seenTests.includes(test.uid)) {
-            dupes.push(name);
-          }
-          seenTests.push(test.uid);
-
-          if (name.slice(0, name.indexOf(':')) === '') {
-            missingFeatureInFile.push(test.file);
-          }
-        });
-        if (dupes.length) {
-          // ideally this should be no-op and throw (breaking change)...
-          output.error(`Duplicate test names detected - Feature + Scenario name should be unique:\n${dupes.join('\n')}`);
-        }
-
-        if (missingFeatureInFile.length) {
-          missingFeatureInFile = [...new Set(missingFeatureInFile)];
-          output.error(`Missing Feature section in:\n${missingFeatureInFile.join('\n')}`);
-        }
-      }
-    };
-
-    const presetReporter = opts.reporter || config.reporter;
-    // use standard reporter
-    if (!presetReporter) {
-      mocha.reporter(reporter, opts);
-      return mocha;
-    }
-
-    // load custom reporter with options
-    const reporterOptions = Object.assign(config.reporterOptions || {});
-
-    if (opts.reporterOptions !== undefined) {
-      opts.reporterOptions.split(',').forEach((opt) => {
-        const L = opt.split('=');
-        if (L.length > 2 || L.length === 0) {
-          throw new Error(`invalid reporter option '${opt}'`);
-        } else if (L.length === 2) {
-          reporterOptions[L[0]] = L[1];
-        } else {
-          reporterOptions[L[0]] = true;
-        }
-      });
-    }
-
-    const attributes = Object.getOwnPropertyDescriptor(reporterOptions, 'codeceptjs-cli-reporter');
-    if (reporterOptions['codeceptjs-cli-reporter'] && attributes) {
-      Object.defineProperty(
-        reporterOptions,
-        'codeceptjs/lib/cli',
-        attributes,
-      );
-      delete reporterOptions['codeceptjs-cli-reporter'];
-    }
-
-    // custom reporters
-    mocha.reporter(presetReporter, reporterOptions);
-    return mocha;
-  }
-}
-
-module.exports = MochaFactory;

package/lib/plugin/debugErrors.js

@@ -1,67 +0,0 @@
-const Container = require('../container')
-const recorder = require('../recorder')
-const event = require('../event')
-const supportedHelpers = require('./standardActingHelpers')
-const { scanForErrorMessages } = require('../html')
-const { output } = require('..')
-
-const defaultConfig = {
-  errorClasses: ['error', 'warning', 'alert', 'danger'],
-}
-
-/**
- * Prints errors found in HTML code after each failed test.
- *
- * It scans HTML and searches for elements with error classes.
- * If an element found prints a text from it to console and adds as artifact to the test.
- *
- * Enable this plugin in config:
- *
- * ```js
- * plugins: {
- *  debugErrors: {
- *   enabled: true,
- * }
- * ```
- *
- * Additional config options:
- *
- * * `errorClasses` - list of classes to search for errors (default: `['error', 'warning', 'alert', 'danger']`)
- *
- */
-module.exports = function (config = {}) {
-  const helpers = Container.helpers()
-  let helper
-
-  config = Object.assign(defaultConfig, config)
-
-  for (const helperName of supportedHelpers) {
-    if (Object.keys(helpers).indexOf(helperName) > -1) {
-      helper = helpers[helperName]
-    }
-  }
-
-  if (!helper) return // no helpers for screenshot
-
-  event.dispatcher.on(event.test.failed, (test) => {
-    recorder.add('HTML snapshot failed test', async () => {
-      try {
-        const currentOutputLevel = output.level()
-        output.level(0)
-        const html = await helper.grabHTMLFrom('body')
-        output.level(currentOutputLevel)
-
-        if (!html) return
-
-        const errors = scanForErrorMessages(html, config.errorClasses)
-        if (errors.length) {
-          output.debug('Detected errors in HTML code')
-          errors.forEach((error) => output.debug(error))
-          test.artifacts.errors = errors
-        }
-      } catch (err) {
-        // not really needed
-      }
-    })
-  })
-}

package/lib/scenario.js

@@ -1,224 +0,0 @@
-const promiseRetry = require('promise-retry');
-const event = require('./event');
-const recorder = require('./recorder');
-const assertThrown = require('./assert/throws');
-const { ucfirst, isAsyncFunction } = require('./utils');
-const parser = require('./parser');
-
-const injectHook = function (inject, suite) {
-  try {
-    inject();
-  } catch (err) {
-    recorder.throw(err);
-  }
-  recorder.catch((err) => {
-    event.emit(event.test.failed, suite, err);
-    throw err;
-  });
-  return recorder.promise();
-};
-
-function makeDoneCallableOnce(done) {
-  let called = false;
-  return function (err) {
-    if (called) {
-      return;
-    }
-    called = true;
-    return done(err);
-  };
-}
-/**
- * Wraps test function, injects support objects from container,
- * starts promise chain with recorder, performs before/after hooks
- * through event system.
- */
-module.exports.test = (test) => {
-  const testFn = test.fn;
-  if (!testFn) {
-    return test;
-  }
-
-  test.steps = [];
-  test.timeout(0);
-  test.async = true;
-
-  test.fn = function (done) {
-    const doneFn = makeDoneCallableOnce(done);
-    recorder.errHandler((err) => {
-      recorder.session.start('teardown');
-      recorder.cleanAsyncErr();
-      if (test.throws) {
-        // check that test should actually fail
-        try {
-          assertThrown(err, test.throws);
-          event.emit(event.test.passed, test);
-          event.emit(event.test.finished, test);
-          recorder.add(doneFn);
-          return;
-        } catch (newErr) {
-          err = newErr;
-        }
-      }
-      event.emit(event.test.failed, test, err);
-      event.emit(event.test.finished, test);
-      recorder.add(() => doneFn(err));
-    });
-
-    if (isAsyncFunction(testFn)) {
-      event.emit(event.test.started, test);
-      testFn
-        .call(test, getInjectedArguments(testFn, test))
-        .then(() => {
-          recorder.add('fire test.passed', () => {
-            event.emit(event.test.passed, test);
-            event.emit(event.test.finished, test);
-          });
-          recorder.add('finish test', doneFn);
-        })
-        .catch((err) => {
-          recorder.throw(err);
-        })
-        .finally(() => {
-          recorder.catch();
-        });
-      return;
-    }
-
-    try {
-      event.emit(event.test.started, test);
-      testFn.call(test, getInjectedArguments(testFn, test));
-    } catch (err) {
-      recorder.throw(err);
-    } finally {
-      recorder.add('fire test.passed', () => {
-        event.emit(event.test.passed, test);
-        event.emit(event.test.finished, test);
-      });
-      recorder.add('finish test', doneFn);
-      recorder.catch();
-    }
-  };
-  return test;
-};
-
-/**
- * Injects arguments to function from controller
- */
-module.exports.injected = function (fn, suite, hookName) {
-  return function (done) {
-    const doneFn = makeDoneCallableOnce(done);
-    const errHandler = (err) => {
-      recorder.session.start('teardown');
-      recorder.cleanAsyncErr();
-      event.emit(event.test.failed, suite, err);
-      if (hookName === 'after') event.emit(event.test.after, suite);
-      if (hookName === 'afterSuite') event.emit(event.suite.after, suite);
-      recorder.add(() => doneFn(err));
-    };
-
-    recorder.errHandler((err) => {
-      errHandler(err);
-    });
-
-    if (!fn) throw new Error('fn is not defined');
-
-    event.emit(event.hook.started, suite);
-
-    this.test.body = fn.toString();
-
-    if (!recorder.isRunning()) {
-      recorder.errHandler((err) => {
-        errHandler(err);
-      });
-    }
-
-    const opts = suite.opts || {};
-    const retries = opts[`retry${ucfirst(hookName)}`] || 0;
-
-    promiseRetry(
-      async (retry, number) => {
-        try {
-          recorder.startUnlessRunning();
-          await fn.call(this, getInjectedArguments(fn));
-          await recorder.promise().catch((err) => retry(err));
-        } catch (err) {
-          retry(err);
-        } finally {
-          if (number < retries) {
-            recorder.stop();
-            recorder.start();
-          }
-        }
-      },
-      { retries },
-    )
-      .then(() => {
-        recorder.add('fire hook.passed', () => event.emit(event.hook.passed, suite));
-        recorder.add(`finish ${hookName} hook`, doneFn);
-        recorder.catch();
-      })
-      .catch((e) => {
-        recorder.throw(e);
-        recorder.catch((e) => {
-          const err = recorder.getAsyncErr() === null ? e : recorder.getAsyncErr();
-          errHandler(err);
-        });
-        recorder.add('fire hook.failed', () => event.emit(event.hook.failed, suite, e));
-      });
-  };
-};
-
-/**
- * Starts promise chain, so helpers could enqueue their hooks
- */
-module.exports.setup = function (suite) {
-  return injectHook(() => {
-    recorder.startUnlessRunning();
-    event.emit(event.test.before, suite && suite.ctx && suite.ctx.currentTest);
-  }, suite);
-};
-
-module.exports.teardown = function (suite) {
-  return injectHook(() => {
-    recorder.startUnlessRunning();
-    event.emit(event.test.after, suite && suite.ctx && suite.ctx.currentTest);
-  }, suite);
-};
-
-module.exports.suiteSetup = function (suite) {
-  return injectHook(() => {
-    recorder.startUnlessRunning();
-    event.emit(event.suite.before, suite);
-  }, suite);
-};
-
-module.exports.suiteTeardown = function (suite) {
-  return injectHook(() => {
-    recorder.startUnlessRunning();
-    event.emit(event.suite.after, suite);
-  }, suite);
-};
-
-const getInjectedArguments = (fn, test) => {
-  const container = require('./container');
-  const testArgs = {};
-  const params = parser.getParams(fn) || [];
-  const objects = container.support();
-  for (const key of params) {
-    testArgs[key] = {};
-    if (test && test.inject && test.inject[key]) {
-      // @FIX: need fix got inject
-      testArgs[key] = test.inject[key];
-      continue;
-    }
-    if (!objects[key]) {
-      throw new Error(`Object of type ${key} is not defined in container`);
-    }
-    testArgs[key] = container.support(key);
-  }
-
-  return testArgs;
-};
-
-module.exports.getInjectedArguments = getInjectedArguments;