codeceptjs 4.0.0-beta.3 → 4.0.0-beta.5

package/lib/plugin/autoLogin.js

@@ -1,340 +1,5 @@
-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 auth = require('./auth')
 
-const defaultUser = {
-  fetch: (I) => I.grabCookie(),
-  check: () => {},
-  restore: (I, cookies) => {
-    I.amOnPage('/') // open a page
-    I.setCookie(cookies)
-  },
-}
+console.log('autoLogin plugin was renamed to auth plugin. Please update your config.')
 
-const defaultConfig = {
-  saveToFile: false,
-  inject: 'login',
-}
-
-/**
- * Logs user in for the first test and reuses session for next tests.
- * Works by saving cookies into memory or file.
- * If a session expires automatically logs in again.
- *
- * > For better development experience cookies can be saved into file, so a session can be reused while writing tests.
- *
- * #### Usage
- *
- * 1. Enable this plugin and configure as described below
- * 2. Define user session names (example: `user`, `editor`, `admin`, etc).
- * 3. Define how users are logged in and how to check that user is logged in
- * 4. Use `login` object inside your tests to log in:
- *
- * ```js
- * // inside a test file
- * // use login to inject auto-login function
- * Feature('Login');
- *
- * Before(({ login }) => {
- *    login('user'); // login using user session
- * });
- *
- * // Alternatively log in for one scenario.
- * Scenario('log me in', ( { I, login } ) => {
- *    login('admin');
- *    I.see('I am logged in');
- * });
- * ```
- *
- * #### Configuration
- *
- * * `saveToFile` (default: false) - save cookies to file. Allows to reuse session between execution.
- * * `inject` (default: `login`) - name of the login function to use
- * * `users` - an array containing different session names and functions to:
- *    * `login` - sign in into the system
- *     * `check` - check that user is logged in
- *     * `fetch` - to get current cookies (by default `I.grabCookie()`)
- *     * `restore` - to set cookies (by default `I.amOnPage('/'); I.setCookie(cookie)`)
- *
- * #### How It Works
- *
- * 1. `restore` method is executed. It should open a page and set credentials.
- * 2. `check` method is executed. It should reload a page (so cookies are applied) and check that this page belongs to logged-in user. When you pass the second args `session`, you could perform the validation using passed session.
- * 3. If `restore` and `check` were not successful, `login` is executed
- * 4. `login` should fill in login form
- * 5. After successful login, `fetch` is executed to save cookies into memory or file.
- *
- * #### Example: Simple login
- *
- * ```js
- * autoLogin: {
- *   enabled: true,
- *   saveToFile: true,
- *   inject: 'login',
- *   users: {
- *     admin: {
- *       // loginAdmin function is defined in `steps_file.js`
- *       login: (I) => I.loginAdmin(),
- *       // if we see `Admin` on page, we assume we are logged in
- *       check: (I) => {
- *          I.amOnPage('/');
- *          I.see('Admin');
- *       }
- *     }
- *   }
- * }
- * ```
- *
- * #### Example: Multiple users
- *
- * ```js
- * autoLogin: {
- *   enabled: true,
- *   saveToFile: true,
- *   inject: 'loginAs', // use `loginAs` instead of login
- *   users: {
- *     user: {
- *       login: (I) => {
- *          I.amOnPage('/login');
- *          I.fillField('email', 'user@site.com');
- *          I.fillField('password', '123456');
- *          I.click('Login');
- *       },
- *       check: (I) => {
- *          I.amOnPage('/');
- *          I.see('User', '.navbar');
- *       },
- *     },
- *     admin: {
- *       login: (I) => {
- *          I.amOnPage('/login');
- *          I.fillField('email', 'admin@site.com');
- *          I.fillField('password', '123456');
- *          I.click('Login');
- *       },
- *       check: (I) => {
- *          I.amOnPage('/');
- *          I.see('Admin', '.navbar');
- *       },
- *     },
- *   }
- * }
- * ```
- *
- * #### Example: Keep cookies between tests
- *
- * If you decide to keep cookies between tests you don't need to save/retrieve cookies between tests.
- * But you need to login once work until session expires.
- * For this case, disable `fetch` and `restore` methods.
- *
- * ```js
- * helpers: {
- *    WebDriver: {
- *      // config goes here
- *      keepCookies: true; // keep cookies for all tests
- *    }
- * },
- * plugins: {
- *    autoLogin: {
- *      users: {
- *        admin: {
- *          login: (I) => {
- *            I.amOnPage('/login');
- *            I.fillField('email', 'admin@site.com');
- *            I.fillField('password', '123456');
- *            I.click('Login');
- *          },
- *          check: (I) => {
- *            I.amOnPage('/dashboard');
- *            I.see('Admin', '.navbar');
- *          },
- *          fetch: () => {}, // empty function
- *          restore: () => {}, // empty funciton
- *        }
- *     }
- *   }
- * }
- * ```
- *
- * #### Example: Getting sessions from local storage
- *
- * If your session is stored in local storage instead of cookies you still can obtain sessions.
- *
- * ```js
- * plugins: {
- *    autoLogin: {
- *     admin: {
- *       login: (I) => I.loginAsAdmin(),
- *       check: (I) => I.see('Admin', '.navbar'),
- *       fetch: (I) => {
- *         return I.executeScript(() => localStorage.getItem('session_id'));
- *       },
- *       restore: (I, session) => {
- *         I.amOnPage('/');
- *         I.executeScript((session) => localStorage.setItem('session_id', session), session);
- *       },
- *     }
- *   }
- * }
- * ```
- *
- * #### Tips: Using async function in the autoLogin
- *
- * If you use async functions in the autoLogin plugin, login function should be used with `await` keyword.
- *
- * ```js
- * autoLogin: {
- *   enabled: true,
- *   saveToFile: true,
- *   inject: 'login',
- *   users: {
- *     admin: {
- *       login: async (I) => {  // If you use async function in the autoLogin plugin
- *          const phrase = await I.grabTextFrom('#phrase')
- *          I.fillField('username', 'admin'),
- *          I.fillField('password', 'password')
- *          I.fillField('phrase', phrase)
- *       },
- *       check: (I) => {
- *          I.amOnPage('/');
- *          I.see('Admin');
- *       },
- *     }
- *   }
- * }
- * ```
- *
- * ```js
- * Scenario('login', async ( {I, login} ) => {
- *   await login('admin') // you should use `await`
- * })
- * ```
- *
- * #### Tips: Using session to validate user
- *
- * Instead of asserting on page elements for the current user in `check`, you can use the `session` you saved in `fetch`
- *
- * ```js
- * autoLogin: {
- *   enabled: true,
- *   saveToFile: true,
- *   inject: 'login',
- *   users: {
- *     admin: {
- *       login: async (I) => {  // If you use async function in the autoLogin plugin
- *          const phrase = await I.grabTextFrom('#phrase')
- *          I.fillField('username', 'admin'),
- *          I.fillField('password', 'password')
- *          I.fillField('phrase', phrase)
- *       },
- *       check: (I, session) => {
- *          // Throwing an error in `check` will make CodeceptJS perform the login step for the user
- *          if (session.profile.email !== the.email.you.expect@some-mail.com) {
- *               throw new Error ('Wrong user signed in');
- *         }
- *       },
- *     }
- *   }
- * }
- * ```
- *
- * ```js
- * Scenario('login', async ( {I, login} ) => {
- *   await login('admin') // you should use `await`
- * })
- *
- *
- */
-module.exports = 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()
-      try {
-        store[`${name}_session`] = JSON.parse(data)
-      } catch (err) {
-        throw new Error(`Could not load session from ${fileName}\n${err}`)
-      }
-      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 loginAndSave = async () => {
-      if (shouldAwait) {
-        await userSession.login(I)
-      } else {
-        userSession.login(I)
-      }
-
-      const cookies = await userSession.fetch(I)
-      if (!cookies) {
-        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))
-      }
-      store[`${name}_session`] = cookies
-    }
-
-    if (!cookies) return loginAndSave()
-
-    recorder.session.start('check login')
-    if (shouldAwait) {
-      await userSession.restore(I, cookies)
-      await userSession.check(I, cookies)
-    } else {
-      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)
-        })
-    })
-    recorder.add(() => {
-      recorder.session.restore('check login')
-    })
-
-    return recorder.promise()
-  }
-
-  // adding this to DI container
-  const support = {}
-  support[config.inject] = loginFunction
-  container.append({ support })
-}
+module.exports = auth

