codeceptjs 3.7.0-beta.1 → 3.7.0-beta.11

package/lib/plugin/retryTo.js

@@ -1,123 +1,23 @@
-const recorder = require('../recorder')
-const { debug } = require('../output')
+const { retryTo } = require('../effects')
 
-const defaultConfig = {
-  registerGlobal: true,
-  pollInterval: 200,
-}
-
-/**
- *
- *
- * Adds global `retryTo` which retries steps a few times before failing.
- *
- * Enable this plugin in `codecept.conf.js` (enabled by default for new setups):
- *
- * ```js
- * plugins: {
- *   retryTo: {
- *     enabled: true
- *   }
- * }
- * ```
- *
- * Use it in your tests:
- *
- * ```js
- * // retry these steps 5 times before failing
- * await retryTo((tryNum) => {
- *   I.switchTo('#editor frame');
- *   I.click('Open');
- *   I.see('Opened')
- * }, 5);
- * ```
- * Set polling interval as 3rd argument (200ms by default):
- *
- * ```js
- * // retry these steps 5 times before failing
- * await retryTo((tryNum) => {
- *   I.switchTo('#editor frame');
- *   I.click('Open');
- *   I.see('Opened')
- * }, 5, 100);
- * ```
- *
- * Default polling interval can be changed in a config:
- *
- * ```js
- * plugins: {
- *   retryTo: {
- *     enabled: true,
- *     pollInterval: 500,
- *   }
- * }
- * ```
- *
- * Disables retryFailedStep plugin for steps inside a block;
- *
- * Use this plugin if:
- *
- * * you need repeat a set of actions in flaky tests
- * * iframe was not rendered and you need to retry switching to it
- *
- *
- * #### Configuration
- *
- * * `pollInterval` - default interval between retries in ms. 200 by default.
- * * `registerGlobal` - to register `retryTo` function globally, true by default
- *
- * If `registerGlobal` is false you can use retryTo from the plugin:
- *
- * ```js
- * 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
-
-      function handleRetryException(err) {
-        recorder.throw(err)
-        reject(err)
-      }
-
-      const tryBlock = async () => {
-        tries++
-        recorder.session.start(`retryTo ${tries}`)
-        try {
-          await callback(tries)
-        } catch (err) {
-          handleRetryException(err)
-        }
-
-        // Call done if no errors
-        recorder.add(() => {
-          recorder.session.restore(`retryTo ${tries}`)
-          done(null)
-        })
-
-        // Catch errors and retry
-        recorder.session.catch(err => {
-          recorder.session.restore(`retryTo ${tries}`)
-          if (tries <= maxTries) {
-            debug(`Error ${err}... Retrying`)
-            recorder.add(`retryTo ${tries}`, () => setTimeout(tryBlock, pollInterval))
-          } else {
-            // if maxTries reached
-            handleRetryException(err)
-          }
-        })
-      }
-
-      recorder.add('retryTo', tryBlock).catch(err => {
-        console.error('An error occurred:', err)
-        done(null)
-      })
-    })
-  }
+  console.log(`
+Deprecation Warning: 'retryTo' has been moved to the effects module.
+You should update your tests to use it as follows:
+
+\`\`\`javascript
+const { retryTo } = require('codeceptjs/effects');
+
+// Example: Retry these steps 5 times before failing
+await retryTo((tryNum) => {
+  I.switchTo('#editor frame');
+  I.click('Open');
+  I.see('Opened');
+}, 5);
+\`\`\`
+
+For more details, refer to the documentation.
+  `)
 
   if (config.registerGlobal) {
     global.retryTo = retryTo

package/lib/plugin/screenshotOnFail.js

@@ -5,8 +5,9 @@ const Container = require('../container')
 const recorder = require('../recorder')
 const event = require('../event')
 const output = require('../output')
-const { fileExists, clearString } = require('../utils')
+const { fileExists } = require('../utils')
 const Codeceptjs = require('../index')
+const { testToFileName } = require('../mocha/test')
 
 const defaultConfig = {
   uniqueScreenshotNames: false,
@@ -14,7 +15,7 @@ const defaultConfig = {
   fullPageScreenshots: false,
 }
 
-const supportedHelpers = require('./standardActingHelpers')
+const supportedHelpers = Container.STANDARD_ACTING_HELPERS
 
 /**
  * Creates screenshot on failure. Screenshot is saved into `output` directory.
@@ -63,7 +64,7 @@ module.exports = function (config) {
   }
 
   if (Codeceptjs.container.mocha()) {
-    options.reportDir = Codeceptjs.container.mocha().options.reporterOptions && Codeceptjs.container.mocha().options.reporterOptions.reportDir
+    options.reportDir = Codeceptjs.container.mocha()?.options?.reporterOptions && Codeceptjs.container.mocha()?.options?.reporterOptions?.reportDir
   }
 
   if (options.disableScreenshots) {
@@ -71,21 +72,19 @@ module.exports = function (config) {
     return
   }
 
-  event.dispatcher.on(event.test.failed, test => {
-    if (test.ctx?._runnable.title.includes('hook: ')) {
-      output.plugin('screenshotOnFail', 'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.')
+  event.dispatcher.on(event.test.failed, (test, _err, hookName) => {
+    if (hookName === 'BeforeSuite' || hookName === 'AfterSuite') {
+      // no browser here
       return
     }
+
     recorder.add(
       'screenshot of failed test',
       async () => {
-        let fileName = clearString(test.title)
         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()
-        }
-        if (test.ctx && test.ctx.test && test.ctx.test.type === 'hook') fileName = clearString(`${test.title}_${test.ctx.test.title}`)
+        let fileName = testToFileName(test)
+
         if (options.uniqueScreenshotNames && test) {
           const uuid = _getUUID(test)
           fileName = `${fileName.substring(0, 10)}_${uuid}.failed.png`
@@ -141,12 +140,8 @@ module.exports = function (config) {
   })
 
   function _getUUID(test) {
-    if (test.uuid) {
-      return test.uuid
-    }
-
-    if (test.ctx && test.ctx.test.uuid) {
-      return test.ctx.test.uuid
+    if (test.uid) {
+      return test.uid
     }
 
     return Math.floor(new Date().getTime() / 1000)

package/lib/plugin/standardActingHelpers.js

@@ -1,3 +1,6 @@
-const standardActingHelpers = ['Playwright', 'WebDriver', 'Puppeteer', 'Appium', 'TestCafe']
+const Container = require('../container')
+// due to using this in internal tooling we won't post deprecation warning
+// but please switch to Container.STANDARD_ACTING_HELPERS
+const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
 
 module.exports = standardActingHelpers

package/lib/plugin/stepByStepReport.js

@@ -12,7 +12,7 @@ const event = require('../event')
 const output = require('../output')
 const { template, deleteDir } = require('../utils')
 
-const supportedHelpers = require('./standardActingHelpers')
+const supportedHelpers = Container.STANDARD_ACTING_HELPERS
 
 const defaultConfig = {
   deleteSuccessful: true,
@@ -121,12 +121,13 @@ module.exports = function (config) {
     deleteDir(dir)
   })
 
-  event.dispatcher.on(event.test.failed, (test, err) => {
-    if (test.ctx._runnable.title.includes('hook: ')) {
-      output.plugin('stepByStepReport', 'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.')
+  event.dispatcher.on(event.test.failed, (test, _err, hookName) => {
+    if (hookName === 'BeforeSuite' || hookName === 'AfterSuite') {
+      // no browser here
       return
     }
-    persist(test, err)
+
+    persist(test)
   })
 
   event.dispatcher.on(event.all.result, () => {

package/lib/plugin/stepTimeout.js

@@ -1,5 +1,5 @@
 const event = require('../event')
-const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER
+const { TIMEOUT_ORDER } = require('../timeout')
 
 const defaultConfig = {
   timeout: 150,

package/lib/plugin/tryTo.js

@@ -1,115 +1,25 @@
-const recorder = require('../recorder')
-const { debug } = require('../output')
+const { tryTo } = require('../effects')
 
-const defaultConfig = {
-  registerGlobal: true,
-}
-
-/**
- *
- *
- * Adds global `tryTo` function in which all failed steps won't fail a test but will return true/false.
- *
- * Enable this plugin in `codecept.conf.js` (enabled by default for new setups):
- *
- * ```js
- * plugins: {
- *   tryTo: {
- *     enabled: true
- *   }
- * }
- * ```
- * Use it in your tests:
- *
- * ```js
- * const result = await tryTo(() => I.see('Welcome'));
- *
- * // if text "Welcome" is on page, result => true
- * // if text "Welcome" is not on page, result => false
- * ```
- *
- * Disables retryFailedStep plugin for steps inside a block;
- *
- * Use this plugin if:
- *
- * * you need to perform multiple assertions inside a test
- * * there is A/B testing on a website you test
- * * there is "Accept Cookie" banner which may surprisingly appear on a page.
- *
- * #### Usage
- *
- * #### Multiple Conditional Assertions
- *
- * ```js
- *
- * Add assert requires first:
- * ```js
- * const assert = require('assert');
- * ```
- * Then use the assertion:
- * const result1 = await tryTo(() => I.see('Hello, user'));
- * const result2 = await tryTo(() => I.seeElement('.welcome'));
- * assert.ok(result1 && result2, 'Assertions were not succesful');
- * ```
- *
- * ##### Optional click
- *
- * ```js
- * I.amOnPage('/');
- * tryTo(() => I.click('Agree', '.cookies'));
- * ```
- *
- * #### Configuration
- *
- * * `registerGlobal` - to register `tryTo` function globally, true by default
- *
- * If `registerGlobal` is false you can use tryTo from the plugin:
- *
- * ```js
- * const tryTo = codeceptjs.container.plugins('tryTo');
- * ```
- *
- */
 module.exports = function (config) {
-  config = Object.assign(defaultConfig, config)
+  console.log(`
+Deprecated Warning: 'tryTo' has been moved to the effects module.
+You should update your tests to use it as follows:
+
+\`\`\`javascript
+const { tryTo } = require('codeceptjs/effects');
+
+// Example: failed step won't fail a test but will return true/false
+await tryTo(() => {
+  I.switchTo('#editor frame');
+});
+\`\`\`
+
+For more details, refer to the documentation.
+  `)
 
   if (config.registerGlobal) {
     global.tryTo = tryTo
   }
-  return tryTo
-}
 
