codeceptjs 2.1.3 → 2.2.1

package/lib/helper/testcafe/testControllerHolder.js

@@ -0,0 +1,42 @@
+const testControllerHolder = {
+
+  testController: undefined,
+  captureResolver: undefined,
+  getResolver: undefined,
+
+  capture(t) {
+    testControllerHolder.testController = t;
+
+    if (testControllerHolder.getResolver) {
+      // @ts-ignore
+      testControllerHolder.getResolver(t);
+    }
+
+    return new Promise((resolve) => {
+      // @ts-ignore
+      testControllerHolder.captureResolver = resolve;
+    });
+  },
+
+  free() {
+    testControllerHolder.testController = undefined;
+
+    if (testControllerHolder.captureResolver) {
+      // @ts-ignore
+      testControllerHolder.captureResolver();
+    }
+  },
+
+  get() {
+    return new Promise((resolve) => {
+      if (testControllerHolder.testController) {
+        resolve(testControllerHolder.testController);
+      } else {
+        // @ts-ignore
+        testControllerHolder.getResolver = resolve;
+      }
+    });
+  },
+};
+
+module.exports = testControllerHolder;

package/lib/helper/testcafe/testcafe-utils.js

@@ -0,0 +1,63 @@
+const { ClientFunction } = require('testcafe');
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { getParamNames } = require('../../utils');
+
+const createTestFile = () => {
+  assert(global.output_dir, 'global.output_dir must be set');
+
+  const testFile = path.join(global.output_dir, `${Date.now()}_test.js`);
+  const testControllerHolderDir = __dirname.replace(/\\/g, '/');
+
+  fs.writeFileSync(
+    testFile,
+    `import testControllerHolder from "${testControllerHolderDir}/testControllerHolder.js";\n\n
+    fixture("fixture")\n
+    test\n
+    ("test", testControllerHolder.capture)`,
+  );
+
+  return testFile;
+};
+
+// TODO Better error mapping (actual, expected)
+const mapError = (testcafeError) => {
+  // console.log('TODO map error better', JSON.stringify(testcafeError, null, 2));
+  if (testcafeError.errMsg) {
+    throw new Error(testcafeError.errMsg);
+  }
+  const errorInfo = `${testcafeError.callsite ? JSON.stringify(testcafeError.callsite) : ''} ${testcafeError.apiFnChain || JSON.stringify(testcafeError)}`;
+  throw new Error(`TestCafe Error: ${errorInfo}`);
+};
+
+
+function createClientFunction(func, args) {
+  if (!args || !args.length) {
+    return ClientFunction(func);
+  }
+  const paramNames = getParamNames(func);
+  const dependencies = {};
+  paramNames.forEach((param, i) => dependencies[param] = args[i]);
+
+  return ClientFunction(getFuncBody(func), { dependencies });
+}
+
+function getFuncBody(func) {
+  let fnStr = func.toString();
+  const arrowIndex = fnStr.indexOf('=>');
+  if (arrowIndex >= 0) {
+    fnStr = fnStr.slice(arrowIndex + 2);
+    // eslint-disable-next-line no-new-func
+    // eslint-disable-next-line no-eval
+    return eval(`() => ${fnStr}`);
+  }
+  // TODO: support general functions
+}
+
+module.exports = {
+  createTestFile,
+  mapError,
+  createClientFunction,
+};

package/lib/history.js

@@ -0,0 +1,39 @@
+const fs = require('fs');
+const path = require('path');
+
+const output = require('./output');
+const colors = require('chalk');
+
+/**
+ * REPL history records REPL commands and stores them in
+ * a file (~history) when session ends.
+ */
+class ReplHistory {
+  constructor() {
+    this.commands = [];
+  }
+
+  push(cmd) {
+    this.commands.push(cmd);
+  }
+
+  pop() {
+    this.commands.pop();
+  }
+
+  save() {
+    if (this.commands.length === 0) {
+      return;
+    }
+
+    const historyFile = path.join(global.output_dir, 'cli-history');
+    const commandSnippet = `\n\n<<< Recorded commands on ${new Date()}\n${this.commands.join('\n')}`;
+    fs.appendFileSync(historyFile, commandSnippet);
+
+    output.print(colors.yellow(` Commands have been saved to ${historyFile}`));
+
+    this.commands = [];
+  }
+}
+
+module.exports = new ReplHistory();

package/lib/hooks.js

@@ -1,6 +1,7 @@
 const getParamNames = require('./utils').getParamNames;
 const fsPath = require('path');
 const fileExists = require('./utils').fileExists;
