@zohodesk/testinglibrary 2.9.5 → 2.9.7

package/.gitlab-ci.yml

@@ -14,18 +14,23 @@ stages:
 
 default:
   cache:
-    key: build-cache
+    key: node14-build-cache
     paths:
       - node_modules
       - build
+      - npm-shrinkwrap.json
 
 # Install dependencies stage
 build:
   stage: build
   script:
+    - npm -v
+    - node -v
     - npm install --ignore-scripts
     - npm run build
     - npm install
+    - npm shrinkwrap
+    - npm run build
 
 # Unit tests stage
 unit:

package/build/core/playwright/builtInFixtures/page.js

@@ -1,12 +1,10 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 var _auth = require("../helpers/auth");
-var _getUrlOrigin = _interopRequireDefault(require("../helpers/auth/getUrlOrigin"));
 var _readConfigFile = require("../readConfigFile");
 /* eslint-disable global-require */
 
@@ -29,84 +27,68 @@ function getCustomAccountDetails(tags) {
     const user = (0, _auth.getUserForSelectedEditionAndProfile)(editionInfo, profileInfo, betaFeature, portalInfo);
     return user;
   }
-  return null;
+  return (0, _auth.getDefaultActor)();
 }
 const {
   testSetup
 } = (0, _readConfigFile.generateConfigFromFile)();
