codeceptjs 3.6.6 → 4.0.0-beta.1

package/lib/output.js

@@ -1,5 +1,5 @@
-const colors = require('chalk');
-const figures = require('figures');
+import colors from 'chalk';
+import figures from 'figures';
 
 const styles = {
   error: colors.bgRed.white.bold,
@@ -19,7 +19,7 @@ let newline = true;
  * @alias output
  * @namespace
  */
-module.exports = {
+export const output = {
   colors,
   styles,
   print,
@@ -62,6 +62,10 @@ module.exports = {
     }
   },
 
+  debugSection(section, msg) {
+    this.debug(`[${section}] ${msg}`);
+  },
+
   /**
    * Print information in --verbose mode
    * @param {string} msg
@@ -113,7 +117,7 @@ module.exports = {
 
     let stepLine = step.toString();
     if (step.metaStep && outputLevel >= 1) {
-      // this.stepShift += 2;
+      this.stepShift += 2;
       stepLine = colors.green(truncate(stepLine, this.spaceShift));
     }
     if (step.comment) {
@@ -167,7 +171,7 @@ module.exports = {
   scenario: {
     /**
      * @param {Mocha.Test} test
-    */
+     */
     /* eslint-disable */
     started(test) {},
     /* eslint-enable */
@@ -232,7 +236,7 @@ module.exports = {
   },
 };
 
-function print(...msg) {
+export function print(...msg) {
   if (outputProcess) {
     msg.unshift(outputProcess);
   }

package/lib/parser.js

@@ -1,21 +1,20 @@
-function _interopDefault(ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex.default : ex; }
-const acorn = require('acorn');
-const parser = _interopDefault(require('parse-function'))({ parse: acorn.parse, ecmaVersion: 11, plugins: ['objectRestSpread'] });
-const { error } = require('./output');
+import { parse as acornParse } from 'acorn';
+import parseFunction from 'parse-function';
+import * as output from './output.js';
 
-parser.use(destructuredArgs);
-
-module.exports.getParamsToString = function (fn) {
+const app = parseFunction({ parse: acornParse, ecmaVersion: 11, plugins: ['objectRestSpread'] });
+app.use(destructuredArgs);
+export function getParamsToString(fn) {
   const newFn = fn.toString().replace(/^async/, 'async function');
   return getParams(newFn).join(', ');
-};
+}
 
-function getParams(fn) {
+export function getParams(fn) {
   if (fn.isSinonProxy) return [];
   try {
-    const reflected = parser.parse(fn);
+    const reflected = app.parse(fn);
     if (reflected.args.length > 1 || reflected.args[0] === 'I') {
-      error('Error: old CodeceptJS v2 format detected. Upgrade your project to the new format -> https://bit.ly/codecept3Up');
+      output.output.error('Error: old CodeceptJS v2 format detected. Upgrade your project to the new format -> https://bit.ly/codecept3Up');
     }
     if (reflected.destructuredArgs.length > 0) reflected.args = [...reflected.destructuredArgs];
     const params = reflected.args.map((p) => {
@@ -28,13 +27,11 @@ function getParams(fn) {
     return params;
   } catch (err) {
     console.log(`Error in ${fn.toString()}`);
-    error(err);
+    output.output.error(err);
   }
 }
 
-module.exports.getParams = getParams;
-
-function destructuredArgs() {
+export function destructuredArgs() {
   return (node, result) => {
     result.destructuredArgs = result.destructuredArgs || [];
 

package/lib/pause.js

@@ -1,16 +1,18 @@
-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');
-const { methodsOfObject } = require('./utils');
+import colors from 'chalk';
+import readline from 'readline';
+import ora from 'ora-classic';
+import debug from 'debug';
+
+import container from './container.js';
+import history from './history.js';
+import { store } from './store.js';
+import AiAssistant from './ai.js';
+import recorder from './recorder.js';
+import * as event from './event.js';
+import * as output from './output.js';
+import { methodsOfObject } from './utils.js';
+
+debug('codeceptjs:pause');
 
 // npm install colors
 let rl;
@@ -18,6 +20,7 @@ let nextStep;
 let finish;
 let next;
 let registeredVariables = {};
+let aiAssistant;
 /**
  * Pauses test execution and starts interactive shell
  * @param {Object<string, *>} [passedObject]
@@ -43,6 +46,8 @@ function pauseSession(passedObject = {}) {
     let vars = Object.keys(registeredVariables).join(', ');
     if (vars) vars = `(vars: ${vars})`;
 
+    aiAssistant = AiAssistant.getInstance();
+
     output.print(colors.yellow(' Interactive shell started'));
     output.print(colors.yellow(' Use JavaScript syntax to try steps in action'));
     output.print(colors.yellow(` - Press ${colors.bold('ENTER')} to run the next step`));
@@ -51,20 +56,14 @@ function pauseSession(passedObject = {}) {
     output.print(colors.yellow(` - Prefix ${colors.bold('=>')} to run js commands ${colors.bold(vars)}`));
 
     if (aiAssistant.isEnabled) {
-      output.print(colors.blue(` ${colors.bold('AI is enabled! (experimental)')} Write what you want and make AI run it`));
-      output.print(colors.blue(' Please note, only HTML fragments with interactive elements are sent to AI provider'));
+      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({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: true,
-    completer,
-    history: history.load(),
-    historySize: 50, // Adjust the history size as needed
-  });
+  rl = readline.createInterface(process.stdin, process.stdout, completer);
 
   rl.on('line', parseInput);
   rl.on('close', () => {
@@ -113,7 +112,7 @@ async function parseInput(cmd) {
     if (cmd.trim().startsWith('=>')) {
       isCustomCommand = true;
       cmd = cmd.trim().substring(2, cmd.length);
-    } else if (aiAssistant.isEnabled && cmd.trim() && !cmd.match(/^\w+\(/) && cmd.includes(' ')) {
+    } else if (aiAssistant.isEnabled && !cmd.match(/^\w+\(/) && cmd.includes(' ')) {
       const currentOutputLevel = output.level();
       output.level(0);
       const res = I.grabSource();
@@ -123,13 +122,13 @@ async function parseInput(cmd) {
           const html = await res;
           await aiAssistant.setHtmlContext(html);
         } catch (err) {
-          output.print(output.styles.error(' ERROR '), 'Can\'t get HTML context', err.stack);
+          output.print(output.output.styles.error(' ERROR '), 'Can\'t get HTML context', err.stack);
           return;
         } finally {
           output.level(currentOutputLevel);
         }
-
-        const spinner = ora("Processing AI request...").start();
+        // aiAssistant.mockResponse("```js\nI.click('Sign in');\n```");
+        const spinner = ora("Processing OpenAI request...").start();
         cmd = await aiAssistant.writeSteps(cmd);
         spinner.stop();
         output.print('');
@@ -147,7 +146,7 @@ async function parseInput(cmd) {
     }).catch((err) => {
       debug(err);
       if (isAiCommand) return;
-      if (!lastError) output.print(output.styles.error(' ERROR '), err.message);
+      if (!lastError) output.print(output.output.styles.error(' ERROR '), err.message);
       debug(err.stack)
 
       lastError = err.message;
@@ -161,15 +160,15 @@ async function parseInput(cmd) {
     }
 
     if (cmd?.startsWith('I.see') || cmd?.startsWith('I.dontSee')) {
-      output.print(output.styles.success('  OK  '), cmd);
+      output.print(output.output.styles.success('  OK  '), cmd);
     }
     if (cmd?.startsWith('I.grab')) {
-      output.print(output.styles.debug(val));
+      output.print(output.output.styles.debug(val));
     }
 
     history.push(cmd); // add command to history when successful
   } catch (err) {
-    if (!lastError) output.print(output.styles.error(' ERROR '), err.message);
+    if (!lastError) output.print(output.output.styles.error(' ERROR '), err.message);
     lastError = err.message;
   }
   recorder.session.catch((err) => {
@@ -179,7 +178,7 @@ async function parseInput(cmd) {
     history.pop();
 
     if (isAiCommand) return;
-    if (!lastError) output.print(output.styles.error(' FAIL '), msg);
+    if (!lastError) output.print(output.output.styles.error(' FAIL '), msg);
     lastError = err.message;
   });
   recorder.add('ask for next step', askForStep);
@@ -208,10 +207,4 @@ function completer(line) {
   return [hits && hits.length ? hits : completions, line];
 }
 
-function registerVariable(name, value) {
-  registeredVariables[name] = value;
-}
-
-module.exports = pause;
-
-module.exports.registerVariable = registerVariable;
+export default pause;

package/lib/plugin/allure.js

@@ -1,15 +1,15 @@
-module.exports = () => {
-  console.log('Allure plugin was moved to @codeceptjs/allure-legacy. Please install it and update your config')
-  console.log()
-  console.log('npm install @codeceptjs/allure-legacy --save-dev')
-  console.log()
-  console.log('Then update your config to use it:')
-  console.log()
-  console.log('plugins: {')
-  console.log('  allure: {')
-  console.log('    enabled: true,')
-  console.log("    require: '@codeceptjs/allure-legacy',")
-  console.log('  }')
-  console.log('}')
-  console.log()
-}
+export default () => {
+  console.log('Allure plugin was moved to @codeceptjs/allure-legacy. Please install it and update your config');
+  console.log();
+  console.log('npm install @codeceptjs/allure-legacy --save-dev');
+  console.log();
+  console.log('Then update your config to use it:');
+  console.log();
+  console.log('plugins: {');
+  console.log('  allure: {');
+  console.log('    enabled: true,');
+  console.log('    require: \'@codeceptjs/allure-legacy\',');
+  console.log('  }');
+  console.log('}');
+  console.log();
+};

package/lib/plugin/autoDelay.js

@@ -1,17 +1,25 @@
-const Container = require('../container')
-const store = require('../store')
-const recorder = require('../recorder')
-const event = require('../event')
-const log = require('../output').log
-const supportedHelpers = require('./standardActingHelpers').slice()
+import Container from '../container.js';
+import { store } from '../store.js';
+import recorder from '../recorder.js';
+import * as event from '../event.js';
+import { log } from '../output.js';
 
-const methodsToDelay = ['click', 'fillField', 'checkOption', 'pressKey', 'doubleClick', 'rightClick']
+const supportedHelpers = require('./standardActingHelpers.js').slice();
+
+const methodsToDelay = [
+  'click',
+  'fillField',
+  'checkOption',
+  'pressKey',
+  'doubleClick',
+  'rightClick',
+];
 
 const defaultConfig = {
   methods: methodsToDelay,
   delayBefore: 100,
   delayAfter: 200,
-}
+};
 
 /**
  *
@@ -51,42 +59,42 @@ const defaultConfig = {
  * * `delayAfter`: put a delay after a command. 200ms by default
  *
  */
-module.exports = function (config) {
-  supportedHelpers.push('REST')
-  const helpers = Container.helpers()
-  let helper
+export default function (config) {
+  supportedHelpers.push('REST');
+  const helpers = Container.helpers();
+  let helper;
 
-  config = Object.assign(defaultConfig, config)
+  config = Object.assign(defaultConfig, config);
 
   for (const helperName of supportedHelpers) {
     if (Object.keys(helpers).indexOf(helperName) > -1) {
-      helper = helpers[helperName]
+      helper = helpers[helperName];
     }
   }
 
-  if (!helper) return // no helpers for auto-delay
+  if (!helper) return; // no helpers for auto-delay
 
   event.dispatcher.on(event.step.before, (step) => {
-    if (config.methods.indexOf(step.helperMethod) < 0) return // skip non-actions
+    if (config.methods.indexOf(step.helperMethod) < 0) return; // skip non-actions
 
     recorder.add('auto-delay', async () => {
-      if (store.debugMode) return // no need to delay in debug
-      log(`Delaying for ${config.delayBefore}ms`)
+      if (store.debugMode) return; // no need to delay in debug
+      log(`Delaying for ${config.delayBefore}ms`);
       return new Promise((resolve) => {
-        setTimeout(resolve, config.delayBefore)
-      })
-    })
-  })
+        setTimeout(resolve, config.delayBefore);
+      });
+    });
+  });
 
   event.dispatcher.on(event.step.after, (step) => {
-    if (config.methods.indexOf(step.helperMethod) < 0) return // skip non-actions
+    if (config.methods.indexOf(step.helperMethod) < 0) return; // skip non-actions
 
     recorder.add('auto-delay', async () => {
-      if (store.debugMode) return // no need to delay in debug
-      log(`Delaying for ${config.delayAfter}ms`)
+      if (store.debugMode) return; // no need to delay in debug
+      log(`Delaying for ${config.delayAfter}ms`);
       return new Promise((resolve) => {
-        setTimeout(resolve, config.delayAfter)
-      })
-    })
-  })
+        setTimeout(resolve, config.delayAfter);
+      });
+    });
+  });
 }

