@zohodesk/testinglibrary 2.9.1 → 2.9.3

package/.gitlab-ci.yml

@@ -1,29 +1,35 @@
 image: repository.desk.csez.zohocorpin.com/base-image/testing-framework-gitlab-runne-base:v2
 
-#workflow:
-#  rules:
-#    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+workflow:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+      when: always
+    - if: $CI_PIPELINE_SOURCE == "web"
+      when: always
 
 stages:
   - build
   - unit
   - uat
 
+default:
+  cache:
+    key: build-cache
+    paths:
+      - node_modules
+      - build
+
 # Install dependencies stage
 build:
   stage: build
-  image: repository.desk.csez.zohocorpin.com/base-image/testing-framework-gitlab-runne-base:v2
   script:
+    - npm install --ignore-scripts
+    - npm run build
     - npm install
-  artifacts:
-    paths:
-      - node_modules/
-
 
 # Unit tests stage
 unit:
   stage: unit
-  image: repository.desk.csez.zohocorpin.com/base-image/testing-framework-gitlab-runne-base:v2
   script:
     - npm run test
   artifacts:
@@ -34,10 +40,7 @@ unit:
 # UAT tests stage
 uat-auth:
   stage: uat
-  image: repository.desk.csez.zohocorpin.com/base-image/testing-framework-gitlab-runne-base:v2
   script:
-    - npm install 
-    - npm run build
     - cd examples
     - npm install $(npm pack ../../testing-framework | tail -1)
     - output=$(npm run uatauth)
@@ -53,10 +56,7 @@ uat-auth:
 
 uat-noauth:
   stage: uat
-  image: repository.desk.csez.zohocorpin.com/base-image/testing-framework-gitlab-runne-base:v2
   script:
-    - npm install 
-    - npm run build
     - cd examples
     - npm install $(npm pack ../../testing-framework | tail -1)
     - output=$(npm run uatnoauth)
@@ -72,10 +72,7 @@ uat-noauth:
     
 uat-profile:
   stage: uat
-  image: repository.desk.csez.zohocorpin.com/base-image/testing-framework-gitlab-runne-base:v2
   script:
-    - npm install 
-    - npm run build
     - cd examples
     - npm install $(npm pack ../../testing-framework | tail -1)
     - output=$(npm run uatprofile)
@@ -89,12 +86,30 @@ uat-profile:
     paths:
       - examples/uat/playwright-report 
 
-uat-nobdd:
+
+uat-unauth:
   stage: uat
   image: repository.desk.csez.zohocorpin.com/base-image/testing-framework-gitlab-runne-base:v2
   script:
     - npm install 
     - npm run build
+    - cd examples
+    - npm install $(npm pack ../../testing-framework | tail -1)
+    - output=$(npm run uatunauth)
+    - echo "$output"
+    - if [[ "$output" == *"failed"* ]]; then
+    -   exit 1
+    - fi
+
+
+  artifacts:
+    when: always
+    paths:
+      - examples/uat/playwright-report 
+
+uat-nobdd:
+  stage: uat
+  script:
     - cd nobdd
     - npm install $(npm pack ../../testing-framework | tail -1)
     - output=$(npm run uatnobdd)
@@ -108,4 +123,3 @@ uat-nobdd:
     when: always
     paths:
       - nobdd/uat/playwright-report
-

package/README.md

@@ -38,3 +38,8 @@
 
 #### Enhancement
    - Beta feature Actors and edition configurations are unified 
+
+### 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.

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

