codeceptjs 3.4.1 → 3.5.1

package/lib/pause.js

@@ -1,9 +1,12 @@
 const colors = require('chalk');
 const readline = require('readline');
+const ora = require('ora-classic');
+const debug = require('debug')('codeceptjs:pause');
 
 const container = require('./container');
 const history = require('./history');
 const store = require('./store');
+const AiAssistant = require('./ai');
 const recorder = require('./recorder');
 const event = require('./event');
 const output = require('./output');
@@ -15,6 +18,8 @@ let nextStep;
 let finish;
 let next;
 let registeredVariables = {};
+const aiAssistant = new AiAssistant();
+
 /**
  * Pauses test execution and starts interactive shell
  */
@@ -45,6 +50,14 @@ function pauseSession(passedObject = {}) {
     output.print(colors.yellow(` - Press ${colors.bold('TAB')} twice to see all available commands`));
     output.print(colors.yellow(` - Type ${colors.bold('exit')} + Enter to exit the interactive shell`));
     output.print(colors.yellow(` - Prefix ${colors.bold('=>')} to run js commands ${colors.bold(vars)}`));
+
+    if (aiAssistant.isEnabled) {
+      output.print(colors.blue(` ${colors.bold('OpenAI is enabled! (experimental)')} Write what you want and make OpenAI run it`));
+      output.print(colors.blue(' Please note, only HTML fragments with interactive elements are sent to OpenAI'));
+      output.print(colors.blue(' Ideas: ask it to fill forms for you or to click'));
+    } else {
+      output.print(colors.blue(` Enable OpenAI assistant by setting ${colors.bold('OPENAI_API_KEY')} env variable`));
+    }
   }
   rl = readline.createInterface(process.stdin, process.stdout, completer);
 
@@ -59,9 +72,10 @@ function pauseSession(passedObject = {}) {
 }
 
 /* eslint-disable */
