@zohodesk/testinglibrary 3.0.4 → 3.0.8

package/.gitlab-ci.yml

@@ -18,14 +18,19 @@ default:
     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:
@@ -45,9 +50,7 @@ uat-auth:
     - npm install $(npm pack ../../testing-framework | tail -1)
     - output=$(npm run uatauth)
     - echo "$output"
-    - if [[ "$output" == *"failed"* ]]; then
-    -   exit 1
-    - fi
+    - node ../ValidateUATReport.js examples
 
   artifacts:
     when: always
@@ -61,9 +64,7 @@ uat-noauth:
     - npm install $(npm pack ../../testing-framework | tail -1)
     - output=$(npm run uatnoauth)
     - echo "$output"
-    - if [[ "$output" == *"failed"* ]]; then
-    -   exit 1
-    - fi
+    - node ../ValidateUATReport.js examples
 
   artifacts:
     when: always
@@ -77,9 +78,23 @@ uat-profile:
     - npm install $(npm pack ../../testing-framework | tail -1)
     - output=$(npm run uatprofile)
     - echo "$output"
-    - if [[ "$output" == *"failed"* ]]; then
-    -   exit 1
-    - fi
+    - node ../ValidateUATReport.js examples
+
+  artifacts:
+    when: always
+    paths:
+      - examples/uat/playwright-report 
+
+
+uat-unauth:
+  stage: uat
+  script:
+    - cd examples
+    - npm install $(npm pack ../../testing-framework | tail -1)
+    - output=$(npm run uatunauth)
+    - echo "$output"
+    - node ../ValidateUATReport.js examples
+
 
   artifacts:
     when: always
@@ -91,11 +106,9 @@ uat-nobdd:
   script:
     - cd nobdd
     - npm install $(npm pack ../../testing-framework | tail -1)
-    - output=$(npm run uatnobdd)
+    - output=$(npm run uatnobdd -- --headless)
     - echo "$output"
-    - if [[ "$output" == *"failed"* ]]; then
-    -   exit 1
-    - fi
+    - node ../ValidateUATReport.js nobdd
 
 
   artifacts:

package/README.md

@@ -29,6 +29,28 @@
 
 ## Version History
 
+### v3.0.8 - 25-12-2024
+
+#### Enhancement
+  - Added support to disable headless mode using command line arguments
+  - Proper validation added for node 14 build process
+  - Removed unwanted uat.config.js files in test projects (examples / nobdd)
+
+### v0.2.9.2 - 22-11-2024   
+
+#### BugFix
+  - Implemented synchronization for the login process. This fix will help avoid login session-related failures in UAT.
+  
+### v0.3.1 - 13-11-2024
+
+#### Issue Fix
+- Adding bddmode to get the fixtures.
+
+### v0.2.9.1 - 14-11-2024
+
+#### Enhancement
+   - Beta feature Actors and edition configurations are unified 
+
 ### v0.2.9 - 25-10-2024
 
 #### Feature
@@ -60,6 +82,11 @@
 #### Issue Fix
 - Adding bddmode to get the fixtures.
 
+### v0.3.3 - 27-11-2024
+
+#### Feature
+- Custom report integration support (ReportPortal)
+
 ### v0.2.9.1 - 14-11-2024
 
 #### Enhancement

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 */
 