@@ -70,6 +70,13 @@ var _default = exports.default = {
       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({

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LOGIN_MUTEX_TIMEOUT = void 0;
+const LOGIN_MUTEX_TIMEOUT = exports.LOGIN_MUTEX_TIMEOUT = {
+  stale: 100000,
+  retries: {
+    retries: 10,
+    factor: 1,
+    minTimeout: 10000,
+    maxTimeout: 20000
+  }
+};

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

@@ -10,6 +10,7 @@ exports.verifyIfCookieFileExists = verifyIfCookieFileExists;
 var _path = _interopRequireDefault(require("path"));
 var _fs = require("fs");
 var _readConfigFile = require("../../readConfigFile");
+var _checkAuthDirectory = require("../checkAuthDirectory");
 var _logger = require("../../../../utils/logger");
 /* eslint-disable no-console */
 
@@ -23,13 +24,7 @@ function getAuthFileDirectory() {
   return _path.default.resolve(_path.default.join(uatDirectory, 'playwright', '.auth'));
 }
 function verifyIfCookieFileExists(authFile) {
-  const authDirectory = getAuthFileDirectory();
-  if (!(0, _fs.existsSync)(authDirectory)) {
-    console.log('Creating auth directory for the first time setup...');
-    (0, _fs.mkdirSync)(authDirectory, {
-      recursive: true
-    });
-  }
+  (0, _checkAuthDirectory.createAuthDirectoryIfNotExist)();
   if (!(0, _fs.existsSync)(authFile)) {
     console.log('creating auth file..');
     (0, _fs.writeFileSync)(authFile, JSON.stringify(authContent, null, 2));
@@ -41,7 +36,6 @@ function convertCookiesToParse(cookies, authFilePath) {
   } catch (err) {
     _logger.Logger.error(err);
     throw new Error(` Error while parsing cookies ${err} \n${_path.default.resolve(process.cwd(), authFilePath)} File is Empty`);
-    // process.exit()
   }
 }
 async function loadCookiesIfPresent(page, authFile) {

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

@@ -6,8 +6,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 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({
@@ -17,25 +20,30 @@ async function performLoginSteps({
   password
 }, isLoggedIn) {
   const authFile = _path.default.resolve(_path.default.join((0, _checkAuthCookies.getAuthFileDirectory)(), `${authFilePrefix}-cookies.json`));
-  await (0, _checkAuthCookies.loadCookiesIfPresent)(page, authFile);
-  await page.goto(process.env.domain);
-
-  // await page.waitForNavigation();
-
-  // await page.waitForLoadState('networkidle')
-
-  await Promise.race([page.waitForNavigation(), page.waitForLoadState('networkidle'), page.waitForTimeout(5000)]);
-  const loginStatus = await isLoggedIn(page);
-  if (!loginStatus) {
-    await (0, _accountLogin.default)(page, useremail, password);
+  const lockFileName = useremail.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 page.waitForLoadState();
-
-    await isLoggedIn(page);
-    await page.context().storageState({
-      path: authFile
-    });
+    await Promise.race([page.waitForNavigation(), page.waitForLoadState('networkidle'), page.waitForTimeout(5000)]);
+    const isAlreadyLoggedIn = await isLoggedIn(page);
+    if (!isAlreadyLoggedIn) {
+      await (0, _accountLogin.default)(page, useremail, password);
+      await page.goto(process.env.domain);
+      await isLoggedIn(page);
+      await page.context().storageState({
+        path: authFile
+      });
+    }
+  } catch (error) {
+    console.error(`Error during login for ${useremail}:`, error);
+  } finally {
+    try {
+      await fileMutex.release();
+    } catch (releaseError) {
+      console.error(`Error releasing lock for ${useremail}:`, releaseError);
+    }
   }
 }
 var _default = exports.default = performLoginSteps;

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

@@ -0,0 +1,27 @@
+"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)) {
+    console.log('Creating auth directory for the first time setup...');
+    (0, _fs.mkdirSync)(authDirectory, {
+      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

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _properLockfile = _interopRequireDefault(require("proper-lockfile"));
+var _fs = require("fs");
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+var _getLockFilePath = /*#__PURE__*/new WeakSet();
+var _createDirectoryIfNotExist = /*#__PURE__*/new WeakSet();
+class FileMutex {
+  constructor(directory, lockFileName, options = {}) {
+    _classPrivateMethodInitSpec(this, _createDirectoryIfNotExist);
+    _classPrivateMethodInitSpec(this, _getLockFilePath);
+    this.directory = directory;
+    this.lockFileName = lockFileName + ".lock";
+    this.options = options;
+  }
+  async acquire() {
+    _classPrivateMethodGet(this, _createDirectoryIfNotExist, _createDirectoryIfNotExist2).call(this);
+    const lockFilePath = _path.default.resolve(this.directory, this.lockFileName);
+    try {
+      if (!(0, _fs.existsSync)(lockFilePath)) {
+        console.log(`[DEBUG] Creating missing lock file:`, this.lockFileName);
+        (0, _fs.writeFileSync)(lockFilePath, 'locked');
+      }
+      await _properLockfile.default.lock(_classPrivateMethodGet(this, _getLockFilePath, _getLockFilePath2).call(this), this.options);
+    } catch (err) {
+      throw new Error(`Failed to acquire lock after ${this.options.retries.retries} attempts: ${err.message}`);
+    }
+  }
+  async release() {
+    try {
+      await _properLockfile.default.unlock(_classPrivateMethodGet(this, _getLockFilePath, _getLockFilePath2).call(this));
+    } catch (err) {
+      throw new Error(`Failed to release lock: ${err.message}`);
+    }
+  }
+}
+function _getLockFilePath2() {
+  return _path.default.resolve(_path.default.join(this.directory, this.lockFileName));
+}
+function _createDirectoryIfNotExist2() {
+  if (!(0, _fs.existsSync)(this.directory)) {
+    (0, _fs.mkdirSync)(this.directory, {
+      recursive: true
+    });
+  }
+}
+var _default = exports.default = FileMutex;

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('../', '../', '../', '../', 'playwrightConfig.js');
+    const beforeCommand = 'node';
+    const bddGenPath = _path.default.resolve(__dirname, '../', '../', '../', 'bdd-framework', 'cli', 'index.js');
+    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/test-runner.js

@@ -20,27 +20,8 @@ var _browserTypes = require("./constants/browserTypes");
 var _ConfigurationHelper = require("./configuration/ConfigurationHelper");
 var _Configuration = _interopRequireDefault(require("./configuration/Configuration"));
 var _UserArgs = _interopRequireDefault(require("./configuration/UserArgs"));
-function 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 _RunnerHelper = _interopRequireDefault(require("./runner/RunnerHelper"));
+var _Runner = _interopRequireDefault(require("./runner/Runner"));
 function runPreprocessing(tagArgs, configPath) {
   const beforeCommand = 'node';
   const bddGenPath = _path.default.resolve(__dirname, '../', '../', 'bdd-framework', 'cli', 'index.js');
@@ -124,18 +105,11 @@ function main() {
   const userArgsObject = userArgConfig.getAll();
   const tagProcessor = new _tagProcessor.default(editionOrder);
   const tagArgs = tagProcessor.processTags(userArgsObject);
-  const playwrightArgs = getPlaywrightArgs(userArgsObject, debug, bddMode, tagArgs, headless);
-  const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
-  const command = playwrightPath;
-  const configPath = (0, _readConfigFile.isUserConfigFileAvailable)() ? require.resolve('./setup/config-creator.js') : require.resolve('../../../playwright.config.js');
-  const args = ['test', '--config', configPath].concat(playwrightArgs);
-  let promises = [];
-  if (bddMode) {
-    promises.push(runPreprocessing(tagArgs, configPath));
-  }
-  Promise.all(promises).then(() => runPlaywright(command, args)).catch(err => {
-    _logger.Logger.error(err);
-    process.exit();
-  });
+  const runnerObj = new _Runner.default();
+  runnerObj.setTagArgs(tagArgs);
+  runnerObj.setUserArgs(userArgsObject);
+  runnerObj.setConfig(uatConfig);
+  const runner = _RunnerHelper.default.createRunner('spawn', runnerObj);
+  runner.run();
 }
 var _default = exports.default = main;

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

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fileMutex = _interopRequireDefault(require("../../../../../core/playwright/helpers/fileMutex"));
+var _properLockfile = _interopRequireDefault(require("proper-lockfile"));
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+jest.mock('proper-lockfile');
+jest.mock('fs');
+describe('FileMutex', () => {
+  const directory = '/tmp/locks';
+  const lockFileName = 'test-lock';
+  const options = {
+    stale: 10000,
+    retries: {
+      retries: 5,
+      factor: 1,
+      minTimeout: 5000,
+      maxTimeout: 8000
+    }
+  };
+  const lockFilePath = _path.default.resolve(directory, lockFileName + '.lock');
+  let fileMutex;
+  beforeEach(() => {
+    fileMutex = new _fileMutex.default(directory, lockFileName, options);
+    jest.clearAllMocks();
+  });
+  describe('acquire', () => {
+    it('should create the directory if it does not exist', async () => {
+      _fs.default.existsSync.mockReturnValue(false);
+      _fs.default.mkdirSync.mockImplementation(() => {});
+      _properLockfile.default.lock.mockResolvedValue();
+      await fileMutex.acquire();
+      expect(_fs.default.existsSync).toHaveBeenCalledWith(directory);
+      expect(_fs.default.mkdirSync).toHaveBeenCalledWith(directory, {
+        recursive: true
+      });
+    });
+    it('should create the lock file if it does not exist', async () => {
+      _fs.default.existsSync.mockImplementation(filePath => filePath !== lockFilePath);
+      _fs.default.writeFileSync.mockImplementation(() => {});
+      _properLockfile.default.lock.mockResolvedValue();
+      await fileMutex.acquire();
+      expect(_fs.default.existsSync).toHaveBeenCalledWith(lockFilePath);
+      expect(_fs.default.writeFileSync).toHaveBeenCalledWith(lockFilePath, 'locked');
+    });
+    it('should acquire the lock using proper-lockfile', async () => {
+      _fs.default.existsSync.mockReturnValue(true);
+      _properLockfile.default.lock.mockResolvedValue();
+      await fileMutex.acquire();
+      expect(_properLockfile.default.lock).toHaveBeenCalledWith(lockFilePath, options);
+    });
+    it('should throw an error if lock acquisition fails', async () => {
+      const errorMessage = 'Lock acquisition failed';
+      _properLockfile.default.lock.mockRejectedValue(new Error(errorMessage));
+      await expect(fileMutex.acquire()).rejects.toThrow(`Failed to acquire lock after ${options.retries.retries} attempts: ${errorMessage}`);
+    });
+  });
+  describe('release', () => {
+    it('should release the lock using proper-lockfile', async () => {
+      _properLockfile.default.unlock.mockResolvedValue();
+      await fileMutex.release();
+      expect(_properLockfile.default.unlock).toHaveBeenCalledWith(lockFilePath);
+    });
+    it('should throw an error if lock release fails', async () => {
+      const errorMessage = 'Lock release failed';
+      _properLockfile.default.unlock.mockRejectedValue(new Error(errorMessage));
+      await expect(fileMutex.release()).rejects.toThrow(`Failed to release lock: ${errorMessage}`);
+    });
+  });
+});

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

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _RunnerHelper = _interopRequireDefault(require("../../../../../core/playwright/runner/RunnerHelper"));
+var _SpawnRunner = _interopRequireDefault(require("../../../../../core/playwright/runner/SpawnRunner"));
+describe('RunnerHelper', () => {
+  describe('createRunner', () => {
+    it('should throw error on invalid runner type', () => {
+      expect(() => _RunnerHelper.default.createRunner('invalid-type', {})).toThrow("Invalid runner type");
+    });
+    it('should create a valid runner class', () => {
+      const runnerInstance = _RunnerHelper.default.createRunner('spawn', {});
+      expect(runnerInstance).toBeInstanceOf(_SpawnRunner.default); // Directly pass the result
+    });
+  });
+});

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

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _RunnerHelper = _interopRequireDefault(require("../../../../../core/playwright/runner/RunnerHelper"));
+var _Runner = _interopRequireDefault(require("../../../../../core/playwright/runner/Runner"));
+var _Configuration = _interopRequireDefault(require("../../../../../core/playwright/configuration/Configuration"));
+jest.mock('child_process');
+jest.mock('../../../../../utils/logger');
+describe('SpawnRunner', () => {
+  let spawnRunner;
+  const runnerObj = new _Runner.default();
+  beforeEach(() => {
+    const config = new _Configuration.default({});
+    config.add("bddMode", true);
+    runnerObj.setConfig(config);
+    runnerObj.setTagArgs(["--headed"]);
+    spawnRunner = _RunnerHelper.default.createRunner('spawn', runnerObj);
+  });
+  describe('run', () => {
+    it('should call runPreprocessing when bddMode is true', () => {
+      const runPreprocessingSpy = jest.spyOn(spawnRunner, 'runPreprocessing').mockResolvedValue();
+      const runPlaywrightSpy = jest.spyOn(spawnRunner, 'runPlaywright').mockResolvedValue();
+      spawnRunner.run();
+      expect(runPreprocessingSpy).toHaveBeenCalled();
+    });
+  });
+});

package/nobdd/uat/conf/default/actors/index.js

@@ -1,5 +1,2 @@
 const editions = require('./editions/index');
-const beta = require('./beta/index');
-
-
-module.exports = { editions, beta }
+module.exports = { editions }

package/nobdd/uat/conf/default/settings.json

@@ -2,5 +2,5 @@
   "environment": "ci",
   "edition": "enterprise",
   "profile": "admin",
-  "domain": "https://zdesk-devops08.csez.zohocorpin.com:31007/agent"
+  "domain": "https://zdesk-devops16.csez.zohocorpin.com:31025/agent"
 }

package/nobdd/uat/conf/nobdd/uat.config.js

@@ -12,16 +12,24 @@ function getPrimaryCookiePath() {
  * @typedef {import('@zohodesk/testinglibrary').UserConfig} UserConfig
  */
 module.exports = {
-  headless: true,
+  headless: false,
+  retries:1,
   openReportOn: 'never',
   browsers: ['Chrome'],
-  isAuthMode: false,
+  isAuthMode: true,
   authFilePath: getPrimaryCookiePath(),
-  trace: true,
-  video: true,
+  trace: 'retain-on-failure',
+  video: 'retain-on-failure',
+  retries:1,
   bddMode: false,
+  expectTimeout: 10 * 1000,
+  testTimeout: 60 * 1000,
+  globalTimeout: 2 * 60 * 60 * 1000,
+  featureFilesFolder: 'feature-files',
+  stepDefinitionsFolder: 'steps',
   viewport: { width: 1280, height: 720 },
   testIdAttribute: 'data-id',
+  editionOrder: ['Free', 'Express', 'Standard', 'Professional', 'Enterprise'],
   additionalPages: {
     ...customFixtures
   }

package/nobdd/uat/env-config.json

@@ -1,18 +1,18 @@
 {
   "dev": {
-    "domain": "https://desk.localzoho.com/agent",
+    "domain": "https://zdesk-devops16.csez.zohocorpin.com:31025/agent",
     "orgName": "org-name",
     "deptName": "dept-name",
     "moduleName": "module-name"
   },
   "prod": {
-    "domain": "https://desk.localzoho.com/agent/",
+    "domain": "https://zdesk-devops16.csez.zohocorpin.com:31025/agent",
     "orgName": "sangeetha.t@zohocorp.com",
     "deptName": "sangeethat",
     "moduleName": "sangeethat"
   },
   "ci": {
-    "domain": "https://zdesk-devops08.csez.zohocorpin.com:31007/agent/",
+    "domain": "https://zdesk-devops16.csez.zohocorpin.com:31025/agent",
     "orgName": "clientcicdk8",
     "deptName": "clientcicdk8",
     "moduleName": "tickets"

package/nobdd/uat/fixtures/setup.teardown.js

@@ -21,7 +21,8 @@ if (!isDevelopmentSetup()) {
       const authFilePath = path.join(authDirectory, file);
       await loadCookiesIfPresent(page, authFilePath);
       const domainOrigin = getUrlOrigin(process.env.domain);
-      await page.goto(`${domainOrigin}/support/logout.sas `);
+      const logoutURL = `${domainOrigin}/support/logout.sas`;
+      await page.goto(logoutURL);
       await page.waitForNavigation();
       await expect(page.locator('[id="signin_flow"]')).toBeVisible();
       await fs.rmSync(authFilePath);

package/nobdd/uat/modules/nobdd/steps/VerifyNoBDD.feature.spec.js

@@ -4,11 +4,11 @@ test.describe("Verify no authentication required @nobdd", () => {
 
   test("Verify the page is not logged in", async ({ page }) => {
 
-    await page.goto('https://desk.localzoho.com/');
+    await page.goto(process.env.domain);
 
-    await page.waitForSelector('.zgh-accounts');
+    await page.waitForSelector('#login');
 
-    const isLoggedIn = await page.isVisible('.zgh-accounts');
+    const isLoggedIn = await page.isVisible('#login');
     expect(isLoggedIn).toBe(true);
 
   });

package/nobdd/uat.config.js

@@ -13,18 +13,25 @@ function getPrimaryCookiePath() {
  */
 module.exports = {
   headless: false,
+  retries:1,
   openReportOn: 'never',
   browsers: ['Chrome'],
   isAuthMode: true,
   authFilePath: getPrimaryCookiePath(),
-  trace: true,
-  video: true,
-  bddMode: true,
+  trace: 'retain-on-failure',
+  video: 'retain-on-failure',
+  retries:1,
+  bddMode: false,
+  expectTimeout: 10 * 1000,
+  testTimeout: 60 * 1000,
+  globalTimeout: 2 * 60 * 60 * 1000,
   featureFilesFolder: 'feature-files',
   stepDefinitionsFolder: 'steps',
   viewport: { width: 1280, height: 720 },
   testIdAttribute: 'data-id',
+  editionOrder: ['Free', 'Express', 'Standard', 'Professional', 'Enterprise'],
   additionalPages: {
     ...customFixtures
-  }
+  },
+  url:""
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/testinglibrary",
-  "version": "2.9.1",
+  "version": "2.9.3",
   "description": "",
   "main": "./build/index.js",
   "scripts": {
@@ -34,6 +34,7 @@
     "jest-environment-jsdom": "29.6.2",
     "msw": "1.2.3",
     "playwright": "1.42.1",
+    "proper-lockfile": "4.1.2",
     "supports-color": "8.1.1"
   },
   "bin": {

package/nobdd/uat/conf/default/actors/beta/custom-module.json

@@ -1,24 +0,0 @@
-[
-  {
-    "id": "1",
-    "edition": "enterprise",
-    "orgName": "custommoduleportal",
-    "profiles": [
-      {
-        "profile": "admin",
-        "email": "indragith.m+agent@zohotest.com",
-        "password": "Paara!2019"
-      },
-      {
-        "profile": "agent",
-        "email": "indragith.m+agent@zohotest.com",
-        "password": "Paara!2019"
-      },
-      {
-        "profile": "lightagent",
-        "email": "indragith.m+abc1@zohotest.com",
-        "password": "Paara!2019"
-      }
-    ]
-  }
-]

package/nobdd/uat/conf/default/actors/beta/index.js

@@ -1,6 +0,0 @@
-const parentchild = require('./parent-child.json');
-const custommodule = require('./custom-module.json');
-
-const beta = { parentchild, custommodule };
-
-module.exports = beta;

package/nobdd/uat/conf/default/actors/beta/parent-child.json

@@ -1,24 +0,0 @@
-[
-  {
-    "id": "1",
-    "edition": "enterprise",
-    "orgName": "parentchildportal",
-    "profiles": [
-      {
-        "profile": "admin",
-        "email": "indragith.m@zohocorp.com",
-        "password": "Paara!2019"
-      },
-      {
-        "profile": "agent",
-        "email": "indragith.m+agent@zohotest.com",
-        "password": "Paara!2019"
-      },
-      {
-        "profile": "lightagent",
-        "email": "indragith.m+abc1@zohotest.com",
-        "password": "Paara!2019"
-      }
-    ]
-  }
-]