-function parseInput(cmd) {
+async function parseInput(cmd) {
   rl.pause();
   next = false;
+  recorder.session.start('pause');
   store.debugMode = false;
   if (cmd === '') next = true;
   if (!cmd || cmd === 'resume' || cmd === 'exit') {
@@ -74,37 +88,78 @@ function parseInput(cmd) {
   for (const k of Object.keys(registeredVariables)) {
     eval(`var ${k} = registeredVariables['${k}'];`); // eslint-disable-line no-eval
   }
+
+  let executeCommand = Promise.resolve();
+
+  const getCmd = () => {
+    debug('Command:', cmd)
+    return cmd;
+  };
+
   store.debugMode = true;
   let isCustomCommand = false;
   let lastError = null;
+  let isAiCommand = false;
+  let $res;
   try {
     const locate = global.locate; // enable locate in this context
     const I = container.support('I');
     if (cmd.trim().startsWith('=>')) {
       isCustomCommand = true;
       cmd = cmd.trim().substring(2, cmd.length);
+    } else if (aiAssistant.isEnabled && !cmd.match(/^\w+\(/) && cmd.includes(' ')) {
+      const currentOutputLevel = output.level();
+      output.level(0);
+      const res = I.grabSource();
+      isAiCommand = true;
+      executeCommand = executeCommand.then(async () => {
+        try {
+          const html = await res; 
+          aiAssistant.setHtmlContext(html);
+        } catch (err) {
+          output.print(output.styles.error(' ERROR '), 'Can\'t get HTML context', err.stack);
+          return;
+        } finally {
+          output.level(currentOutputLevel);          
+        }
+        // aiAssistant.mockResponse("```js\nI.click('Sign in');\n```");
+        const spinner = ora("Processing OpenAI request...").start();
+        cmd = await aiAssistant.writeSteps(cmd);
+        spinner.stop();
+        output.print('');
+        output.print(colors.blue(aiAssistant.getResponse()));
+        output.print('');
+        return cmd;
+      })
     } else {
       cmd = `I.${cmd}`;
     }
-    const executeCommand = eval(cmd); // eslint-disable-line no-eval
-
-    const result = executeCommand instanceof Promise ? executeCommand : Promise.resolve(executeCommand);
-    result.then((val) => {
-      if (isCustomCommand) {
-        console.log(val);
-        return;
-      }
-      if (cmd.startsWith('I.see') || cmd.startsWith('I.dontSee')) {
-        output.print(output.styles.success('  OK  '), cmd);
-        return;
-      }
-      if (cmd.startsWith('I.grab')) {
-        output.print(output.styles.debug(val));
-      }
+    executeCommand = executeCommand.then(async () => {
+      const cmd = getCmd();
+      if (!cmd) return;
+      return eval(cmd); // eslint-disable-line no-eval
     }).catch((err) => {
+      debug(err);
+      if (isAiCommand) return;
       if (!lastError) output.print(output.styles.error(' ERROR '), err.message);
+      debug(err.stack)
+
       lastError = err.message;
-    });
+    })
+
+    const val = await executeCommand;
+    
+    if (isCustomCommand) {
+      if (val !== undefined) console.log('Result', '$res=', val); // eslint-disable-line
+      $res = val;
+    }
+    
+    if (cmd?.startsWith('I.see') || cmd?.startsWith('I.dontSee')) {
+      output.print(output.styles.success('  OK  '), cmd);
+    }
+    if (cmd?.startsWith('I.grab')) {
+      output.print(output.styles.debug(val));
+    }
 
     history.push(cmd); // add command to history when successful
   } catch (err) {
@@ -117,6 +172,7 @@ function parseInput(cmd) {
     // pop latest command from history because it failed
     history.pop();
 
+    if (isAiCommand) return;
     if (!lastError) output.print(output.styles.error(' FAIL '), msg);
     lastError = err.message;
   });

package/lib/plugin/debugErrors.js

@@ -0,0 +1,67 @@
+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/plugin/fakerTransform.js

@@ -2,20 +2,18 @@ const { faker } = require('@faker-js/faker');
 const transform = require('../transform');
 
 /**
- * Use the [faker.js](https://www.npmjs.com/package/faker) package to generate fake data inside examples on your gherkin tests
- *
- * ![Faker.js](https://raw.githubusercontent.com/Marak/faker.js/master/logo.png)
+ * Use the `@faker-js/faker` package to generate fake data inside examples on your gherkin tests
  *
  * #### Usage
  *
- * To start please install `faker.js` package
+ * To start please install `@faker-js/faker` package
  *
  * ```
- * npm install -D faker
+ * npm install -D @faker-js/faker
  * ```
  *
  * ```
- * yarn add -D faker
+ * yarn add -D @faker-js/faker
  * ```
  *
  * Add this plugin to config file:

package/lib/plugin/heal.js

@@ -0,0 +1,177 @@
+const debug = require('debug')('codeceptjs:heal');
+const colors = require('chalk');
+const Container = require('../container');
+const AiAssistant = require('../ai');
+const recorder = require('../recorder');
+const event = require('../event');
+const output = require('../output');
+const supportedHelpers = require('./standardActingHelpers');
+
+const defaultConfig = {
+  healLimit: 2,
+  healSteps: [
+    'click',
+    'fillField',
+    'appendField',
+    'selectOption',
+    'attachFile',
+    'checkOption',
+    'uncheckOption',
+    'doubleClick',
+  ],
+};
+
+/**
+ * Self-healing tests with OpenAI.
+ *
+ * This plugin is experimental and requires OpenAI API key.
+ *
+ * To use it you need to set OPENAI_API_KEY env variable and enable plugin inside the config.
+ *
+ * ```js
+ * plugins: {
+ *   heal: {
+ *    enabled: true,
+ *   }
+ * }
+ * ```
+ *
+ * More config options are available:
+ *
+ * * `healLimit` - how many steps can be healed in a single test (default: 2)
+ * * `healSteps` - which steps can be healed (default: all steps that interact with UI, see list below)
+ *
+ * Steps to heal:
+ *
+ * * `click`
+ * * `fillField`
+ * * `appendField`
+ * * `selectOption`
+ * * `attachFile`
+ * * `checkOption`
+ * * `uncheckOption`
+ * * `doubleClick`
+ *
+ */
+module.exports = function (config = {}) {
+  const aiAssistant = new AiAssistant();
+
+  let currentTest = null;
+  let currentStep = null;
+  let healedSteps = 0;
+
+  const healSuggestions = [];
+
+  config = Object.assign(defaultConfig, config);
+
+  event.dispatcher.on(event.test.before, (test) => {
+    currentTest = test;
+    healedSteps = 0;
+  });
+
+  event.dispatcher.on(event.step.started, step => currentStep = step);
+
+  event.dispatcher.on(event.step.before, () => {
+    const store = require('../store');
+    if (store.debugMode) return;
+
+    recorder.catchWithoutStop(async (err) => {
+      if (!aiAssistant.isEnabled) throw err;
+      if (!currentStep) throw err;
+      if (!config.healSteps.includes(currentStep.name)) throw err;
+      const test = currentTest;
+
+      if (healedSteps >= config.healLimit) {
+        output.print(colors.bold.red(`Can't heal more than ${config.healLimit} step(s) in a test`));
+        output.print('Entire flow can be broken, please check it manually');
+        output.print('or increase healing limit in heal plugin config');
+
+        throw err;
+      }
+
+      recorder.session.start('heal');
+      const helpers = Container.helpers();
+      let helper;
+
+      for (const helperName of supportedHelpers) {
+        if (Object.keys(helpers).indexOf(helperName) > -1) {
+          helper = helpers[helperName];
+        }
+      }
+
+      if (!helper) throw err; // no helpers for html
+
+      const step = test.steps[test.steps.length - 1];
+      debug('Self-healing started', step.toCode());
+
+      const currentOutputLevel = output.level();
+      output.level(0);
+      const html = await helper.grabHTMLFrom('body');
+      output.level(currentOutputLevel);
+
+      if (!html) throw err;
+
+      aiAssistant.setHtmlContext(html);
+      await tryToHeal(step, err);
+      recorder.session.restore();
+    });
+  });
+
+  event.dispatcher.on(event.all.result, () => {
+    if (!healSuggestions.length) return;
+
+    const { print } = output;
+
+    print('');
+    print('===================');
+    print(colors.bold.green('Self-Healing Report:'));
+
+    print(`${colors.bold(healSuggestions.length)} step(s) were healed by AI`);
+
+    let i = 1;
+    print('');
+    print('Suggested changes:');
+    print('');
+
+    for (const suggestion of healSuggestions) {
+      print(`${i}. To fix ${colors.bold.blue(suggestion.test.title)}`);
+      print('Replace the failed code with:');
+      print(colors.red(`- ${suggestion.step.toCode()}`));
+      print(colors.green(`+ ${suggestion.snippet}`));
+      print(suggestion.step.line());
+      print('');
+      i++;
+    }
+  });
+
+  async function tryToHeal(failedStep, err) {
+    output.debug(`Running OpenAI to heal ${failedStep.toCode()} step`);
+
+    const codeSnippets = await aiAssistant.healFailedStep(
+      failedStep, err, currentTest,
+    );
+
+    output.debug(`Received ${codeSnippets.length} suggestions from OpenAI`);
+
+    for (const codeSnippet of codeSnippets) {
+      try {
+        debug('Executing', codeSnippet);
+        await eval(codeSnippet); // eslint-disable-line
+
+        healSuggestions.push({
+          test: currentTest,
+          step: failedStep,
+          snippet: codeSnippet,
+        });
+
+        output.print(colors.bold.green('  Code healed successfully'));
+        healedSteps++;
+        return;
+      } catch (err) {
+        debug('Failed to execute code', err);
+      }
+    }
+
+    output.debug(`Couldn't heal the code for ${failedStep.toCode()}`);
+  }
+};

package/lib/plugin/screenshotOnFail.js

@@ -75,7 +75,8 @@ module.exports = function (config) {
   event.dispatcher.on(event.test.failed, (test) => {
     recorder.add('screenshot of failed test', async () => {
       let fileName = clearString(test.title);
-      // This prevent data driven to be included in the failed screenshot file name
+      const dataType = 'image/png';
+      // This prevents data driven to be included in the failed screenshot file name
       if (fileName.indexOf('{') !== -1) {
         fileName = fileName.substr(0, (fileName.indexOf('{') - 3)).trim();
       }
@@ -106,7 +107,15 @@ module.exports = function (config) {
 
         const allureReporter = Container.plugins('allure');
         if (allureReporter) {
-          allureReporter.addAttachment('Last Seen Screenshot', fs.readFileSync(path.join(global.output_dir, fileName)), 'image/png');
+          allureReporter.addAttachment('Main session - Last Seen Screenshot', fs.readFileSync(path.join(global.output_dir, fileName)), dataType);
+
+          if (helper.activeSessionName) {
+            for (const sessionName in helper.sessionPages) {
+              const screenshotFileName = `${sessionName}_${fileName}`;
+              test.artifacts[`${sessionName.replace(/ /g, '_')}_screenshot`] = path.join(global.output_dir, screenshotFileName);
+              allureReporter.addAttachment(`${sessionName} - Last Seen Screenshot`, fs.readFileSync(path.join(global.output_dir, screenshotFileName)), dataType);
+            }
+          }
         }
 
         const cucumberReporter = Container.plugins('cucumberJsonReporter');

package/lib/recorder.js

@@ -1,6 +1,6 @@
 const debug = require('debug')('codeceptjs:recorder');
 const promiseRetry = require('promise-retry');
-
+const { printObjectProperties } = require('./utils');
 const { log } = require('./output');
 
 const MAX_TASKS = 100;
@@ -41,6 +41,7 @@ module.exports = {
    * @inner
    */
   start() {
+    debug('Starting recording promises');
     running = true;
     asyncErr = null;
     errFn = null;
@@ -161,7 +162,7 @@ module.exports = {
    *     true: it will retries if `retryOpts` set.
    *     false: ignore `retryOpts` and won't retry.
    * @param {number} [timeout]
-   * @return {Promise<*> | undefined}
+   * @return {Promise<*>}
    * @inner
    */
   add(taskName, fn = undefined, force = false, retry = undefined, timeout = undefined) {
@@ -175,7 +176,7 @@ module.exports = {
       return;
     }
     tasks.push(taskName);
-    if (process.env.DEBUG) debug(`${currentQueue()}Queued | ${taskName}`);
+    debug(`${currentQueue()}Queued | ${taskName}`);
 
     return promise = Promise.resolve(promise).then((res) => {
       // prefer options for non-conditional retries
@@ -224,10 +225,11 @@ module.exports = {
    * @inner
    */
   catch(customErrFn) {
+    debug(`${currentQueue()}Queued | catch with error handler`);
     return promise = promise.catch((err) => {
       log(`${currentQueue()}Error | ${err}`);
       if (!(err instanceof Error)) { // strange things may happen
-        err = new Error(`[Wrapped Error] ${JSON.stringify(err)}`); // we should be prepared for them
+        err = new Error(`[Wrapped Error] ${printObjectProperties(err)}`); // we should be prepared for them
       }
       if (customErrFn) {
         customErrFn(err);
@@ -250,9 +252,9 @@ module.exports = {
         err = new Error(`[Wrapped Error] ${JSON.stringify(err)}`); // we should be prepared for them
       }
       if (customErrFn) {
-        customErrFn(err);
-      } else if (errFn) {
-        errFn(err);
+        return customErrFn(err);
+      } if (errFn) {
+        return errFn(err);
       }
     });
   },
@@ -264,8 +266,9 @@ module.exports = {
    * @param {*} err
    * @inner
    */
+
   throw(err) {
-    return this.add(`throw error ${err}`, () => {
+    return this.add(`throw error: ${err.message}`, () => {
       throw err;
     });
   },

package/lib/secret.js

@@ -1,6 +1,8 @@
 /* eslint-disable max-classes-per-file */
 const { deepClone } = require('./utils');
 
+const maskedString = '*****';
+
 /** @param {string} secret */
 class Secret {
   constructor(secret) {
@@ -13,7 +15,7 @@ class Secret {
   }
 
   getMasked() {
-    return '*****';
+    return maskedString;
   }
 
   /**
@@ -36,12 +38,11 @@ function secretObject(obj, fieldsToHide = []) {
       if (prop === 'toString') {
         return function () {
           const maskedObject = deepClone(obj);
-          fieldsToHide.forEach(f => maskedObject[f] = '****');
+          fieldsToHide.forEach(f => maskedObject[f] = maskedString);
           return JSON.stringify(maskedObject);
         };
       }
-
-      return obj[prop];
+      return fieldsToHide.includes(prop) ? new Secret(obj[prop]) : obj[prop];
     },
   };
 

package/lib/step.js

@@ -172,7 +172,12 @@ class Step {
       } else if (arg.toString && arg.toString() !== '[object Object]') {
         return arg.toString();
       } else if (typeof arg === 'object') {
-        return JSON.stringify(arg);
+        const returnedArg = {};
+        for (const [key, value] of Object.entries(arg)) {
+          returnedArg[key] = value;
+          if (value instanceof Secret) returnedArg[key] = value.getMasked();
+        }
+        return JSON.stringify(returnedArg);
       }
       return arg;
     }).join(', ');

package/lib/ui.js

@@ -23,10 +23,11 @@ const setContextTranslation = (context) => {
 /**
  * Codecept-style interface:
  *
- * Feature('login')
- * Scenario('login as regular user', (I) {
+ * Feature('login');
+ *
+ * Scenario('login as regular user', ({I}) {
  *   I.fillField();
- *   I.click()
+ *   I.click();
  *   I.see('Hello, '+data.login);
  * });
  *

package/lib/utils.js

@@ -455,3 +455,20 @@ module.exports.isNotSet = function (obj) {
   if (obj === undefined) return true;
   return false;
 };
+
+module.exports.emptyFolder = async (directoryPath) => {
+  require('child_process').execSync(`rm -rf ${directoryPath}/*`);
+};
+
+module.exports.printObjectProperties = (obj) => {
+  if (typeof obj !== 'object' || obj === null) {
+    return obj;
+  }
+
+  let result = '';
+  for (const [key, value] of Object.entries(obj)) {
+    result += `${key}: "${value}"; `;
+  }
+
+  return `{${result}}`;
+};