codeceptjs 3.6.7 → 4.0.0-beta.1

package/lib/plugin/heal.js

@@ -1,14 +1,19 @@
-const debug = require('debug')('codeceptjs:heal')
-const colors = require('chalk')
-const recorder = require('../recorder')
-const event = require('../event')
-const output = require('../output')
-const heal = require('../heal')
-const store = require('../store')
+import debug from 'debug';
+import colors from 'chalk';
+import Container from '../container.js';
+import AiAssistant from '../ai.js';
+import recorder from '../recorder.js';
+import * as event from '../event.js';
+import * as output from '../output.js';
+import supportedHelpers from './standardActingHelpers.js';
+
+debug('codeceptjs:heal');
+const heal = require('../heal');
+const store = require('../store');
 
 const defaultConfig = {
   healLimit: 2,
-}
+};
 
 /**
  * Self-healing tests with AI.
@@ -28,94 +33,130 @@ const defaultConfig = {
  * * `healLimit` - how many steps can be healed in a single test (default: 2)
  *
  */
-module.exports = function (config = {}) {
-  if (store.debugMode && !process.env.DEBUG) {
+
+export default function (config = {}) {
+  if (store.store.debugMode && !process.env.DEBUG) {
     event.dispatcher.on(event.test.failed, () => {
-      output.plugin(
-        'heal',
-        'Healing is disabled in --debug mode, use DEBUG="codeceptjs:heal" to enable it in debug mode',
-      )
-    })
-    return
+      output.output.plugin('heal', 'Healing is disabled in --debug mode, use DEBUG="codeceptjs:heal" to enable it in debug mode');
+    });
+    return;
   }
 
-  let currentTest = null
-  let currentStep = null
-  let healedSteps = 0
-  let caughtError
-  let healTries = 0
-  let isHealing = false
+  let currentTest = null;
+  let currentStep = null;
+  let healedSteps = 0;
+  let caughtError;
+  let healTries = 0;
+  let isHealing = false;
 
-  config = Object.assign(defaultConfig, config)
+  config = Object.assign(defaultConfig, config);
 
   event.dispatcher.on(event.test.before, (test) => {
-    currentTest = test
-    healedSteps = 0
-    caughtError = null
-  })
+    currentTest = test;
+    healedSteps = 0;
+    caughtError = null;
+  });
 