-function tryTo(callback) {
-  let result = false
-  return recorder.add(
-    'tryTo',
-    () => {
-      recorder.session.start('tryTo')
-      process.env.TRY_TO = 'true'
-      callback()
-      recorder.add(() => {
-        result = true
-        recorder.session.restore('tryTo')
-        return result
-      })
-      recorder.session.catch(err => {
-        result = false
-        const msg = err.inspect ? err.inspect() : err.toString()
-        debug(`Unsuccessful try > ${msg}`)
-        recorder.session.restore('tryTo')
-        return result
-      })
-      return recorder.add(
-        'result',
-        () => {
-          process.env.TRY_TO = undefined
-          return result
-        },
-        true,
-        false,
-      )
-    },
-    false,
-    false,
-  )
+  return tryTo
 }

package/lib/recorder.js

@@ -3,7 +3,7 @@ const promiseRetry = require('promise-retry')
 const chalk = require('chalk')
 const { printObjectProperties } = require('./utils')
 const { log } = require('./output')
-
+const { TimeoutError } = require('./timeout')
 const MAX_TASKS = 100
 
 let promise
@@ -179,7 +179,7 @@ module.exports = {
     }
     if (retry === undefined) retry = true
     if (!running && !force) {
-      return
+      return Promise.resolve()
     }
     tasks.push(taskName)
     debug(chalk.gray(`${currentQueue()} Queued | ${taskName}`))
