codeceptjs 3.6.4-beta.2 → 3.6.5-beta.1

package/lib/listener/timeout.js

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

package/lib/pause.js

@@ -56,7 +56,15 @@ function pauseSession(passedObject = {}) {
       output.print(colors.blue(' Ideas: ask it to fill forms for you or to click'));
     }
   }
-  rl = readline.createInterface(process.stdin, process.stdout, completer);
+
+  rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+    completer,
+    history: history.load(),
+    historySize: 50, // Adjust the history size as needed
+  });
 
   rl.on('line', parseInput);
   rl.on('close', () => {
@@ -105,7 +113,7 @@ async function parseInput(cmd) {
     if (cmd.trim().startsWith('=>')) {
       isCustomCommand = true;
       cmd = cmd.trim().substring(2, cmd.length);
-    } else if (aiAssistant.isEnabled && !cmd.match(/^\w+\(/) && cmd.includes(' ')) {
+    } else if (aiAssistant.isEnabled && cmd.trim() && !cmd.match(/^\w+\(/) && cmd.includes(' ')) {
       const currentOutputLevel = output.level();
       output.level(0);
       const res = I.grabSource();
@@ -121,7 +129,7 @@ async function parseInput(cmd) {
           output.level(currentOutputLevel);
         }
 
-        const spinner = ora("Processing OpenAI request...").start();
+        const spinner = ora("Processing AI request...").start();
         cmd = await aiAssistant.writeSteps(cmd);
         spinner.stop();
         output.print('');
@@ -200,4 +208,10 @@ function completer(line) {
   return [hits && hits.length ? hits : completions, line];
 }
 
+function registerVariable(name, value) {
+  registeredVariables[name] = value;
+}
+
 module.exports = pause;
+
+module.exports.registerVariable = registerVariable;

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();
-};
+  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,24 +1,17 @@
-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();
+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()
 
-const methodsToDelay = [
-  'click',
-  'fillField',
-  'checkOption',
-  'pressKey',
-  'doubleClick',
-  'rightClick',
-];
+const methodsToDelay = ['click', 'fillField', 'checkOption', 'pressKey', 'doubleClick', 'rightClick']
 
 const defaultConfig = {
   methods: methodsToDelay,
   delayBefore: 100,
   delayAfter: 200,
-};
+}
 
 /**
  *
@@ -59,41 +52,41 @@ const defaultConfig = {
  *
  */
 module.exports = function (config) {
-  supportedHelpers.push('REST');
-  const helpers = Container.helpers();
-  let helper;
+  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,25 @@
-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;
+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
 
 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,88 +249,92 @@ const defaultConfig = {
  * })
  *
  *
-*/
+ */
 module.exports = function (config) {
-  config = Object.assign(defaultConfig, config);
-  Object.keys(config.users).map(u => config.users[u] = {
-    ...defaultUser,
-    ...config.users[u],
-  });
+  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');
+const event = require('../event')
+const recorder = require('../recorder')
+const { MetaStep } = require('../step')
 
-let currentCommentStep;
+let currentCommentStep
 
-const defaultGlobalName = '__';
+const defaultGlobalName = '__'
 
 /**
  * Add descriptive nested steps for your tests:
@@ -101,36 +101,36 @@ const defaultGlobalName = '__';
  */
 module.exports = function (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), '')
+  })
 }