-  event.dispatcher.on(event.step.started, (step) => (currentStep = step))
+  event.dispatcher.on(event.step.started, step => currentStep = step);
 
   event.dispatcher.on(event.step.after, (step) => {
-    if (isHealing) return
-    if (healTries >= config.healLimit) return // out of limit
+    if (isHealing) return;
+    if (store.store.debugMode) return;
+    if (healTries >= config.healLimit) return; // out of limit
 
-    if (!heal.hasCorrespondingRecipes(step)) return
+    if (!heal.hasCorrespondingRecipes(step)) return;
 
     recorder.catchWithoutStop(async (err) => {
-      isHealing = true
-      if (caughtError === err) throw err // avoid double handling
-      caughtError = err
+      isHealing = true;
+      if (caughtError === err) throw err; // avoid double handling
+      caughtError = err;
 
-      const test = currentTest
+      const test = currentTest;
 
-      recorder.session.start('heal')
+      recorder.session.start('heal');
 
-      debug('Self-healing started', step.toCode())
+      debug('Self-healing started', step.toCode());
 
-      await heal.healStep(step, err, { test })
+      await heal.healStep(step, err, { test });
 
-      healTries++
+      healTries++;
 
       recorder.add('close healing session', () => {
-        recorder.reset()
-        recorder.session.restore('heal')
-        recorder.ignoreErr(err)
-      })
-      await recorder.promise()
+        recorder.reset();
+        recorder.session.restore('heal');
+        recorder.ignoreErr(err);
+      });
+      await recorder.promise();
 
-      isHealing = false
-    })
-  })
+      isHealing = false;
+    });
+  });
 
   event.dispatcher.on(event.all.result, () => {
-    if (!heal.fixes?.length) return
+    if (!heal.fixes?.length) return;
 
-    const { print } = output
+    const { print } = output;
 
-    print('')
-    print('===================')
-    print(colors.bold.green('Self-Healing Report:'))
+    print('');
+    print('===================');
+    print(colors.bold.green('Self-Healing Report:'));
 
-    print(`${colors.bold(heal.fixes.length)} ${heal.fixes.length === 1 ? 'step was' : 'steps were'} healed`)
+    print(`${colors.bold(heal.fixes.length)} ${heal.fixes.length === 1 ? 'step was' : 'steps were'} healed`);
 
-    const suggestions = heal.fixes.filter((fix) => fix.recipe && heal.recipes[fix.recipe].suggest)
+    const suggestions = heal.fixes.filter(fix => fix.recipe && heal.recipes[fix.recipe].suggest);
 
-    if (!suggestions.length) return
+    if (!suggestions.length) return;
 
-    let i = 1
-    print('')
-    print('Suggested changes:')
-    print('')
+    let i = 1;
+    print('');
+    print('Suggested changes:');
+    print('');
 
     for (const suggestion of suggestions) {
-      print(`${i}. To fix ${colors.bold.magenta(suggestion.test?.title)}`)
-      print('  Replace the failed code:', colors.gray(`(suggested by ${colors.bold(suggestion.recipe)})`))
-      print(colors.red(`- ${suggestion.step.toCode()}`))
-      print(colors.green(`+ ${suggestion.snippet}`))
-      print(suggestion.step.line())
-      print('')
-      i++
+      print(`${i}. To fix ${colors.bold.magenta(suggestion.test?.title)}`);
+      print('  Replace the failed code:', colors.gray(`(suggested by ${colors.bold(suggestion.recipe)})`));
+      print(colors.red(`- ${suggestion.step.toCode()}`));
+      print(colors.green(`+ ${suggestion.snippet}`));
+      print(suggestion.step.line());
+      print('');
+      i++;
+    }
+  });
+
+  async function tryToHeal(failedStep, err) {
+    output.output.debug(`Running OpenAI to heal ${failedStep.toCode()} step`);
+
+    const codeSnippets = await AiAssistant.healFailedStep(failedStep, err, currentTest);
+
+    output.output.debug(`Received ${codeSnippets.length} suggestions from OpenAI`);
+    const I = Container.support('I'); // eslint-disable-line
+
+    for (const codeSnippet of codeSnippets) {
+      try {
+        debug('Executing', codeSnippet);
+        recorder.catch((e) => {
+          console.log(e);
+        });
+        await eval(codeSnippet); // eslint-disable-line
+
+        let healSuggestions = [];
+        healSuggestions.push({
+          test: currentTest,
+          step: failedStep,
+          snippet: codeSnippet,
+        });
+
+        recorder.add('healed', () => output.print(colors.bold.green('  Code healed successfully')));
+        healedSteps++;
+        return;
+      } catch (err) {
+        debug('Failed to execute code', err);
+        recorder.ignoreErr(err); // healing ded not help
+        // recorder.catch(() => output.print(colors.bold.red('  Failed healing code')));
+      }
     }
-  })
+
+    output.output.debug(`Couldn't heal the code for ${failedStep.toCode()}`);
+  }
+  return recorder.promise();
 }

package/lib/plugin/pauseOnFail.js

@@ -1,5 +1,5 @@
-const event = require('../event')
-const pause = require('../pause')
+import * as event from '../event.js';
+import pause from '../pause';
 
 /**
  * Automatically launches [interactive pause](/basics/#pause) when a test fails.
@@ -21,18 +21,18 @@ const pause = require('../pause')
  * ```
  *
  */
-module.exports = () => {
-  let failed = false
+export default () => {
+  let failed = false;
 
   event.dispatcher.on(event.test.started, () => {
-    failed = false
-  })
+    failed = false;
+  });
 
   event.dispatcher.on(event.step.failed, () => {
-    failed = true
-  })
+    failed = true;
+  });
 
   event.dispatcher.on(event.test.after, () => {
-    if (failed) pause()
-  })
-}
+    if (failed) pause();
+  });
+};

package/lib/plugin/retryFailedStep.js

@@ -1,14 +1,22 @@
-const event = require('../event')
-const recorder = require('../recorder')
-const container = require('../container')
-const { log } = require('../output')
+import * as event from '../event.js';
+import recorder from '../recorder.js';
+import * as output from '../output.js';
+
+import { store } from '../store.js';
 
 const defaultConfig = {
   retries: 3,
-  defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
+  defaultIgnoredSteps: [
+    'amOnPage',
+    'wait*',
+    'send*',
+    'execute*',
+    'run*',
+    'have*',
+  ],
   factor: 1.5,
   ignoredSteps: [],
-}
+};
 
 /**
  * Retries each failed step in a test.
@@ -76,46 +84,45 @@ const defaultConfig = {
  * ```
  *
  */