+const output = require('./output');
 
 module.exports = function (hook, done, stage) {
   stage = stage || 'bootstrap';
@@ -39,6 +40,8 @@ function loadCustomHook(module) {
 
 function callSync(callable, done) {
   if (isAsync(callable)) {
+    callAsync(callable, done, hasArguments(callable));
+  } else if (hasArguments(callable)) {
     callable(done);
   } else {
     callable();
@@ -46,7 +49,28 @@ function callSync(callable, done) {
   }
 }
 
-function isAsync(fn) {
+function callAsync(callable, done, hasArgs = false) {
+  let called = new Promise(() => {});
+
+  if (done) {
+    if (hasArgs) called = callable(done);
+    else called = callable().then(() => done());
+  } else {
+    called = callable();
+  }
+
+  called.catch((err) => {
+    output.print('');
+    output.error(err.message);
+    output.print('');
+    output.print(output.colors.grey(err.stack.replace(err.message, '')));
+    process.exit(1);
+  });
+}
+
+const isAsync = fn => fn.constructor.name === 'AsyncFunction';
+
+function hasArguments(fn) {
   const params = getParamNames(fn);
   return params && params.length;
 }

package/lib/interfaces/gherkin.js

@@ -73,7 +73,7 @@ module.exports = (text) => {
           }
           const tags = child.tags.map(t => t.name);
           const title = `${child.name} ${JSON.stringify(current)} ${tags.join(' ')}`.trim();
-          const test = new Test(title, async () => runSteps(exampleSteps));
+          const test = new Test(title, async () => runSteps(addExampleInTable(exampleSteps, current)));
           test.tags = suite.tags.concat(tags);
           suite.addTest(scenario.test(test));
         }
@@ -99,3 +99,19 @@ function transformTable(table) {
   }
   return str;
 }
+function addExampleInTable(exampleSteps, placeholders) {
+  const steps = JSON.parse(JSON.stringify(exampleSteps));
+  for (const placeholder in placeholders) {
+    steps.map((step) => {
+      step = Object.assign({}, step);
+      if (step.argument && step.argument.type === 'DataTable') {
+        for (const id in step.argument.rows) {
+          const cells = step.argument.rows[id].cells;
+          cells.map(c => (c.value = c.value.replace(`<${placeholder}>`, placeholders[placeholder])));
+        }
+      }
+      return step;
+    });
+  }
+  return steps;
+}

package/lib/interfaces/scenarioConfig.js

@@ -58,13 +58,13 @@ class ScenarioConfig {
    * Configures a helper.
    * Helper name can be omitted and values will be applied to first helper.
    */
-  config(helper, obj) {
+  async config(helper, obj) {
     if (!obj) {
       obj = helper;
       helper = 0;
     }
     if (typeof obj === 'function') {
-      obj = obj(this.test);
+      obj = await obj(this.test);
     }
     if (!this.test.config) {
       this.test.config = {};

package/lib/listener/config.js

@@ -1,7 +1,7 @@
 const event = require('../event');
 const container = require('../container');
 const recorder = require('../recorder');
-const { deepMerge, ucfirst } = require('../utils');
+const { deepMerge, deepClone, ucfirst } = require('../utils');
 const { debug } = require('../output');
 /**
  * Enable Helpers to listen to test events
@@ -17,7 +17,7 @@ module.exports = function () {
       function updateHelperConfig(helper, config) {
         const oldConfig = Object.assign({}, helper.options);
         try {
-          helper._setConfig(deepMerge(Object.assign({}, oldConfig), config));
+          helper._setConfig(deepMerge(deepClone(oldConfig), config));
           debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`);
         } catch (err) {
           recorder.throw(err);
@@ -34,7 +34,7 @@ module.exports = function () {
         for (let name in context.config) {
           const config = context.config[name];
           if (name === '0') { // first helper
-            name = Object.keys(helpers);
+            name = Object.keys(helpers)[0];
           }
           const helper = helpers[name];
           updateHelperConfig(helper, config);

package/lib/locator.js

@@ -207,6 +207,9 @@ Locator.clickable = {
     `.//label[contains(normalize-space(string(.)), ${literal})]`,
     `.//input[./@type = 'submit' or ./@type = 'image' or ./@type = 'button'][./@name = ${literal}]`,
     `.//button[./@name = ${literal}]`,
+    `.//*[@aria-label = ${literal}]`,
+    `.//*[@title = ${literal}]`,
+    `.//*[@aria-labelledby = //*[normalize-space(string(.)) = ${literal}]/@id ]`,
   ]),
 
   self: literal => `./self::*[contains(normalize-space(string(.)), ${literal}) or contains(normalize-space(@value), ${literal})]`,
@@ -220,6 +223,9 @@ Locator.field = {
   labelContains: literal => xpathLocator.combine([
     `.//*[self::input | self::textarea | self::select][not(./@type = 'submit' or ./@type = 'image' or ./@type = 'hidden')][(((./@name = ${literal}) or ./@id = //label[contains(normalize-space(string(.)), ${literal})]/@for) or ./@placeholder = ${literal})]`,
     `.//label[contains(normalize-space(string(.)), ${literal})]//.//*[self::input | self::textarea | self::select][not(./@type = 'submit' or ./@type = 'image' or ./@type = 'hidden')]`,
+    `.//*[@aria-label = ${literal}]`,
+    `.//*[@title = ${literal}]`,
+    `.//*[@aria-labelledby = //*[normalize-space(string(.)) = ${literal}]/@id ]`,
   ]),
   byName: literal => `.//*[self::input | self::textarea | self::select][@name = ${literal}]`,
   byText: literal => xpathLocator.combine([

package/lib/pause.js

@@ -1,4 +1,5 @@
 const container = require('./container');
+const history = require('./history');
 const store = require('./store');
 const recorder = require('./recorder');
 const event = require('./event');
@@ -58,18 +59,38 @@ function parseInput(cmd) {
     finish();
     recorder.session.restore();
     rl.close();
+    history.save();
     return nextStep();
   }
   store.debugMode = true;
   try {
     const locate = global.locate; // enable locate in this context
     const I = container.support('I');
-    eval(`I.${cmd}`); // eslint-disable-line no-eval
+
+    const fullCommand = `I.${cmd}`;
+    const result = eval(fullCommand); // eslint-disable-line no-eval
+    result.then((val) => {
+      if (cmd.startsWith('see') || cmd.startsWith('dontSee')) {
+        output.print(output.styles.success('  OK  '), cmd);
+        return;
+      }
+      if (cmd.startsWith('grab')) {
+        output.print(output.styles.debug(val));
+      }
+    }).catch((err) => {
+      if (err.message) output.print(output.styles.error(' ERROR '), err.message);
+    });
+
+    history.push(fullCommand); // add command to history when successful
   } catch (err) {
     output.print(output.styles.error(' ERROR '), err.message);
   }
   recorder.session.catch((err) => {
     const msg = err.cliMessage ? err.cliMessage() : err.message;
+
+    // pop latest command from history because it failed
+    history.pop();
+
     return output.print(output.styles.error(' FAIL '), msg);
   });
   recorder.add('ask for next step', askForStep);

package/lib/plugin/allure.js

@@ -1,6 +1,7 @@
 const event = require('../event');
 const Allure = require('allure-js-commons');
 const logger = require('../output');
+const ansiRegExp = require('../utils').ansiRegExp;
 
 const defaultConfig = {
   outputDir: global.output_dir,
@@ -61,6 +62,12 @@ const defaultConfig = {
  *
  * * `addAttachment(name, buffer, type)` - add an attachment to current test / suite
  * * `addLabel(name, value)` - adds a label to current test
+ * * `severity(value)` - adds severity label
+ * * `epic(value)` - adds epic label
+ * * `feature(value)` - adds feature label
+ * * `story(value)` - adds story label
+ * * `issue(value)` - adds issue label
+ * * `setDescription(description, type)` - sets a description
  *
  */
 module.exports = (config) => {
@@ -77,6 +84,60 @@ module.exports = (config) => {
     reporter.addAttachment(name, buffer, type);
   };
 
+  this.setDescription = (description, type) => {
+    reporter.setDescription(description, type);
+  };
+
+  this.createStep = (name, stepFunc = () => {}) => {
+    let result;
+    let status = 'passed';
+    reporter.startStep(name);
+    try {
+      result = stepFunc(this.arguments);
+    } catch (error) {
+      status = 'broken';
+      throw error;
+    } finally {
+      if (!!result
+          && (typeof result === 'object' || typeof result === 'function')
+          && typeof result.then === 'function'
+      ) {
+        result.then(() => reporter.endStep('passed'), () => reporter.endStep('broken'));
+      } else {
+        reporter.endStep(status);
+      }
+    }
+    return result;
+  };
+
+  this.createAttachment = (name, content, type) => {
+    if (typeof content === 'function') {
+      const attachmentName = name;
+      const buffer = content.apply(this, arguments);
+      return createAttachment(attachmentName, buffer, type);
+    } reporter.addAttachment(name, content, type);
+  };
+
+  this.severity = (severity) => {
+    this.addLabel('severity', severity);
+  };
+
+  this.epic = (epic) => {
+    this.addLabel('epic', epic);
+  };
+
+  this.feature = (feature) => {
+    this.addLabel('feature', feature);
+  };
+
+  this.story = (story) => {
+    this.addLabel('story', story);
+  };
+
+  this.issue = (issue) => {
+    this.addLabel('issue', issue);
+  };
+
   this.addLabel = (name, value) => {
     const currentTest = reporter.getCurrentTest();
     if (currentTest) {
@@ -133,6 +194,8 @@ module.exports = (config) => {
       currentMetaStep.forEach(() => reporter.endStep('failed'));
       currentMetaStep = [];
     }
+
+    err.message = err.message.replace(ansiRegExp(), '');
     reporter.endCase('failed', err);
   });
 

package/lib/plugin/autoLogin.js

@@ -5,6 +5,7 @@ const container = require('../container');
 const store = require('../store');
 const recorder = require('../recorder');
 const debug = require('../output').debug;
+const isAsyncFunction = require('../utils').isAsyncFunction;
 
 const defaultUser = {
   fetch: I => I.grabCookie(),
@@ -136,19 +137,21 @@ const defaultConfig = {
  * },
  * plugins: {
  *    autoLogin: {
- *     admin: {
- *       login: (I) => {
- *          I.amOnPage('/login');
- *          I.fillField('email', 'admin@site.com');
- *          I.fillField('password', '123456');
- *          I.click('Login');
- *       }
- *       check: (I) => {
- *          I.amOnPage('/dashboard');
- *          I.see('Admin', '.navbar');
- *       },
- *       fetch: () => {}, // empty function
- *       restore: () => {}, // empty funciton
+ *      users: {
+ *        admin: {
+ *          login: (I) => {
+ *            I.amOnPage('/login');
+ *            I.fillField('email', 'admin@site.com');
+ *            I.fillField('password', '123456');
+ *            I.click('Login');
+ *          },
+ *          check: (I) => {
+ *            I.amOnPage('/dashboard');
+ *            I.see('Admin', '.navbar');
+ *          },
+ *          fetch: () => {}, // empty function
+ *          restore: () => {}, // empty funciton
+ *        }
  *     }
  *   }
  * }
@@ -176,6 +179,40 @@ const defaultConfig = {
  * }
  * ```
  *
+ * #### Tips: Using async function in the autoLogin
+ *
+ * If you use async functions in the autoLogin plugin, login function should be used with `await` keyword.
+ *
+ * ```js
+ * autoLogin: {
+ *   enabled: true,
+ *   saveToFile: true,
+ *   inject: 'login',
+ *   users: {
+ *     admin: {
+ *       login: async (I) => {  // If you use async function in the autoLogin plugin
+ *          const phrase = await I.grabTextFrom('#phrase')
+ *          I.fillField('username', 'admin'),
+ *          I.fillField('password', 'password')
+ *          I.fillField('phrase', phrase)
+ *       },
+ *       check: (I) => {
+ *          I.amOnPage('/');
+ *          I.see('Admin');
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ```js
+ * Scenario('login', async (I, login) => {
+ *   await login('admin') // you should use `await`
+ * })
+ * ```
+ *
+ *
+ *
 */
 module.exports = function (config) {
   config = Object.assign(defaultConfig, config);
@@ -200,9 +237,16 @@ module.exports = function (config) {
     const userSession = config.users[name];
     const I = container.support('I');
     const cookies = store[`${name}_session`];
+    const shouldAwait = isAsyncFunction(userSession.login)
+      || isAsyncFunction(userSession.restore)
+      || isAsyncFunction(userSession.check);
 
     const loginAndSave = async () => {
-      await userSession.login(I);
+      if (shouldAwait) {
+        await userSession.login(I);
+      } else {
+        userSession.login(I);
+      }
       store.debugMode = true;
       const cookies = await userSession.fetch(I);
       if (config.saveToFile) {
@@ -218,8 +262,13 @@ module.exports = function (config) {
     store.debugMode = true;
 
     recorder.session.start('check login');
-    await userSession.restore(I, cookies);
-    await userSession.check(I);
+    if (shouldAwait) {
+      await userSession.restore(I, cookies);
+      await userSession.check(I);
+    } else {
+      userSession.restore(I, cookies);
+      userSession.check(I);
+    }
     recorder.session.catch((err) => {
       debug(`Failed auto login for ${name} due to ${err}`);
       debug('Logging in again');

package/lib/plugin/puppeteerCoverage.js

@@ -130,7 +130,12 @@ module.exports = function (config) {
               process.cwd(),
               options.coverageDir,
             );
-            fs.mkdirSync(coverageDir, { recursive: true });
+
+            // Checking if coverageDir already exists, if not, create new one
+
+            if (!fs.existsSync(coverageDir)) {
+              fs.mkdirSync(coverageDir, { recursive: true });
+            }
 
             const coveragePath = path.resolve(
               coverageDir,

package/lib/plugin/stepByStepReport.js

@@ -7,7 +7,8 @@ const fs = require('fs');
 const path = require('path');
 const figures = require('figures');
 const colors = require('chalk');
-const { template, clearString, deleteDir } = require('../utils');
+const crypto = require('crypto');
+const { template, deleteDir } = require('../utils');
 
 const supportedHelpers = [
   'WebDriverIO',
@@ -84,13 +85,13 @@ module.exports = function (config) {
   let slides = {};
   let error;
   let savedStep = null;
-  const uuid = Math.floor(new Date().getTime() / 1000);
   const recordedTests = {};
   const pad = '0000';
   const reportDir = config.output ? path.resolve(global.codecept_dir, config.output) : defaultConfig.output;
 
   event.dispatcher.on(event.test.before, (test) => {
-    dir = path.join(reportDir, `record_${clearString(test.title).substring(0, 20)}_${uuid}`);
+    const md5hash = crypto.createHash('md5').update(test.file + test.title).digest('hex');
+    dir = path.join(reportDir, `record_${md5hash}`);
     mkdirp.sync(dir);
     stepNum = 0;
     error = null;

package/lib/scenario.js

@@ -95,21 +95,32 @@ module.exports.test = (test) => {
  */
 module.exports.injected = function (fn, suite, hookName) {
   return function (done) {
-    recorder.errHandler((err) => {
+    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(() => done(err));
+    };
+
+    recorder.errHandler((err) => {
+      errHandler(err);
     });
 
     if (!fn) throw new Error('fn is not defined');
 
+    event.emit(event.hook.started, suite);
+    if (!recorder.isRunning()) {
+      recorder.start();
+      recorder.errHandler((err) => {
+        errHandler(err);
+      });
+    }
+
+    this.test.body = fn.toString();
+
     if (isAsyncFunction(fn)) {
-      event.emit(event.hook.started, suite);
-      recorder.startUnlessRunning();
-      this.test.body = fn.toString();
       fn.apply(this, getInjectedArguments(fn)).then(() => {
         recorder.add('fire hook.passed', () => event.emit(event.hook.passed, suite));
         recorder.add(`finish ${hookName} hook`, () => done());
@@ -118,28 +129,23 @@ module.exports.injected = function (fn, suite, hookName) {
         recorder.throw(e);
         recorder.catch((e) => {
           const err = (recorder.getAsyncErr() === null) ? e : recorder.getAsyncErr();
-          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(() => done(err));
+          errHandler(err);
         });
       });
       return;
     }
 
     try {
-      event.emit(event.hook.started, suite);
-      recorder.startUnlessRunning();
-      this.test.body = fn.toString();
-      const res = fn.apply(this, getInjectedArguments(fn));
-    } catch (err) {
-      recorder.throw(err);
-    } finally {
+      fn.apply(this, getInjectedArguments(fn));
       recorder.add('fire hook.passed', () => event.emit(event.hook.passed, suite));
       recorder.add(`finish ${hookName} hook`, () => done());
       recorder.catch();
+    } catch (err) {
+      recorder.throw(err);
+      recorder.catch((e) => {
+        const err = (recorder.getAsyncErr() === null) ? e : recorder.getAsyncErr();
+        errHandler(err);
+      });
     }
   };
 };

package/lib/step.js

@@ -154,8 +154,11 @@ function detectMetaStep(stack) {
     if (isTest(line) || isBDD(line)) break;
     const fnName = line.match(/^at (\w+)\.(\w+)\s\(/);
     if (!fnName) continue;
-    if (fnName[1] === 'Generator') return; // don't track meta steps inside generators
-    if (fnName[1] === 'recorder') return; // don't track meta steps inside generators
+    if (fnName[1] === 'Generator'
+      || fnName[1] === 'recorder'
+      || fnName[1] === 'Runner'
+    ) { return; } // don't track meta steps inside generators
+
     if (fnName[1] === 'Object') {
       // detect PO name from includes
       for (const name in support) {

package/lib/ui.js

@@ -138,7 +138,7 @@ module.exports = function (suite) {
      * Pending test case.
      */
     context.xScenario = context.Scenario.skip = function (title) {
-      context.Scenario(title, {});
+      return context.Scenario(title, {});
     };
 
     addDataContext(context);