@@ -34,6 +32,16 @@ function getCustomAccountDetails(tags) {
 const {
   testSetup
 } = (0, _readConfigFile.generateConfigFromFile)();
+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 performDefaultPageSteps({
   context,
   $tags,
@@ -49,13 +57,11 @@ async function performDefaultPageSteps({
     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 verifyPageIsLoaded(testInfo) {
+  if (testSetup.validateLogin && typeof testSetup.validateLogin === 'function') {
+    return await testSetup.validateLogin(testInfo);
   }
-  return false;
+  return true;
 }
 var _default = exports.default = {
   page: async ({
@@ -63,38 +69,37 @@ var _default = exports.default = {
     $tags,
     page
   }, use) => {
-    const {
-      isAuthMode
-    } = (0, _readConfigFile.generateConfigFromFile)();
-    if (!isAuthMode) {
-      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();
+    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);
+        isAuthMode
+      } = (0, _readConfigFile.generateConfigFromFile)();
+      if (!isAuthMode) {
+        return;
+      }
+      const testPortalDetails = getCustomAccountDetails($tags);
+      if (testPortalDetails) {
+        await context.clearCookies();
+        const {
+          email
+        } = testPortalDetails;
+        await (0, _auth.performLoginSteps)({
+          page,
+          $tags,
+          context,
+          ...testPortalDetails
+        }, async testInfo => {
+          return await verifyPageIsLoaded(testInfo);
+        }, loginSteps);
+        process.env.actorInfo = JSON.stringify(testPortalDetails);
+      }
+    } catch (error) {
+      console.error('Error during page', error);
+    } finally {
       await performDefaultPageSteps({
         context,
         $tags,

package/build/core/playwright/constants/fileMutexConfig.js

@@ -5,7 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.LOGIN_MUTEX_TIMEOUT = void 0;
 const LOGIN_MUTEX_TIMEOUT = exports.LOGIN_MUTEX_TIMEOUT = {
-  "wait": 300000,
-  "retries": 600,
-  "stale": 240000
+  stale: 100000,
+  retries: {
+    retries: 10,
+    factor: 1,
+    minTimeout: 10000,
+    maxTimeout: 20000
+  }
 };

package/build/core/playwright/custom-commands.js

@@ -4,4 +4,4 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.CUSTOM_COMMANDS = void 0;
-const CUSTOM_COMMANDS = exports.CUSTOM_COMMANDS = ['mode', 'tags', 'edition', 'browsers', 'filePath'];
+const CUSTOM_COMMANDS = exports.CUSTOM_COMMANDS = ['mode', 'tags', 'edition', 'browsers', 'filePath', 'headless'];

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

@@ -8,40 +8,41 @@ 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 fileMutex = new _fileMutex.default((0, _checkAuthCookies.getAuthFileDirectory)(), lockFileName, _fileMutexConfig.LOGIN_MUTEX_TIMEOUT);
+  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 loginSteps(testInfo);
       await page.goto(process.env.domain);
-      await isLoggedIn(page);
+      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/helpers/checkAuthDirectory.js

@@ -1,11 +1,15 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createAuthDirectoryIfNotExist = createAuthDirectoryIfNotExist;
+exports.getLockDirectoryPath = getLockDirectoryPath;
 var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
 var _checkAuthCookies = require("./auth/checkAuthCookies");
+var _readConfigFile = require("../readConfigFile");
 function createAuthDirectoryIfNotExist() {
   const authDirectory = (0, _checkAuthCookies.getAuthFileDirectory)();
   if (!(0, _fs.existsSync)(authDirectory)) {
@@ -14,4 +18,10 @@ function createAuthDirectoryIfNotExist() {
       recursive: true
     });
   }
+}
+function getLockDirectoryPath() {
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  return _path.default.resolve(_path.default.join(uatDirectory, 'playwright', '.lock'));
 }

package/build/core/playwright/helpers/fileMutex.js

@@ -6,45 +6,42 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _path = _interopRequireDefault(require("path"));
-var _lockfile = _interopRequireDefault(require("lockfile"));
+var _properLockfile = _interopRequireDefault(require("proper-lockfile"));
 var _fs = require("fs");
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
 function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
 var _FileMutex_brand = /*#__PURE__*/new WeakSet();
 class FileMutex {
-  constructor(directory, lockFileName, timeout) {
+  constructor(directory, lockFileName, options = {}) {
     _classPrivateMethodInitSpec(this, _FileMutex_brand);
     this.directory = directory;
-    this.lockFileName = lockFileName;
-    this.timeout = timeout;
+    this.lockFileName = lockFileName + ".lock";
+    this.options = options;
   }
   async acquire() {
     _assertClassBrand(_FileMutex_brand, this, _createDirectoryIfNotExist).call(this);
-    return new Promise((resolve, reject) => {
-      _lockfile.default.lock(_assertClassBrand(_FileMutex_brand, this, _getLockFilePath).call(this), this.timeout, err => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve();
-        }
-      });
-    });
+    const lockFilePath = _assertClassBrand(_FileMutex_brand, this, _getLockFilePath).call(this);
+    try {
+      if (!(0, _fs.existsSync)(lockFilePath)) {
+        console.log(`[DEBUG] Creating missing lock file:`, this.lockFileName);
+        (0, _fs.writeFileSync)(lockFilePath, 'locked');
+      }
+      await _properLockfile.default.lock(lockFilePath, this.options);
+    } catch (err) {
+      throw new Error(`Failed to acquire lock after ${this.options.retries.retries} attempts: ${err.message}`);
+    }
   }
   async release() {
-    return new Promise((resolve, reject) => {
-      _lockfile.default.unlock(_assertClassBrand(_FileMutex_brand, this, _getLockFilePath).call(this), err => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve();
-        }
-      });
-    });
+    try {
+      await _properLockfile.default.unlock(_assertClassBrand(_FileMutex_brand, this, _getLockFilePath).call(this));
+    } catch (err) {
+      throw new Error(`Failed to release lock: ${err.message}`);
+    }
   }
 }
 function _getLockFilePath() {
-  return _path.default.resolve(_path.default.join(this.directory, `/${this.lockFileName}.lock`));
+  return _path.default.resolve(_path.default.join(this.directory, this.lockFileName));
 }
 function _createDirectoryIfNotExist() {
   if (!(0, _fs.existsSync)(this.directory)) {

package/build/core/playwright/runner/Runner.js

@@ -0,0 +1,22 @@
+"use strict";
+
+class Runner {
+  constructor(config) {
+    this.tagArgs = "";
+    this.userArgs = "";
+    this.config = config;
+  }
+  setUserArgs(userArgs) {
+    this.userArgs = userArgs;
+  }
+  setTagArgs(tagArgs) {
+    this.tagArgs = tagArgs;
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+  run() {
+    throw new Error("Method 'run()' must be implemented.");
+  }
+}
+module.exports = Runner;

package/build/core/playwright/runner/RunnerHelper.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _RunnerTypes = _interopRequireDefault(require("./RunnerTypes"));
+var _configUtils = require("../setup/config-utils");
+var _cliArgsToObject = require("../../../utils/cliArgsToObject");
+var _browserTypes = require("../constants/browserTypes");
+var _customCommands = require("../custom-commands");
+class RunnerHelper {
+  static createRunner(type, runnerObj) {
+    const runnerClass = _RunnerTypes.default.getRunnerClass(type, runnerObj);
+    if (!runnerClass) {
+      throw new Error("Invalid runner type");
+    }
+    return runnerClass;
+  }
+  static getPlaywrightArgs(userArgsObject, debug, bddMode, tagArgs, headless) {
+    const {
+      browsers = null
+    } = userArgsObject;
+    let browserList = (0, _configUtils.getBrowsersList)(browsers);
+    const playwrightArgs = (0, _cliArgsToObject.objectToCliArgs)(userArgsObject, key => !_customCommands.CUSTOM_COMMANDS.includes(key));
+    if (debug) {
+      playwrightArgs.push('--debug');
+    }
+    if (!bddMode && tagArgs) {
+      playwrightArgs.push('--grep');
+      playwrightArgs.push(tagArgs);
+    }
+    if (!headless && !userArgsObject.headed) {
+      playwrightArgs.push('--headed');
+    }
+    if (browserList && browserList.length > 0) {
+      browserList.map(browser => playwrightArgs.push(`--project=${_browserTypes.BROWSER_PROJECT_MAPPING[browser.toUpperCase()]}`));
+    }
+    return playwrightArgs;
+  }
+}
+var _default = exports.default = RunnerHelper;

package/build/core/playwright/runner/RunnerTypes.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _SpawnRunner = _interopRequireDefault(require("./SpawnRunner"));
+class RunnerTypes {
+  static getRunnerClass(type, runnerObj) {
+    const RunnerClass = this.runnerTypes[type];
+    if (!RunnerClass) {
+      throw new Error("Invalid runner type");
+    }
+    return new RunnerClass(runnerObj);
+  }
+  static runnerTypes = {
+    spawn: _SpawnRunner.default //require("./SpawnRunner"), // used lazy loading to reduce circular dependencies 
+  };
+}
+module.exports = RunnerTypes;

package/build/core/playwright/runner/SpawnRunner.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _readConfigFile = require("../readConfigFile");
+var _rootPath = require("../../../utils/rootPath");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../../utils/logger");
+var _child_process = require("child_process");
+var _RunnerHelper = _interopRequireDefault(require("./RunnerHelper"));
+var _Runner = _interopRequireDefault(require("./Runner"));
+class SpawnRunner extends _Runner.default {
+  constructor(runnerObj) {
+    super(runnerObj);
+    this.runnerObj = runnerObj;
+  }
+  run() {
+    const {
+      config
+    } = this.runnerObj;
+    let promises = [];
+    const {
+      bddMode
+    } = config.getAll();
+    if (bddMode) {
+      promises.push(this.runPreprocessing());
+    }
+    Promise.all(promises).then(() => this.runPlaywright()).catch(err => {
+      _logger.Logger.error(err);
+      process.exit();
+    });
+  }
+  runPreprocessing() {
+    const {
+      tagArgs
+    } = this.runnerObj;
+    const configPath = (0, _readConfigFile.isUserConfigFileAvailable)() ? _path.default.resolve(__dirname, '../', 'setup', 'config-creator.js') : _path.default.resolve(__dirname, '../', '../', '../', '../', 'playwrightConfig.js');
+    const beforeCommand = 'node';
+    const bddGenPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('bddgen'));
+    const beforeArgs = [bddGenPath, '-c', require.resolve(configPath)];
+    if (tagArgs) {
+      beforeArgs.push('--tags');
+      beforeArgs.push(tagArgs);
+    }
+    return new Promise((resolve, reject) => {
+      const childProcessForPreprocessing = (0, _child_process.spawn)(beforeCommand, beforeArgs, {
+        stdio: 'inherit',
+        env: {
+          ...process.env
+        }
+      });
+      childProcessForPreprocessing.on('error', data => {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, data);
+        reject(data);
+      });
+      childProcessForPreprocessing.on('exit', code => {
+        if (code === 0) {
+          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Feature Files Processed Successfully');
+          resolve();
+        } else {
+          reject(`BddGen exited with code ${code}`);
+        }
+      });
+    });
+  }
+  runPlaywright() {
+    const {
+      tagArgs,
+      config,
+      userArgs
+    } = this.runnerObj;
+    const {
+      debug,
+      bddMode = false,
+      headless = false
+    } = config.getAll();
+    const playwrightArgs = _RunnerHelper.default.getPlaywrightArgs(userArgs, debug, bddMode, tagArgs, headless);
+    const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
+    const command = playwrightPath;
+    const configPath = (0, _readConfigFile.isUserConfigFileAvailable)() ? _path.default.resolve(__dirname, '../', 'setup', 'config-creator.js') : _path.default.resolve('../', '../', '../', '../', 'playwrightConfig.js');
+    const args = ['test', '--config', require.resolve(configPath)].concat(playwrightArgs);
+    return new Promise((resolve, reject) => {
+      const childProcessForRunningPlaywright = (0, _child_process.spawn)(command, args, {
+        stdio: 'inherit',
+        env: {
+          ...process.env
+        }
+      });
+      childProcessForRunningPlaywright.on('error', error => {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error);
+      });
+      childProcessForRunningPlaywright.on('exit', (code, signal) => {
+        if (code !== 0) {
+          reject(`Child Process Exited with Code ${code} and Signal ${signal}`);
+        } else {
+          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Test Ran Successfully');
+          resolve();
+        }
+      });
+      process.on('exit', () => {
+        childProcessForRunningPlaywright.kill();
+        reject('Terminating Playwright Process...');
+      });
+      process.on('SIGINT', () => {
+        childProcessForRunningPlaywright.kill();
+        reject('Cleaning up...');
+      });
+    });
+  }
+}
+module.exports = SpawnRunner;

package/build/core/playwright/setup/config-creator.js

@@ -25,7 +25,8 @@ const {
   featureFilesFolder,
   stepDefinitionsFolder,
   testIdAttribute,
-  globalTimeout
+  globalTimeout,
+  customReporter
 } = uatConfig;
 const projects = (0, _configUtils.getProjects)({
   browsers,
@@ -45,6 +46,13 @@ const use = {
   viewport,
   testIdAttribute
 };
+let reporter = [['html', {
+  outputFolder: reportPath,
+  open: openReportOn
+}], ['list'], ['./custom-reporter.js']];
+if (customReporter) {
+  reporter = [customReporter, ...reporter];
+}
 
 /**
  * Playwright configuration object
@@ -57,10 +65,7 @@ function getPlaywrightConfig() {
     globalTimeout: globalTimeout || 3600000,
     outputDir: _path.default.join(process.cwd(), 'uat', 'test-results'),
     fullyParallel: true,
-    reporter: [['html', {
-      outputFolder: reportPath,
-      open: openReportOn
-    }], ['list'], ['./custom-reporter.js']],
+    reporter,
     timeout: testTimeout,
     expect: {
       timeout: expectTimeout