-module.exports = (config) => {
-  config = Object.assign(defaultConfig, config)
-  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
-  const customWhen = config.when
+export default (config) => {
+  config = Object.assign(defaultConfig, config);
+  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps);
+  const customWhen = config.when;
 
-  let enableRetry = false
+  let enableRetry = false;
 
   const when = (err) => {
-    if (!enableRetry) return
-    const store = require('../store')
-    if (store.debugMode) return false
-    if (customWhen) return customWhen(err)
-    return true
-  }
-  config.when = when
+    if (!enableRetry) return;
+    if (store.debugMode) return false;
+    if (customWhen) return customWhen(err);
+    return true;
+  };
+  config.when = when;
 
   event.dispatcher.on(event.step.started, (step) => {
     if (process.env.TRY_TO === 'true') {
-      log('Info: RetryFailedStep plugin is disabled inside tryTo block')
-      return
+      output.output.log('Info: RetryFailedStep plugin is disabled inside tryTo block');
+      return;
     }
 
     // if a step is ignored - return
     for (const ignored of config.ignoredSteps) {
-      if (step.name === ignored) return
+      if (step.name === ignored) return;
       if (ignored instanceof RegExp) {
-        if (step.name.match(ignored)) return
-      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return
+        if (step.name.match(ignored)) return;
+      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return;
     }
-    enableRetry = true // enable retry for a step
-  })
+    enableRetry = true; // enable retry for a step
+  });
 
   event.dispatcher.on(event.step.finished, () => {
-    enableRetry = false
-  })
+    enableRetry = false;
+  });
 
   event.dispatcher.on(event.test.before, (test) => {
-    if (test && test.disableRetryFailedStep) return // disable retry when a test is not active
+    if (test && test.disableRetryFailedStep) return; // disable retry when a test is not active
     // this env var is used to set the retries inside _before() block of helpers
-    process.env.FAILED_STEP_RETRIES = config.retries
-    recorder.retry(config)
-  })
-}
+    process.env.FAILED_STEP_RETRIES = config.retries;
+    recorder.retry(config);
+  });
+};

package/lib/plugin/retryTo.js

@@ -1,10 +1,10 @@
-const recorder = require('../recorder')
-const { debug } = require('../output')
+import recorder from '../recorder.js';
+import * as output from '../output.js';
 
 const defaultConfig = {
   registerGlobal: true,
   pollInterval: 200,
-}
+};
 
 /**
  *
@@ -72,56 +72,50 @@ const defaultConfig = {
  * const retryTo = codeceptjs.container.plugins('retryTo');
  * ```
  *
- */
-module.exports = function (config) {
-  config = Object.assign(defaultConfig, config)
-  function retryTo(callback, maxTries, pollInterval = config.pollInterval) {
-    return new Promise((done, reject) => {
-      let tries = 1
+*/
+export default function (config) {
+  config = Object.assign(defaultConfig, config);
 
-      function handleRetryException(err) {
-        recorder.throw(err)
-        reject(err)
-      }
+  if (config.registerGlobal) {
+    // @ts-ignore
+    global.retryTo = retryTo;
+  }
+  return retryTo;
 
-      const tryBlock = async () => {
-        tries++
-        recorder.session.start(`retryTo ${tries}`)
-        try {
-          await callback(tries)
-        } catch (err) {
-          handleRetryException(err)
-        }
+  function retryTo(callback, maxTries, pollInterval = undefined) {
+    let tries = 1;
+    if (!pollInterval) pollInterval = config.pollInterval;
 
-        // Call done if no errors
-        recorder.add(() => {
-          recorder.session.restore(`retryTo ${tries}`)
-          done(null)
-        })
+    let err = null;
 
-        // Catch errors and retry
-        recorder.session.catch((err) => {
-          recorder.session.restore(`retryTo ${tries}`)
+    return new Promise((done) => {
+      const tryBlock = async () => {
+        recorder.session.start(`retryTo ${tries}`);
+        await callback(tries);
+        recorder.add(() => {
+          recorder.session.restore(`retryTo ${tries}`);
+          done(null);
+        });
+        recorder.session.catch((e) => {
+          err = e;
+          recorder.session.restore(`retryTo ${tries}`);
+          tries++;
           if (tries <= maxTries) {
-            debug(`Error ${err}... Retrying`)
-            recorder.add(`retryTo ${tries}`, () => setTimeout(tryBlock, pollInterval))
+            output.output.debug(`Error ${err}... Retrying`);
+            err = null;
+
+            recorder.add(`retryTo ${tries}`, () => setTimeout(tryBlock, pollInterval));
           } else {
-            // if maxTries reached
-            handleRetryException(err)
+            done(null);
           }
-        })
-      }
-
-      recorder.add('retryTo', tryBlock).catch((err) => {
-        console.error('An error occurred:', err)
-        done(null)
-      })
-    })
-  }
+        });
+      };
 
-  if (config.registerGlobal) {
-    global.retryTo = retryTo
+      recorder.add('retryTo', async () => {
+        tryBlock();
+      });
+    }).then(() => {
+      if (err) recorder.throw(err);
+    });
   }
-
-  return retryTo
 }