-async function performDefaultPageSteps({
-  context,
-  $tags,
-  page
-}) {
-  if (testSetup.page && typeof testSetup.page === 'function') {
-    await testSetup.page({
-      context,
-      $tags,
-      page
-    });
+async function loginSteps(pageDetail) {
+  const {
+    page
+  } = pageDetail;
+  if (testSetup.loginSteps && typeof testSetup.loginSteps === 'function') {
+    return await testSetup.loginSteps(pageDetail);
   } else {
     await page.goto(process.env.domain);
   }
 }
-async function verifyPageIsLoaded(page) {
-  const urlOrigin = (0, _getUrlOrigin.default)(page.url());
-  const domainOrigin = (0, _getUrlOrigin.default)(process.env.domain);
-  if (urlOrigin === domainOrigin) {
-    return true;
+async function performDefaultPageSteps(testInfo) {
+  if (testSetup.page && typeof testSetup.page === 'function') {
+    await testSetup.page(testInfo);
+  }
+}
+async function verifyPageIsLoaded(testInfo) {
+  if (testSetup.validateLogin && typeof testSetup.validateLogin === 'function') {
+    return await testSetup.validateLogin(testInfo);
   }
-  return false;
+  return true;
 }
 var _default = exports.default = {
   page: async ({
     context,
     $tags,
     page
-  }, use) => {
-    const {
-      isAuthMode
-    } = (0, _readConfigFile.generateConfigFromFile)();
-    if (!isAuthMode) {
-      await use(page);
-      return;
-    }
-
-    //This block is used to skip the login process if the @unauthenticated tag is added to the script
-    if ($tags.includes('@unauthenticated')) {
-      await context.clearCookies();
-      await use(page);
-      return;
-    }
-    const testPortalDetails = getCustomAccountDetails($tags);
-    if (testPortalDetails === null) {
-      await performDefaultPageSteps({
-        context,
-        $tags,
-        page
-      });
-      const user = (0, _auth.getDefaultActor)();
-      process.env.actorInfo = JSON.stringify(user);
-      await use(page);
-    } else {
-      await context.clearCookies();
+  }, use, testInfo) => {
+    let testPortalDetails = getCustomAccountDetails($tags);
+    let testDetails = {
+      page,
+      $tags,
+      context,
+      ...testPortalDetails
+    };
+    try {
+      //This block is used to skip the login process if the @unauthenticated tag is added to the script
+      if ($tags.includes('@unauthenticated')) {
+        await context.clearCookies();
+        return;
+      }
       const {
-        email,
-        password
-      } = testPortalDetails;
-      await (0, _auth.performLoginSteps)({
-        page,
-        authFilePrefix: email,
-        useremail: email,
-        password: password
-      }, async () => {
-        return await verifyPageIsLoaded(page);
-      });
-      process.env.actorInfo = JSON.stringify(testPortalDetails);
-      await performDefaultPageSteps({
-        context,
-        $tags,
-        page
-      });
+        isAuthMode
+      } = (0, _readConfigFile.generateConfigFromFile)();
+      if (!isAuthMode) {
+        return;
+      }
+      if (testPortalDetails && testInfo.project.name !== 'setup') {
+        await context.clearCookies();
+        await (0, _auth.performLoginSteps)(testDetails, async testInfo => {
+          return await verifyPageIsLoaded(testInfo);
+        }, loginSteps);
+        process.env.actorInfo = JSON.stringify(testPortalDetails);
+      }
+    } catch (e) {
+      console.error('Error during page', e);
+    } finally {
+      await performDefaultPageSteps(testDetails);
       await use(page);
       await context.close();
     }

package/build/core/playwright/helpers/auth/loginSteps.js

@@ -8,41 +8,38 @@ exports.default = void 0;
 var _path = _interopRequireDefault(require("path"));
 var _fileMutex = _interopRequireDefault(require("../fileMutex"));
 var _fileMutexConfig = require("../../constants/fileMutexConfig");
-var _accountLogin = _interopRequireDefault(require("./accountLogin"));
 var _checkAuthCookies = require("./checkAuthCookies");
 var _checkAuthDirectory = require("../checkAuthDirectory");
 /* eslint-disable no-console */
 
-async function performLoginSteps({
-  page,
-  authFilePrefix,
-  useremail,
-  password
-}, isLoggedIn) {
+async function performLoginSteps(testInfo, isLoggedIn, loginSteps) {
+  let {
+    page,
+    authFilePrefix,
+    email
+  } = testInfo;
+  authFilePrefix = authFilePrefix || email;
   const authFile = _path.default.resolve(_path.default.join((0, _checkAuthCookies.getAuthFileDirectory)(), `${authFilePrefix}-cookies.json`));
-  const lockFileName = useremail.replace(/[@.]/g, '_');
+  const lockFileName = email.replace(/[@.]/g, '_');
   const fileMutex = new _fileMutex.default((0, _checkAuthDirectory.getLockDirectoryPath)(), lockFileName, _fileMutexConfig.LOGIN_MUTEX_TIMEOUT);
   try {
     await fileMutex.acquire();
     await (0, _checkAuthCookies.loadCookiesIfPresent)(page, authFile);
-    await page.goto(process.env.domain);
-    await Promise.race([page.waitForNavigation(), page.waitForLoadState('networkidle'), page.waitForTimeout(5000)]);
-    const isAlreadyLoggedIn = await isLoggedIn(page);
+    const isAlreadyLoggedIn = await isLoggedIn(testInfo);
     if (!isAlreadyLoggedIn) {
-      await (0, _accountLogin.default)(page, useremail, password);
-      await page.goto(process.env.domain);
-      await isLoggedIn(page);
+      await loginSteps(testInfo);
+      await isLoggedIn(testInfo);
       await page.context().storageState({
         path: authFile
       });
     }
   } catch (error) {
-    console.error(`Error during login for ${useremail}:`, error);
+    console.error(`Error during login for ${email}:`, error);
   } finally {
     try {
       await fileMutex.release();
     } catch (releaseError) {
-      console.error(`Error releasing lock for ${useremail}:`, releaseError);
+      console.error(`Error releasing lock for ${email}:`, releaseError);
     }
   }
 }

package/build/core/playwright/tagProcessor.js

@@ -10,12 +10,14 @@ class TagProcessor {
     _classPrivateMethodInitSpec(this, _TagProcessor_brand);
     this.editionOrder = editionOrder;
   }
-  processTags(userArgs) {
-    const tagArgs = userArgs['tags'] || '';
-    const edition = userArgs['edition'] || null;
-    if (!edition) return tagArgs;
+  processTags(config) {
+    const {
+      tags,
+      edition
+    } = config.getAll();
+    if (!edition) return tags;
     const editionsArray = edition.split(',');
-    const editionTags = editionsArray.length === 1 ? _assertClassBrand(_TagProcessor_brand, this, _processSingleEdition).call(this, editionsArray[0], tagArgs) : _assertClassBrand(_TagProcessor_brand, this, _processMultipleEditions).call(this, editionsArray, tagArgs);
+    const editionTags = editionsArray.length === 1 ? _assertClassBrand(_TagProcessor_brand, this, _processSingleEdition).call(this, editionsArray[0], tags) : _assertClassBrand(_TagProcessor_brand, this, _processMultipleEditions).call(this, editionsArray, tags);
     return editionTags;
   }
 }

package/build/core/playwright/test-runner.js

@@ -104,7 +104,7 @@ function main() {
   //This is only used for pass the user arguments to need places in legacy code. We need to rewamp that also.
   const userArgsObject = userArgConfig.getAll();
   const tagProcessor = new _tagProcessor.default(editionOrder);
-  const tagArgs = tagProcessor.processTags(userArgsObject);
+  const tagArgs = tagProcessor.processTags(uatConfig);
   const runnerObj = new _Runner.default();
   runnerObj.setTagArgs(tagArgs);
   runnerObj.setUserArgs(userArgsObject);

package/build/test/core/playwright/__tests__/tagProcessor.test.js

@@ -2,6 +2,7 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _tagProcessor = _interopRequireDefault(require("../../../../../src/core/playwright/tagProcessor"));
+var _Configuration = _interopRequireDefault(require("../../../../../src/core/playwright/configuration/Configuration.js"));
 var _logger = require("../../../../utils/logger");
 jest.mock('../../../../utils/logger');
 describe('TagProcessor', () => {
@@ -11,83 +12,83 @@ describe('TagProcessor', () => {
   });
   test('should return tagArgs if no edition is provided', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: null
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1');
   });
   test('should handle a single edition with <= operator', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: '<=edition2'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition3 or @edition_edition4)');
   });
   test('should handle a single edition with >= operator', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: '>=edition2'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition1)');
   });
   test('should handle a single edition with < operator', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: '<edition3'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition3 or @edition_edition4)');
   });
   test('should handle a single edition with > operator', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: '>edition1'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition1)');
   });
   test('should handle a single edition with no operator', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: 'edition2'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition1 or @edition_edition3 or @edition_edition4)');
   });
   test('should log a message if edition is not found', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: 'nonexistentEdition'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1');
     expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.INFO_TYPE, expect.stringContaining('No matching editions for nonexistentEdition found.'));
   });
   test('should handle multiple editions', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: 'edition1,edition3'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition2 or @edition_edition4)');
   });
   test('should build tags correctly when tags are empty', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: '',
       edition: 'edition1'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('not (@edition_edition2 or @edition_edition3 or @edition_edition4)');
   });