package/lib/plugin/autoLogin.js

@@ -1,25 +1,24 @@
-const fs = require('fs')
-const path = require('path')
-const { fileExists } = require('../utils')
-const container = require('../container')
-const store = require('../store')
-const recorder = require('../recorder')
-const { debug } = require('../output')
-const isAsyncFunction = require('../utils').isAsyncFunction
+import fs from 'fs';
+import path from 'path';
+import { fileExists, isAsyncFunction } from '../utils.js';
+import container from '../container.js';
+import { store } from '../store.js';
+import recorder from '../recorder.js';
+import { debug } from '../output.js';
 
 const defaultUser = {
-  fetch: (I) => I.grabCookie(),
+  fetch: I => I.grabCookie(),
   check: () => {},
   restore: (I, cookies) => {
-    I.amOnPage('/') // open a page
-    I.setCookie(cookies)
+    I.amOnPage('/'); // open a page
+    I.setCookie(cookies);
   },
-}
+};
 
 const defaultConfig = {
   saveToFile: false,
   inject: 'login',
-}
+};
 
 /**
  * Logs user in for the first test and reuses session for next tests.
@@ -249,92 +248,88 @@ const defaultConfig = {
  * })
  *
  *
- */
-module.exports = function (config) {
-  config = Object.assign(defaultConfig, config)
-  Object.keys(config.users).map(
-    (u) =>
-      (config.users[u] = {
-        ...defaultUser,
-        ...config.users[u],
-      }),
-  )
+*/
+export default function (config) {
+  config = Object.assign(defaultConfig, config);
+  Object.keys(config.users).map(u => config.users[u] = {
+    ...defaultUser,
+    ...config.users[u],
+  });
 
   if (config.saveToFile) {
     // loading from file
     for (const name in config.users) {
-      const fileName = path.join(global.output_dir, `${name}_session.json`)
-      if (!fileExists(fileName)) continue
-      const data = fs.readFileSync(fileName).toString()
+      const fileName = path.join(global.output_dir, `${name}_session.json`);
+      if (!fileExists(fileName)) continue;
+      const data = fs.readFileSync(fileName).toString();
       try {
-        store[`${name}_session`] = JSON.parse(data)
+        store[`${name}_session`] = JSON.parse(data);
       } catch (err) {
-        throw new Error(`Could not load session from ${fileName}\n${err}`)
+        throw new Error(`Could not load session from ${fileName}\n${err}`);
       }
-      debug(`Loaded user session for ${name}`)
+      debug(`Loaded user session for ${name}`);
     }
   }
 
   const loginFunction = async (name) => {
-    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 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 () => {
       if (shouldAwait) {
-        await userSession.login(I)
+        await userSession.login(I);
       } else {
-        userSession.login(I)
+        userSession.login(I);
       }
 
-      const cookies = await userSession.fetch(I)
+      const cookies = await userSession.fetch(I);
       if (!cookies) {
-        debug("Cannot save user session with empty cookies from auto login's fetch method")
-        return
+        debug('Cannot save user session with empty cookies from auto login\'s fetch method');
+        return;
       }
       if (config.saveToFile) {
-        debug(`Saved user session into file for ${name}`)
-        fs.writeFileSync(path.join(global.output_dir, `${name}_session.json`), JSON.stringify(cookies))
+        debug(`Saved user session into file for ${name}`);
+        fs.writeFileSync(path.join(global.output_dir, `${name}_session.json`), JSON.stringify(cookies));
       }
-      store[`${name}_session`] = cookies
-    }
+      store[`${name}_session`] = cookies;
+    };
 
-    if (!cookies) return loginAndSave()
+    if (!cookies) return loginAndSave();
 
-    recorder.session.start('check login')
+    recorder.session.start('check login');
     if (shouldAwait) {
-      await userSession.restore(I, cookies)
-      await userSession.check(I, cookies)
+      await userSession.restore(I, cookies);
+      await userSession.check(I, cookies);
     } else {
-      userSession.restore(I, cookies)
-      userSession.check(I, cookies)
+      userSession.restore(I, cookies);
+      userSession.check(I, cookies);
     }
     recorder.session.catch((err) => {
-      debug(`Failed auto login for ${name} due to ${err}`)
-      debug('Logging in again')
-      recorder.session.start('auto login')
-      return loginAndSave()
-        .then(() => {
-          recorder.add(() => recorder.session.restore('auto login'))
-          recorder.catch(() => debug('continue'))
-        })
-        .catch((err) => {
-          recorder.session.restore('auto login')
-          recorder.session.restore('check login')
-          recorder.throw(err)
-        })
-    })
+      debug(`Failed auto login for ${name} due to ${err}`);
+      debug('Logging in again');
+      recorder.session.start('auto login');
+      return loginAndSave().then(() => {
+        recorder.add(() => recorder.session.restore('auto login'));
+        recorder.catch(() => debug('continue'));
+      }).catch((err) => {
+        recorder.session.restore('auto login');
+        recorder.session.restore('check login');
+        recorder.throw(err);
+      });
+    });
     recorder.add(() => {
-      recorder.session.restore('check login')
-    })
+      recorder.session.restore('check login');
+    });
 
