@zohodesk/testinglibrary 2.9.2 → 2.9.3

package/.gitlab-ci.yml

@@ -86,6 +86,27 @@ uat-profile:
     paths:
       - examples/uat/playwright-report 
 
+
+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:

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

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

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

@@ -10,6 +10,7 @@ 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({
@@ -20,7 +21,7 @@ async function performLoginSteps({
 }, isLoggedIn) {
   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 fileMutex = new _fileMutex.default((0, _checkAuthDirectory.getLockDirectoryPath)(), lockFileName, _fileMutexConfig.LOGIN_MUTEX_TIMEOUT);
   try {
     await fileMutex.acquire();
     await (0, _checkAuthCookies.loadCookiesIfPresent)(page, authFile);

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,7 +6,7 @@ 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(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"); } }
@@ -14,39 +14,36 @@ function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(
 var _getLockFilePath = /*#__PURE__*/new WeakSet();
 var _createDirectoryIfNotExist = /*#__PURE__*/new WeakSet();
 class FileMutex {
-  constructor(directory, lockFileName, timeout) {
+  constructor(directory, lockFileName, options = {}) {
     _classPrivateMethodInitSpec(this, _createDirectoryIfNotExist);
     _classPrivateMethodInitSpec(this, _getLockFilePath);
     this.directory = directory;
-    this.lockFileName = lockFileName;
-    this.timeout = timeout;
+    this.lockFileName = lockFileName + ".lock";
+    this.options = options;
   }
   async acquire() {
     _classPrivateMethodGet(this, _createDirectoryIfNotExist, _createDirectoryIfNotExist2).call(this);
-    return new Promise((resolve, reject) => {
-      _lockfile.default.lock(_classPrivateMethodGet(this, _getLockFilePath, _getLockFilePath2).call(this), this.timeout, err => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve();
-        }
-      });
-    });
+    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() {
-    return new Promise((resolve, reject) => {
-      _lockfile.default.unlock(_classPrivateMethodGet(this, _getLockFilePath, _getLockFilePath2).call(this), err => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve();
-        }
-      });
-    });
+    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}.lock`));
+  return _path.default.resolve(_path.default.join(this.directory, this.lockFileName));
 }
 function _createDirectoryIfNotExist2() {
   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('../', '../', '../', '../', '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

@@ -2,93 +2,70 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _fileMutex = _interopRequireDefault(require("../../../../../core/playwright/helpers/fileMutex"));
-var _lockfile = _interopRequireDefault(require("lockfile"));
+var _properLockfile = _interopRequireDefault(require("proper-lockfile"));
 var _path = _interopRequireDefault(require("path"));
 var _fs = _interopRequireDefault(require("fs"));
-jest.mock('lockfile');
+jest.mock('proper-lockfile');
 jest.mock('fs');
 describe('FileMutex', () => {
-  const mockDirectory = '/tmp';
-  const mockFileName = 'test_user';
-  const mockTimeout = {
-    wait: 5000,
-    retries: 5,
-    stale: 60000
+  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(mockDirectory, mockFileName, mockTimeout);
-  });
-  afterEach(() => {
+    fileMutex = new _fileMutex.default(directory, lockFileName, options);
     jest.clearAllMocks();
   });
   describe('acquire', () => {
-    it('should resolve when lockfile.lock succeeds and call getLockFilePath correctly', async () => {
-      const expectedPath = _path.default.resolve(_path.default.join(mockDirectory, `./${mockFileName}.lock`));
-      _lockfile.default.lock.mockImplementation((lockPath, options, callback) => {
-        expect(lockPath).toBe(expectedPath);
-        expect(options).toEqual(mockTimeout);
-        callback(null);
-      });
-      await expect(fileMutex.acquire()).resolves.toBeUndefined();
-      expect(_lockfile.default.lock).toHaveBeenCalledWith(expectedPath, mockTimeout, expect.any(Function));
-    });
-    it('should reject when lockfile.lock fails', async () => {
-      const mockError = new Error('Lock failed');
-      _lockfile.default.lock.mockImplementation((lockPath, options, callback) => {
-        expect(lockPath).toBe(_path.default.resolve(_path.default.join(mockDirectory, `./${mockFileName}.lock`)));
-        expect(options).toEqual(mockTimeout);
-        callback(mockError);
-      });
-      await expect(fileMutex.acquire()).rejects.toThrow('Lock failed');
-      expect(_lockfile.default.lock).toHaveBeenCalled();
-    });
-    it('should create the directory if it does not exist and acquire the lock', async () => {
+    it('should create the directory if it does not exist', async () => {
       _fs.default.existsSync.mockReturnValue(false);
-      _fs.default.mkdirSync.mockImplementation((dir, options) => {
-        expect(dir).toBe(mockDirectory);
-        expect(options).toEqual({
-          recursive: true
-        });
-      });
-      _lockfile.default.lock.mockImplementation((lockPath, options, callback) => {
-        expect(lockPath).toBe(_path.default.resolve(_path.default.join(mockDirectory, `./${mockFileName}.lock`)));
-        expect(options).toEqual(mockTimeout);
-        callback(null);
-      });
-      await expect(fileMutex.acquire()).resolves.toBeUndefined();
-      expect(_fs.default.existsSync).toHaveBeenCalledWith(mockDirectory);
-      expect(_fs.default.mkdirSync).toHaveBeenCalledWith(mockDirectory, {
+      _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
       });
-      expect(_lockfile.default.lock).toHaveBeenCalled();
     });
-    it('should not create the directory if it already exists', async () => {
+    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);
-      _lockfile.default.lock.mockImplementation((lockPath, options, callback) => {
-        callback(null);
-      });
-      await expect(fileMutex.acquire()).resolves.toBeUndefined();
-      expect(_fs.default.mkdirSync).not.toHaveBeenCalled();
-      expect(_lockfile.default.lock).toHaveBeenCalled();
+      _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 resolve when lockfile.unlock succeeds and call getLockFilePath correctly', async () => {
-      const expectedPath = _path.default.resolve(_path.default.join(mockDirectory, `./${mockFileName}.lock`));
-      _lockfile.default.unlock.mockImplementation((path, callback) => {
-        callback(null);
-      });
-      await expect(fileMutex.release()).resolves.toBeUndefined();
-      expect(_lockfile.default.unlock).toHaveBeenCalledWith(expectedPath, expect.any(Function));
+    it('should release the lock using proper-lockfile', async () => {
+      _properLockfile.default.unlock.mockResolvedValue();
+      await fileMutex.release();
+      expect(_properLockfile.default.unlock).toHaveBeenCalledWith(lockFilePath);
     });
-    it('should reject when lockfile.unlock fails', async () => {
-      const mockError = new Error('Unlock failed');
-      _lockfile.default.unlock.mockImplementation((path, callback) => {
-        callback(mockError);
-      });
-      await expect(fileMutex.release()).rejects.toThrow('Unlock failed');
-      expect(_lockfile.default.unlock).toHaveBeenCalled();
+    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.config.js

@@ -32,5 +32,6 @@ module.exports = {
   editionOrder: ['Free', 'Express', 'Standard', 'Professional', 'Enterprise'],
   additionalPages: {
     ...customFixtures
-  }
+  },
+  url:""
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/testinglibrary",
-  "version": "2.9.2",
+  "version": "2.9.3",
   "description": "",
   "main": "./build/index.js",
   "scripts": {
@@ -32,9 +32,9 @@
     "fast-glob": "3.3.1",
     "jest": "29.6.2",
     "jest-environment-jsdom": "29.6.2",
-    "lockfile": "^1.0.4",
     "msw": "1.2.3",
     "playwright": "1.42.1",
+    "proper-lockfile": "4.1.2",
     "supports-color": "8.1.1"
   },
   "bin": {