package/lib/plugin/commentStep.js

@@ -7,6 +7,8 @@ let currentCommentStep
 const defaultGlobalName = '__'
 
 /**
+ * This plugin is **deprecated**, use `Section` instead.
+ *
  * Add descriptive nested steps for your tests:
  *
  * ```js
@@ -100,11 +102,14 @@ const defaultGlobalName = '__'
  * ```
  */
 module.exports = function (config) {
+  console.log('commentStep is deprecated, disable it and use Section instead')
+  console.log('const { Section: __ } = require("codeceptjs/steps")')
+
   event.dispatcher.on(event.test.started, () => {
     currentCommentStep = null
   })
 
-  event.dispatcher.on(event.step.started, (step) => {
+  event.dispatcher.on(event.step.started, step => {
     if (currentCommentStep) {
       const metaStep = getRootMetaStep(step)
 

package/lib/plugin/coverage.js

@@ -15,7 +15,7 @@ const supportedHelpers = ['Puppeteer', 'Playwright', 'WebDriver']
 
 const v8CoverageHelpers = {
   Playwright: {
-    startCoverage: async (page) => {
+    startCoverage: async page => {
       await Promise.all([
         page.coverage.startJSCoverage({
           resetOnNavigation: false,
@@ -26,16 +26,13 @@ const v8CoverageHelpers = {
       ])
     },
     takeCoverage: async (page, coverageReport) => {
-      const [jsCoverage, cssCoverage] = await Promise.all([
-        page.coverage.stopJSCoverage(),
-        page.coverage.stopCSSCoverage(),
-      ])
+      const [jsCoverage, cssCoverage] = await Promise.all([page.coverage.stopJSCoverage(), page.coverage.stopCSSCoverage()])
       const coverageList = [...jsCoverage, ...cssCoverage]
       await coverageReport.add(coverageList)
     },
   },
   Puppeteer: {
-    startCoverage: async (page) => {
+    startCoverage: async page => {
       await Promise.all([
         page.coverage.startJSCoverage({
           resetOnNavigation: false,
@@ -47,13 +44,10 @@ const v8CoverageHelpers = {
       ])
     },
     takeCoverage: async (page, coverageReport) => {
-      const [jsCoverage, cssCoverage] = await Promise.all([
-        page.coverage.stopJSCoverage(),
-        page.coverage.stopCSSCoverage(),
-      ])
+      const [jsCoverage, cssCoverage] = await Promise.all([page.coverage.stopJSCoverage(), page.coverage.stopCSSCoverage()])
       // to raw V8 script coverage
       const coverageList = [
-        ...jsCoverage.map((it) => {
+        ...jsCoverage.map(it => {
           return {
             source: it.text,
             ...it.rawScriptCoverage,
@@ -65,7 +59,7 @@ const v8CoverageHelpers = {
     },
   },
   WebDriver: {
-    startCoverage: async (page) => {
+    startCoverage: async page => {
       await Promise.all([
         page.coverage.startJSCoverage({
           resetOnNavigation: false,
@@ -77,13 +71,10 @@ const v8CoverageHelpers = {
       ])
     },
     takeCoverage: async (page, coverageReport) => {
-      const [jsCoverage, cssCoverage] = await Promise.all([
-        page.coverage.stopJSCoverage(),
-        page.coverage.stopCSSCoverage(),
-      ])
+      const [jsCoverage, cssCoverage] = await Promise.all([page.coverage.stopJSCoverage(), page.coverage.stopCSSCoverage()])
       // to raw V8 script coverage
       const coverageList = [
-        ...jsCoverage.map((it) => {
+        ...jsCoverage.map(it => {
           return {
             source: it.text,
             ...it.rawScriptCoverage,
@@ -131,7 +122,7 @@ module.exports = function (config) {
   let coverageRunning = false
 
   const v8Names = Object.keys(v8CoverageHelpers)
-  const helperName = Object.keys(helpers).find((it) => v8Names.includes(it))
+  const helperName = Object.keys(helpers).find(it => v8Names.includes(it))
   if (!helperName) {
     console.error(`Coverage is only supported in ${supportedHelpers.join(' or ')}`)
     // no helpers for screenshot
@@ -143,9 +134,6 @@ module.exports = function (config) {
 
   const helper = helpers[helperName]
 
-  if (helperName === 'WebDriver' && !helper.config.devtoolsProtocol)
-    throw Error('Coverage is currently supporting the WebDriver running with Devtools protocol.')
-
   const v8Helper = v8CoverageHelpers[helperName]
 
   const coverageOptions = {
@@ -183,7 +171,7 @@ module.exports = function (config) {
   })
 
   // Save coverage data after every test run
-  event.dispatcher.on(event.test.after, (test) => {
+  event.dispatcher.on(event.test.after, test => {
     recorder.add(
       'take coverage',
       async () => {

package/lib/plugin/customLocator.js

@@ -111,7 +111,7 @@ const defaultConfig = {
  * I.click('=sign-up'); // matches => [data-qa=sign-up],[data-test=sign-up]
  * ```
  */
-module.exports = (config) => {
+module.exports = config => {
   config = { ...defaultConfig, ...config }
 
   Locator.addFilter((value, locatorObj) => {
@@ -125,7 +125,7 @@ module.exports = (config) => {
     if (config.strategy.toLowerCase() === 'xpath') {
       locatorObj.value = `.//*[${[]
         .concat(config.attribute)
-        .map((attr) => `@${attr}=${xpathLocator.literal(val)}`)
+        .map(attr => `@${attr}=${xpathLocator.literal(val)}`)
         .join(' or ')}]`
       locatorObj.type = 'xpath'
     }
@@ -133,7 +133,7 @@ module.exports = (config) => {
     if (config.strategy.toLowerCase() === 'css') {
       locatorObj.value = []
         .concat(config.attribute)
-        .map((attr) => `[${attr}=${val}]`)
+        .map(attr => `[${attr}=${val}]`)
         .join(',')
       locatorObj.type = 'css'
     }

package/lib/plugin/customReporter.js

@@ -0,0 +1,52 @@
+const event = require('../event')
+
+/**
+ * Sample custom reporter for CodeceptJS.
+ */
+module.exports = function (config) {
+  event.dispatcher.on(event.hook.finished, hook => {
+    if (config.onHookFinished) {
+      config.onHookFinished(hook)
+    }
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    if (config.onTestBefore) {
+      config.onTestBefore(test)
+    }
+  })
+
+  event.dispatcher.on(event.test.failed, (test, err) => {
+    if (config.onTestFailed) {
+      config.onTestFailed(test, err)
+    }
+  })
+
+  event.dispatcher.on(event.test.passed, test => {
+    if (config.onTestPassed) {
+      config.onTestPassed(test)
+    }
+  })
+
+  event.dispatcher.on(event.test.skipped, test => {
+    if (config.onTestSkipped) {
+      config.onTestSkipped(test)
+    }
+  })
+
+  event.dispatcher.on(event.test.finished, test => {
+    if (config.onTestFinished) {
+      config.onTestFinished(test)
+    }
+  })
+
+  event.dispatcher.on(event.all.result, result => {
+    if (config.onResult) {
+      config.onResult(result)
+    }
+
+    if (config.save) {
+      result.save()
+    }
+  })
+}

package/lib/plugin/eachElement.js

@@ -72,7 +72,7 @@ function eachElement(purpose, locator, fn) {
   if (store.dryRun) return
   const helpers = Object.values(container.helpers())
 
-  const helper = helpers.filter((h) => !!h._locate)[0]
+  const helper = helpers.filter(h => !!h._locate)[0]
 
   if (!helper) {
     throw new Error('No helper enabled with _locate method with returns a list of elements.')

package/lib/plugin/fakerTransform.js

@@ -40,7 +40,7 @@ const transform = require('../transform')
  *
  */
 module.exports = function (config) {
-  transform.addTransformerBeforeAll('gherkin.examples', (value) => {
+  transform.addTransformerBeforeAll('gherkin.examples', value => {
     if (typeof value === 'string' && value.length > 0) {
       return faker.helpers.fake(value)
     }

package/lib/plugin/heal.js

@@ -5,6 +5,7 @@ const event = require('../event')
 const output = require('../output')
 const heal = require('../heal')
 const store = require('../store')
+const container = require('../container')
 
 const defaultConfig = {
   healLimit: 2,
@@ -31,10 +32,7 @@ const defaultConfig = {
 module.exports = function (config = {}) {
   if (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',
-      )
+      output.plugin('heal', 'Healing is disabled in --debug mode, use DEBUG="codeceptjs:heal" to enable it in debug mode')
     })
     return
   }
@@ -48,21 +46,21 @@ module.exports = function (config = {}) {
 
   config = Object.assign(defaultConfig, config)
 
-  event.dispatcher.on(event.test.before, (test) => {
+  event.dispatcher.on(event.test.before, test => {
     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) => {
+  event.dispatcher.on(event.step.after, step => {
     if (isHealing) return
     if (healTries >= config.healLimit) return // out of limit
 
     if (!heal.hasCorrespondingRecipes(step)) return
 
-    recorder.catchWithoutStop(async (err) => {
+    recorder.catchWithoutStop(async err => {
       isHealing = true
       if (caughtError === err) throw err // avoid double handling
       caughtError = err
@@ -99,7 +97,7 @@ module.exports = function (config = {}) {
 
     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
 
@@ -118,4 +116,33 @@ module.exports = function (config = {}) {
       i++
     }
   })
+
+  event.dispatcher.on(event.workers.result, result => {
+    const { print } = output
+
+    const healedTests = Object.values(result.tests)
+      .flat()
+      .filter(test => test.notes.some(note => note.type === 'heal'))
+    if (!healedTests.length) return
+
+    setTimeout(() => {
+      print('')
+      print('===================')
+      print(colors.bold.green('Self-Healing Report:'))
+
+      print('')
+      print('Suggested changes:')
+      print('')
+
+      healedTests.forEach(test => {
+        print(`${colors.bold.magenta(test.title)}`)
+        test.notes
+          .filter(note => note.type === 'heal')
+          .forEach(note => {
+            print(note.text)
+            print('')
+          })
+      })
+    }, 0)
+  })
 }