codeceptjs 3.7.0-beta.9 → 3.7.0

package/lib/helper/extras/Popup.js

@@ -2,66 +2,66 @@
  * Class to handle the interaction with the Dialog (Popup) Class from Puppeteer
  */
 class Popup {
-  constructor(popup, defaultAction) {
-    this._popup = popup || null;
-    this._actionType = '';
-    this._defaultAction = defaultAction || '';
+  constructor(popup = null, defaultAction = '') {
+    this._popup = popup
+    this._actionType = ''
+    this._defaultAction = defaultAction
   }
 
   _assertValidActionType(action) {
     if (['accept', 'cancel'].indexOf(action) === -1) {
-      throw new Error('Invalid Popup action type. Only "accept" or "cancel" actions are accepted');
+      throw new Error('Invalid Popup action type. Only "accept" or "cancel" actions are accepted')
     }
   }
 
   set defaultAction(action) {
-    this._assertValidActionType(action);
-    this._defaultAction = action;
+    this._assertValidActionType(action)
+    this._defaultAction = action
   }
 
   get defaultAction() {
-    return this._defaultAction;
+    return this._defaultAction
   }
 
   get popup() {
-    return this._popup;
+    return this._popup
   }
 
   set popup(popup) {
     if (this._popup) {
-      console.error('Popup already exists and was not closed. Popups must always be closed by calling either I.acceptPopup() or I.cancelPopup()');
+      return
     }
-    this._popup = popup;
+    this._popup = popup
   }
 
   get actionType() {
-    return this._actionType;
+    return this._actionType
   }
 
   set actionType(action) {
-    this._assertValidActionType(action);
-    this._actionType = action;
+    this._assertValidActionType(action)
+    this._actionType = action
   }
 
   clear() {
-    this._popup = null;
-    this._actionType = '';
+    this._popup = null
+    this._actionType = ''
   }
 
   assertPopupVisible() {
     if (!this._popup) {
-      throw new Error('There is no Popup visible');
+      throw new Error('There is no Popup visible')
     }
   }
 
   assertPopupActionType(type) {
-    this.assertPopupVisible();
-    const expectedAction = this._actionType || this._defaultAction;
+    this.assertPopupVisible()
+    const expectedAction = this._actionType || this._defaultAction
     if (expectedAction !== type) {
-      throw new Error(`Popup action does not fit the expected action type. Expected popup action to be '${expectedAction}' not '${type}`);
+      throw new Error(`Popup action does not fit the expected action type. Expected popup action to be '${expectedAction}' not '${type}`)
     }
-    this.clear();
+    this.clear()
   }
 }
 
-module.exports = Popup;
+module.exports = Popup

package/lib/mocha/asyncWrapper.js

@@ -145,11 +145,13 @@ module.exports.injected = function (fn, suite, hookName) {
     const opts = suite.opts || {}
     const retries = opts[`retry${ucfirst(hookName)}`] || 0
 
+    const currentTest = hookName === 'before' || hookName === 'after' ? suite?.ctx?.currentTest : null
+
     promiseRetry(
       async (retry, number) => {
         try {
           recorder.startUnlessRunning()
-          await fn.call(this, getInjectedArguments(fn))
+          await fn.call(this, { ...getInjectedArguments(fn), suite, test: currentTest })
           await recorder.promise().catch(err => retry(err))
         } catch (err) {
           retry(err)

package/lib/mocha/gherkin.js

@@ -107,7 +107,7 @@ module.exports = (text, file) => {
       )
       continue
     }
-    if (child.scenario && (currentLanguage ? child.scenario.keyword === currentLanguage.contexts.ScenarioOutline : child.scenario.keyword === 'Scenario Outline')) {
+    if (child.scenario && (currentLanguage ? currentLanguage.contexts.ScenarioOutline.includes(child.scenario.keyword) : child.scenario.keyword === 'Scenario Outline')) {
       for (const examples of child.scenario.examples) {
         const fields = examples.tableHeader.cells.map(c => c.value)
         for (const example of examples.tableBody) {

package/lib/mocha/inject.js

@@ -5,6 +5,7 @@ const getInjectedArguments = (fn, test) => {
   const testArgs = {}
   const params = parser.getParams(fn) || []
   const objects = container.support()
+
   for (const key of params) {
     testArgs[key] = {}
     if (test && test.inject && test.inject[key]) {
@@ -18,6 +19,10 @@ const getInjectedArguments = (fn, test) => {
     testArgs[key] = container.support(key)
   }
 
+  if (test) {
+    testArgs.suite = test?.parent
+    testArgs.test = test
+  }
   return testArgs
 }
 

package/lib/mocha/test.js

@@ -133,8 +133,10 @@ function cloneTest(test) {
   return deserializeTest(serializeTest(test))
 }
 
-function testToFileName(test) {
-  let fileName = clearString(test.title)
+function testToFileName(test, suffix = '') {
+  let fileName = test.title
+
+  if (suffix) fileName = `${fileName}_${suffix}`
   // remove tags with empty string (disable for now)
   // fileName = fileName.replace(/\@\w+/g, '')
   fileName = fileName.slice(0, 100)
@@ -146,6 +148,7 @@ function testToFileName(test) {
   // if (test.parent && test.parent.title) {
   //   fileName = `${clearString(test.parent.title)}_${fileName}`
   // }
+  fileName = clearString(fileName).slice(0, 100)
   return fileName
 }
 

package/lib/plugin/analyze.js

@@ -60,7 +60,7 @@ const defaultConfig = {
 
         If there is no groups of tests, say: "No patterns found"
         Preserve error messages but cut them if they are too long.
-        Respond clearly and directly, without introductory words or phrases like ‘Of course,’ ‘Here is the answer,’ etc.
+        Respond clearly and directly, without introductory words or phrases like 'Of course,' 'Here is the answer,' etc.
         Do not list more than 3 errors in the group.
         If you identify that all tests in the group have the same tag, add this tag to the group report, otherwise ignore TAG section.
         If you identify that all tests in the group have the same suite, add this suite to the group report, otherwise ignore SUITE section.
@@ -160,9 +160,56 @@ const defaultConfig = {
 }
 
 /**
+ * CodeceptJS Analyze Plugin - Uses AI to analyze test failures and provide insights
  *
- * @param {*} config
- * @returns
+ * This plugin analyzes failed tests using AI to provide detailed explanations and group similar failures.
+ * When enabled with --ai flag, it generates reports after test execution.
+ *
+ * #### Usage
+ *
+ * ```js
+ * // in codecept.conf.js
+ * exports.config = {
+ *   plugins: {
+ *     analyze: {
+ *       enabled: true,
+ *       clusterize: 5,
+ *       analyze: 2,
+ *       vision: false
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * #### Configuration
+ *
+ * * `clusterize` (number) - minimum number of failures to trigger clustering analysis. Default: 5
+ * * `analyze` (number) - maximum number of individual test failures to analyze in detail. Default: 2
+ * * `vision` (boolean) - enables visual analysis of test screenshots. Default: false
+ * * `categories` (array) - list of failure categories for classification. Defaults to:
+ *   - Browser connection error / browser crash
+ *   - Network errors (server error, timeout, etc)
+ *   - HTML / page elements (not found, not visible, etc)
+ *   - Navigation errors (404, etc)
+ *   - Code errors (syntax error, JS errors, etc)
+ *   - Library & framework errors
+ *   - Data errors (password incorrect, invalid format, etc)
+ *   - Assertion failures
+ *   - Other errors
+ * * `prompts` (object) - customize AI prompts for analysis
+ *   - `clusterize` - prompt for clustering analysis
+ *   - `analyze` - prompt for individual test analysis
+ *
+ * #### Features
+ *
+ * * Groups similar failures when number of failures >= clusterize value
+ * * Provides detailed analysis of individual failures
+ * * Analyzes screenshots if vision=true and screenshots are available
+ * * Classifies failures into predefined categories
+ * * Suggests possible causes and solutions
+ *
+ * @param {Object} config - Plugin configuration
+ * @returns {void}
  */
 module.exports = function (config = {}) {
   config = Object.assign(defaultConfig, config)

package/lib/plugin/auth.js

@@ -0,0 +1,435 @@
+const fs = require('fs')
+const path = require('path')
+const { fileExists } = require('../utils')
+const CommentStep = require('../step/comment')
+const Section = require('../step/section')
+const container = require('../container')
+const store = require('../store')
+const event = require('../event')
+const recorder = require('../recorder')
+const { debug } = require('../output')
+const { isAsyncFunction } = require('../utils')
+
+const defaultUser = {
+  fetch: I => I.grabCookie(),
+  check: () => {},
+  restore: (I, 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.
+ * 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
+ * auth: {
+ *   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
+ * auth: {
+ *   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: {
+ *    auth: {
+ *      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: {
+ *    auth: {
+ *     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 auth
+ *
+ * If you use async functions in the auth plugin, login function should be used with `await` keyword.
+ *
+ * ```js
+ * auth: {
+ *   enabled: true,
+ *   saveToFile: true,
+ *   inject: 'login',
+ *   users: {
+ *     admin: {
+ *       login: async (I) => {  // If you use async function in the auth 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
+ * auth: {
+ *   enabled: true,
+ *   saveToFile: true,
+ *   inject: 'login',
+ *   users: {
+ *     admin: {
+ *       login: async (I) => {  // If you use async function in the auth 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
+    loadCookiesFromFile(config)
+  }
+
+  const loginFunction = async name => {
+    const I = container.support('I')
+    const userSession = config.users[name]
+
+    if (!userSession) {
+      throw new Error(`User '${name}' was not configured for authorization in auth plugin. Add it to the plugin config`)
+    }
+
+    const test = store.currentTest
+
+    // we are in BeforeSuite hook
+    if (!test) {
+      enableAuthBeforeEachTest(name)
+      return
+    }
+
+    const section = new Section(`I am logged in as ${name}`)
+
+    if (config.saveToFile && !store[`${name}_session`]) {
+      loadCookiesFromFile(config)
+    }
+
+    if (isPlaywrightSession() && test?.opts?.cookies) {
+      if (test.opts.user == name) {
+        debug(`Cookies already loaded for ${name}`)
+
+        alreadyLoggedIn(name)
+        return
+      } else {
+        debug(`Cookies already loaded for ${test.opts.user}, but not for ${name}`)
+        await I.deleteCookie()
+      }
+    }
+
+    section.start()
+
+    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)
+      }
+
+      section.end()
+      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)
+    }
+    section.end()
+    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')
+          section.end()
+          recorder.throw(err)
+        })
+    })
+    recorder.add(() => {
+      recorder.session.restore('check login')
+    })
+
+    return recorder.promise()
+  }
+
+  function enableAuthBeforeEachTest(name) {
+    const suite = store.currentSuite
+    if (!suite) return
+
+    debug(`enabling auth as ${name} for each test of suite ${suite.title}`)
+
+    // we are setting test opts so they can be picked up by Playwright if it starts browser for this test
+    suite.eachTest(test => {
+      // preload from store
+      if (store[`${name}_session`]) {
+        test.opts.cookies = store[`${name}_session`]
+        test.opts.user = name
+        return
+      }
+
+      if (!config.saveToFile) return
+      const cookieFile = path.join(global.output_dir, `${name}_session.json`)
+
+      if (!fileExists(cookieFile)) {
+        return
+      }
+
+      const context = fs.readFileSync(cookieFile).toString()
+      test.opts.cookies = JSON.parse(context)
+      test.opts.user = name
+    })
+
+    function runLoginFunctionForTest(test) {
+      if (!suite.tests.includes(test)) return
+      // let's call this function to ensure that authorization happened
+      // if no cookies, it will login and save them
+      loginFunction(name)
+    }
+
+    // we are in BeforeSuite hook
+    event.dispatcher.on(event.test.started, runLoginFunctionForTest)
+    event.dispatcher.on(event.suite.after, () => {
+      event.dispatcher.off(event.test.started, runLoginFunctionForTest)
+    })
+  }
+
+  // adding this to DI container
+  const support = {}
+  support[config.inject] = loginFunction
+  container.append({ support })
+
+  return loginFunction
+}
+
+function loadCookiesFromFile(config) {
+  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}`)
+  }
+}
+
+function isPlaywrightSession() {
+  return !!container.helpers('Playwright')
+}
+
+function alreadyLoggedIn(name) {
+  const step = new CommentStep('am logged in as')
+  step.actor = 'I'
+  return step.addToRecorder([name])
+}

package/lib/plugin/autoDelay.js

@@ -2,8 +2,8 @@ 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 { log } = require('../output')
+const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
 
 const methodsToDelay = ['click', 'fillField', 'checkOption', 'pressKey', 'doubleClick', 'rightClick']