@@ -191,13 +191,13 @@ module.exports = {
         .slice(-1)
         .pop()
       // no retries or unnamed tasks
+      debug(`${currentQueue()} Running | ${taskName} | Timeout: ${timeout || 'None'}`)
+
       if (!retryOpts || !taskName || !retry) {
         const [promise, timer] = getTimeoutPromise(timeout, taskName)
         return Promise.race([promise, Promise.resolve(res).then(fn)]).finally(() => clearTimeout(timer))
       }
 
-      debug(`${currentQueue()} Running | ${taskName}`)
-
       const retryRules = this.retries.slice().reverse()
       return promiseRetry(Object.assign(defaultRetryOptions, retryOpts), (retry, number) => {
         if (number > 1) log(`${currentQueue()}Retrying... Attempt #${number}`)
@@ -386,7 +386,7 @@ function getTimeoutPromise(timeoutMs, taskName) {
   return [
     new Promise((done, reject) => {
       timer = setTimeout(() => {
-        reject(new Error(`Action ${taskName} was interrupted on step timeout ${timeoutMs}ms`))
+        reject(new TimeoutError(`Action ${taskName} was interrupted on timeout ${timeoutMs}ms`))
       }, timeoutMs || 2e9)
     }),
     timer,

package/lib/rerun.js

@@ -1,81 +1,82 @@
-const fsPath = require('path');
-const container = require('./container');
-const event = require('./event');
-const BaseCodecept = require('./codecept');
-const output = require('./output');
+const fsPath = require('path')
+const container = require('./container')
+const event = require('./event')
+const BaseCodecept = require('./codecept')
+const output = require('./output')
 
 class CodeceptRerunner extends BaseCodecept {
   runOnce(test) {
     return new Promise((resolve, reject) => {
       // @ts-ignore
-      container.createMocha();
-      const mocha = container.mocha();
-      this.testFiles.forEach((file) => {
-        delete require.cache[file];
-      });
-      mocha.files = this.testFiles;
+      container.createMocha()
+      const mocha = container.mocha()
+      this.testFiles.forEach(file => {
+        delete require.cache[file]
+      })
+      mocha.files = this.testFiles
       if (test) {
         if (!fsPath.isAbsolute(test)) {
-          test = fsPath.join(global.codecept_dir, test);
+          test = fsPath.join(global.codecept_dir, test)
         }
-        mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test);
+        mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test)
       }
       try {
-        mocha.run((failures) => {
+        mocha.run(failures => {
           if (failures === 0) {
-            resolve();
+            resolve()
           } else {
-            reject(new Error(`${failures} tests fail`));
+            reject(new Error(`${failures} tests fail`))
           }
-        });
+        })
       } catch (e) {
-        reject(e);
+        reject(e)
       }
-    });
+    })
   }
 
   async runTests(test) {
-    const configRerun = this.config.rerun || {};
-    const minSuccess = configRerun.minSuccess || 1;
-    const maxReruns = configRerun.maxReruns || 1;
+    const configRerun = this.config.rerun || {}
+    const minSuccess = configRerun.minSuccess || 1
+    const maxReruns = configRerun.maxReruns || 1
     if (minSuccess > maxReruns) {
-      process.exitCode = 1;
-      throw new Error(`run-rerun Configuration Error: minSuccess must be less than maxReruns. Current values: minSuccess=${minSuccess} maxReruns=${maxReruns}`);
+      process.exitCode = 1
+      throw new Error(`run-rerun Configuration Error: minSuccess must be less than maxReruns. Current values: minSuccess=${minSuccess} maxReruns=${maxReruns}`)
     }
     if (maxReruns === 1) {
-      await this.runOnce(test);
-      return;
+      await this.runOnce(test)
+      return
     }
-    let successCounter = 0;
-    let rerunsCounter = 0;
+    let successCounter = 0
+    let rerunsCounter = 0
     while (rerunsCounter < maxReruns && successCounter < minSuccess) {
-      rerunsCounter++;
+      container.result().reset() // reset result
+      rerunsCounter++
       try {
-        await this.runOnce(test);
-        successCounter++;
-        output.success(`\nProcess run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess}\n`);
+        await this.runOnce(test)
+        successCounter++
+        output.success(`\nProcess run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess}\n`)
       } catch (e) {
-        output.error(`\nFail run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess} \n`);
-        console.error(e);
+        output.error(`\nFail run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess} \n`)
+        console.error(e)
       }
     }
     if (successCounter < minSuccess) {
-      throw new Error(`Flaky tests detected! ${successCounter} success runs achieved instead of ${minSuccess} success runs expected`);
+      throw new Error(`Flaky tests detected! ${successCounter} success runs achieved instead of ${minSuccess} success runs expected`)
     }
   }
 
   async run(test) {
-    event.emit(event.all.before, this);
+    event.emit(event.all.before, this)
     try {
-      await this.runTests(test);
+      await this.runTests(test)
     } catch (e) {
-      output.error(e.stack);
-      throw e;
+      output.error(e.stack)
+      throw e
     } finally {
-      event.emit(event.all.result, this);
-      event.emit(event.all.after, this);
+      event.emit(event.all.result, this)
+      event.emit(event.all.after, this)
     }
   }
 }
 
-module.exports = CodeceptRerunner;
+module.exports = CodeceptRerunner