-    return recorder.promise()
-  }
+    return recorder.promise();
+  };
 
   // adding this to DI container
-  const support = {}
-  support[config.inject] = loginFunction
-  container.append({ support })
+  const support = {};
+  support[config.inject] = loginFunction;
+  container.append({ support });
 }

package/lib/plugin/commentStep.js

@@ -1,10 +1,10 @@
-const event = require('../event')
-const recorder = require('../recorder')
-const { MetaStep } = require('../step')
+import * as event from '../event.js';
+import recorder from '../recorder.js';
+import { MetaStep } from '../step.js';
 
-let currentCommentStep
+let currentCommentStep;
 
-const defaultGlobalName = '__'
+const defaultGlobalName = '__';
 
 /**
  * Add descriptive nested steps for your tests:
@@ -99,38 +99,38 @@ const defaultGlobalName = '__'
  * });
  * ```
  */
-module.exports = function (config) {
+export default function commentStep(config) {
   event.dispatcher.on(event.test.started, () => {
-    currentCommentStep = null
-  })
+    currentCommentStep = null;
+  });
 
   event.dispatcher.on(event.step.started, (step) => {
     if (currentCommentStep) {
-      const metaStep = getRootMetaStep(step)
+      const metaStep = getRootMetaStep(step);
 
       if (metaStep !== currentCommentStep) {
-        metaStep.metaStep = currentCommentStep
+        metaStep.metaStep = currentCommentStep;
       }
     }
-  })
+  });
 
   if (config.registerGlobal) {
     if (config.registerGlobal === true) {
-      config.registerGlobal = defaultGlobalName
+      config.registerGlobal = defaultGlobalName;
     }
-    global[config.registerGlobal] = setCommentString
+    global[config.registerGlobal] = setCommentString;
   }
 
-  return setCommentString
+  return setCommentString;
 }
 
 function getRootMetaStep(step) {
-  if (step.metaStep) return getRootMetaStep(step.metaStep)
-  return step
+  if (step.metaStep) return getRootMetaStep(step.metaStep);
+  return step;
 }
 
 function setCommentString(string) {
   recorder.add('set comment metastep', () => {
-    currentCommentStep = new MetaStep(String.raw(string), '')
-  })
+    currentCommentStep = new MetaStep(String.raw(string), '');
+  });
 }