codeceptjs 4.0.0-beta.2 → 4.0.0-beta.20

package/lib/plugin/{autoLogin.js → auth.js}

@@ -1,24 +1,27 @@
-import fs from 'fs';
-import path from 'path';
-import { fileExists, isAsyncFunction } from '../utils.js';
-import container from '../container.js';
-import { store } from '../store.js';
-import recorder from '../recorder.js';
-import { debug } from '../output.js';
+import fs from 'fs'
+import path from 'path'
+import { fileExists, isAsyncFunction } from '../utils.js'
+import CommentStep from '../step/comment.js'
+import Section from '../step/section.js'
+import container from '../container.js'
+import store from '../store.js'
+import event from '../event.js'
+import recorder from '../recorder.js'
+import output from '../output.js'
 
 const defaultUser = {
   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.
@@ -71,7 +74,7 @@ const defaultConfig = {
  * #### Example: Simple login
  *
  * ```js
- * autoLogin: {
+ * auth: {
  *   enabled: true,
  *   saveToFile: true,
  *   inject: 'login',
@@ -92,7 +95,7 @@ const defaultConfig = {
  * #### Example: Multiple users
  *
  * ```js
- * autoLogin: {
+ * auth: {
  *   enabled: true,
  *   saveToFile: true,
  *   inject: 'loginAs', // use `loginAs` instead of login
@@ -139,7 +142,7 @@ const defaultConfig = {
  *    }
  * },
  * plugins: {
- *    autoLogin: {
+ *    auth: {
  *      users: {
  *        admin: {
  *          login: (I) => {
@@ -166,7 +169,7 @@ const defaultConfig = {
  *
  * ```js
  * plugins: {
- *    autoLogin: {
+ *    auth: {
  *     admin: {
  *       login: (I) => I.loginAsAdmin(),
  *       check: (I) => I.see('Admin', '.navbar'),
@@ -182,18 +185,18 @@ const defaultConfig = {
  * }
  * ```
  *
- * #### Tips: Using async function in the autoLogin
+ * #### Tips: Using async function in the auth
  *
- * If you use async functions in the autoLogin plugin, login function should be used with `await` keyword.
+ * If you use async functions in the auth plugin, login function should be used with `await` keyword.
  *
  * ```js
- * autoLogin: {
+ * auth: {
  *   enabled: true,
  *   saveToFile: true,
  *   inject: 'login',
  *   users: {
  *     admin: {
- *       login: async (I) => {  // If you use async function in the autoLogin plugin
+ *       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')
@@ -219,13 +222,13 @@ const defaultConfig = {
  * Instead of asserting on page elements for the current user in `check`, you can use the `session` you saved in `fetch`
  *
  * ```js
- * autoLogin: {
+ * auth: {
  *   enabled: true,
  *   saveToFile: true,
  *   inject: 'login',
  *   users: {
  *     admin: {
- *       login: async (I) => {  // If you use async function in the autoLogin plugin
+ *       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')
@@ -248,88 +251,184 @@ const defaultConfig = {
  * })
  *
  *
-*/
+ */
 export default 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();
-      try {
-        store[`${name}_session`] = JSON.parse(data);
-      } catch (err) {
-        throw new Error(`Could not load session from ${fileName}\n${err}`);
+    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) {
+        output.debug(`Cookies already loaded for ${name}`)
+
+        alreadyLoggedIn(name)
+        return
+      } else {
+        output.debug(`Cookies already loaded for ${test.opts.user}, but not for ${name}`)
+        await I.deleteCookie()
       }
-      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);
+    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);
+        await userSession.login(I)
       } else {
-        userSession.login(I);
+        userSession.login(I)
       }
 
-      const cookies = await userSession.fetch(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;
+        output.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));
+        output.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);
-      });
-    });
+    section.end()
+    recorder.session.catch(err => {
+      output.debug(`Failed auto login for ${name} due to ${err}`)
+      output.debug('Logging in again')
+      recorder.session.start('auto login')
+      return loginAndSave()
+        .then(() => {
+          recorder.add(() => recorder.session.restore('auto login'))
+          recorder.catch(() => output.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');
-    });
+      recorder.session.restore('check login')
+    })
+
+    return recorder.promise()
+  }
 
-    return recorder.promise();
-  };
+  function enableAuthBeforeEachTest(name) {
+    const suite = store.currentSuite
+    if (!suite) return
+
+    output.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 });
+  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}`)
+    }
+    output.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

@@ -1,25 +1,21 @@
-import Container from '../container.js';
-import { store } from '../store.js';
-import recorder from '../recorder.js';
-import * as event from '../event.js';
-import { log } from '../output.js';
+import Container from '../container.js'
 
-const supportedHelpers = require('./standardActingHelpers.js').slice();
+import store from '../store.js'
 
-const methodsToDelay = [
-  'click',
-  'fillField',
-  'checkOption',
-  'pressKey',
-  'doubleClick',
-  'rightClick',
-];
+import recorder from '../recorder.js'
+
+import event from '../event.js'
+
+import output from '../output.js'
+const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
+
+const methodsToDelay = ['click', 'fillField', 'checkOption', 'pressKey', 'doubleClick', 'rightClick']
 
 const defaultConfig = {
   methods: methodsToDelay,
   delayBefore: 100,
   delayAfter: 200,
-};
+}
 
 /**
  *
@@ -60,41 +56,41 @@ const defaultConfig = {
  *
  */
 export default function (config) {
-  supportedHelpers.push('REST');
-  const helpers = Container.helpers();
-  let helper;
+  const affectedHelpers = [...standardActingHelpers, 'REST']
+  const helpers = Container.helpers()
+  let helper
 
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
 
-  for (const helperName of supportedHelpers) {
+  for (const helperName of affectedHelpers) {
     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
+  event.dispatcher.on(event.step.before, step => {
+    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`);
-      return new Promise((resolve) => {
-        setTimeout(resolve, config.delayBefore);
-      });
-    });
-  });
+      if (store.debugMode) return // no need to delay in debug
+      output.log(`Delaying for ${config.delayBefore}ms`)
+      return new Promise(resolve => {
+        setTimeout(resolve, config.delayBefore)
+      })
+    })
+  })
 
-  event.dispatcher.on(event.step.after, (step) => {
-    if (config.methods.indexOf(step.helperMethod) < 0) return; // skip non-actions
+  event.dispatcher.on(event.step.after, step => {
+    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`);
-      return new Promise((resolve) => {
-        setTimeout(resolve, config.delayAfter);
-      });
-    });
-  });
+      if (store.debugMode) return // no need to delay in debug
+      output.log(`Delaying for ${config.delayAfter}ms`)
+      return new Promise(resolve => {
+        setTimeout(resolve, config.delayAfter)
+      })
+    })
+  })
 }