@zohodesk/testinglibrary 3.0.9 → 3.1.0

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

@@ -78,7 +78,8 @@ var _default = exports.default = {
       if (!isAuthMode) {
         return;
       }
-      if (testPortalDetails && testInfo.project.name !== 'setup') {
+      const projectName = testInfo.project.name;
+      if (testPortalDetails && projectName !== 'setup' && projectName !== 'cleanup') {
         await context.clearCookies();
         await (0, _auth.performLoginSteps)(testDetails, async testInfo => {
           return await verifyPageIsLoaded(testInfo);

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

@@ -3,13 +3,7 @@
 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
-  }
+exports.fileDeletionTimeoutConfig = void 0;
+const fileDeletionTimeoutConfig = exports.fileDeletionTimeoutConfig = {
+  timeout: 45000
 };

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

@@ -21,7 +21,7 @@ async function performLoginSteps(testInfo, isLoggedIn, loginSteps) {
   authFilePrefix = authFilePrefix || email;
   const authFile = _path.default.resolve(_path.default.join((0, _checkAuthCookies.getAuthFileDirectory)(), `${authFilePrefix}-cookies.json`));
   const lockFileName = email.replace(/[@.]/g, '_');
-  const fileMutex = new _fileMutex.default((0, _checkAuthDirectory.getLockDirectoryPath)(), lockFileName, _fileMutexConfig.LOGIN_MUTEX_TIMEOUT);
+  const fileMutex = new _fileMutex.default((0, _checkAuthDirectory.getLockDirectoryPath)(), lockFileName, email, authFile, _fileMutexConfig.fileDeletionTimeoutConfig);
   try {
     await fileMutex.acquire();
     await (0, _checkAuthCookies.loadCookiesIfPresent)(page, authFile);
@@ -36,11 +36,7 @@ async function performLoginSteps(testInfo, isLoggedIn, loginSteps) {
   } catch (error) {
     console.error(`Error during login for ${email}:`, error);
   } finally {
-    try {
-      await fileMutex.release();
-    } catch (releaseError) {
-      console.error(`Error releasing lock for ${email}:`, releaseError);
-    }
+    await fileMutex.release();
   }
 }
 var _default = exports.default = performLoginSteps;

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

@@ -6,48 +6,71 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _path = _interopRequireDefault(require("path"));
-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();
+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();
 class FileMutex {
-  constructor(directory, lockFileName, options = {}) {
-    _classPrivateMethodInitSpec(this, _FileMutex_brand);
+  constructor(directory, lockFileName, email, authFile, fileDeletionTimeoutConfig) {
+    _classPrivateMethodInitSpec(this, _getLockFilePath);
     this.directory = directory;
     this.lockFileName = lockFileName + ".lock";
-    this.options = options;
+    this.email = email;
+    this.authFile = authFile;
+    this.fileDeletionTimeout = fileDeletionTimeoutConfig.timeout;
+    this.createDirectoryIfNotExist();
+    this.lockFilePath = _classPrivateMethodGet(this, _getLockFilePath, _getLockFilePath2).call(this);
   }
   async acquire() {
-    _assertClassBrand(_FileMutex_brand, this, _createDirectoryIfNotExist).call(this);
-    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}`);
+    if ((0, _fs.existsSync)(this.authFile)) {
+      console.log(`${this.email} Cookie file exists. Loading cookies...`);
+      return;
     }
+    return new Promise((resolve, reject) => {
+      if (!(0, _fs.existsSync)(this.lockFilePath)) {
+        (0, _fs.writeFileSync)(this.lockFilePath, 'locked');
+        console.log(`Lock file created: ${this.lockFilePath}`);
+        return resolve();
+      }
+      const timeout = setTimeout(() => {
+        watcher.close();
+        reject(new Error('Watch timeout exceeded'));
+      }, this.fileDeletionTimeout);
+      const watcher = (0, _fs.watch)(this.directory, (eventType, filename) => {
+        try {
+          if (eventType === 'rename' && filename === this.lockFileName) {
+            clearTimeout(timeout);
+            console.log(`Lock file deleted! Proceeding...`);
+            watcher.close();
+            resolve();
+          }
+        } catch (err) {
+          console.error(`Error watching for lock file deletion: ${err.message}`);
+          watcher.close();
+        }
+      });
+    });
   }
   async release() {
     try {
-      await _properLockfile.default.unlock(_assertClassBrand(_FileMutex_brand, this, _getLockFilePath).call(this));
+      if ((0, _fs.existsSync)(this.lockFilePath)) {
+        (0, _fs.unlinkSync)(this.lockFilePath);
+        console.log(`Lock file deleted: ${this.lockFilePath}`);
+      }
     } catch (err) {
-      throw new Error(`Failed to release lock: ${err.message}`);
+      console.error(`Error deleting lock file: ${err.message}`);
+    }
+  }
+  async createDirectoryIfNotExist() {
+    if (!(0, _fs.existsSync)(this.directory)) {
+      (0, _fs.mkdirSync)(this.directory, {
+        recursive: true
+      });
     }
   }
 }
-function _getLockFilePath() {
+function _getLockFilePath2() {
   return _path.default.resolve(_path.default.join(this.directory, this.lockFileName));
 }
-function _createDirectoryIfNotExist() {
-  if (!(0, _fs.existsSync)(this.directory)) {
-    (0, _fs.mkdirSync)(this.directory, {
-      recursive: true
-    });
-  }
-}
 var _default = exports.default = FileMutex;

package/build/core/playwright/tagProcessor.js

@@ -1,13 +1,23 @@
 "use strict";
 
 var _logger = require("../../utils/logger");
-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 _TagProcessor_brand = /*#__PURE__*/new WeakSet();
+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 _buildTagsString = /*#__PURE__*/new WeakSet();
+var _parseEdition = /*#__PURE__*/new WeakSet();
+var _processSingleEdition = /*#__PURE__*/new WeakSet();
+var _processMultipleEditions = /*#__PURE__*/new WeakSet();
+var _getEditionArgs = /*#__PURE__*/new WeakSet();
+var _buildEditionTags = /*#__PURE__*/new WeakSet();
 class TagProcessor {
   constructor(editionOrder) {
-    _classPrivateMethodInitSpec(this, _TagProcessor_brand);
+    _classPrivateMethodInitSpec(this, _buildEditionTags);
+    _classPrivateMethodInitSpec(this, _getEditionArgs);
+    _classPrivateMethodInitSpec(this, _processMultipleEditions);
+    _classPrivateMethodInitSpec(this, _processSingleEdition);
+    _classPrivateMethodInitSpec(this, _parseEdition);
+    _classPrivateMethodInitSpec(this, _buildTagsString);
     this.editionOrder = editionOrder;
   }
   processTags(userArgs) {
@@ -15,36 +25,36 @@ class TagProcessor {
     const edition = userArgs['edition'] || null;
     if (!edition) return tagArgs;
     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 ? _classPrivateMethodGet(this, _processSingleEdition, _processSingleEdition2).call(this, editionsArray[0], tagArgs) : _classPrivateMethodGet(this, _processMultipleEditions, _processMultipleEditions2).call(this, editionsArray, tagArgs);
     return editionTags;
   }
 }
-function _buildTagsString(tags, editionTags) {
+function _buildTagsString2(tags, editionTags) {
   return tags && tags !== '' ? `${tags} and not (${editionTags})` : `not (${editionTags})`;
 }
-function _parseEdition(edition) {
+function _parseEdition2(edition) {
   if (edition.startsWith('<=')) return ['<=', edition.slice(2)];
   if (edition.startsWith('>=')) return ['>=', edition.slice(2)];
   if (edition.startsWith('<')) return ['<', edition.slice(1)];
   if (edition.startsWith('>')) return ['>', edition.slice(1)];
   return [null, edition];
 }
-function _processSingleEdition(selectedEdition, tagArgs) {
-  const editionArgs = _assertClassBrand(_TagProcessor_brand, this, _getEditionArgs).call(this, selectedEdition);
+function _processSingleEdition2(selectedEdition, tagArgs) {
+  const editionArgs = _classPrivateMethodGet(this, _getEditionArgs, _getEditionArgs2).call(this, selectedEdition);
   if (editionArgs && editionArgs.length > 0) {
-    const editionTags = _assertClassBrand(_TagProcessor_brand, this, _buildEditionTags).call(this, editionArgs, 'or');
-    return _assertClassBrand(_TagProcessor_brand, this, _buildTagsString).call(this, tagArgs, editionTags);
+    const editionTags = _classPrivateMethodGet(this, _buildEditionTags, _buildEditionTags2).call(this, editionArgs, 'or');
+    return _classPrivateMethodGet(this, _buildTagsString, _buildTagsString2).call(this, tagArgs, editionTags);
   }
   _logger.Logger.log(_logger.Logger.INFO_TYPE, `No matching editions for ${selectedEdition} found. Running with default edition`);
   return tagArgs;
 }
-function _processMultipleEditions(editionsArray, tagArgs) {
+function _processMultipleEditions2(editionsArray, tagArgs) {
   const filteredEditions = this.editionOrder.filter(edition => !editionsArray.includes(edition));
-  const editionTags = _assertClassBrand(_TagProcessor_brand, this, _buildEditionTags).call(this, filteredEditions, 'or');
-  return _assertClassBrand(_TagProcessor_brand, this, _buildTagsString).call(this, tagArgs, editionTags);
+  const editionTags = _classPrivateMethodGet(this, _buildEditionTags, _buildEditionTags2).call(this, filteredEditions, 'or');
+  return _classPrivateMethodGet(this, _buildTagsString, _buildTagsString2).call(this, tagArgs, editionTags);
 }
-function _getEditionArgs(selectedEdition) {
-  const [operator, editionValue] = _assertClassBrand(_TagProcessor_brand, this, _parseEdition).call(this, selectedEdition.toLowerCase());
+function _getEditionArgs2(selectedEdition) {
+  const [operator, editionValue] = _classPrivateMethodGet(this, _parseEdition, _parseEdition2).call(this, selectedEdition.toLowerCase());
   const index = this.editionOrder.findIndex(edition => edition.toLowerCase() === editionValue);
   if (index === -1) {
     _logger.Logger.log(_logger.Logger.INFO_TYPE, `No matching editions for ${selectedEdition} found. Running with default edition`);
@@ -63,7 +73,7 @@ function _getEditionArgs(selectedEdition) {
       return this.editionOrder.filter((_, i) => i !== index);
   }
 }
-function _buildEditionTags(editionArgs, operator = 'or') {
+function _buildEditionTags2(editionArgs, operator = 'or') {
   return editionArgs.map(edition => `@edition_${edition}`).join(` ${operator} `);
 }
 module.exports = TagProcessor;

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

@@ -2,70 +2,95 @@
 
 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');
+var _fs = require("fs");
 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 email = 'test@example.com';
+  const authFile = '/tmp/authFile';
+  const fileDeletionTimeoutConfig = {
+    timeout: 1000
   };
   const lockFilePath = _path.default.resolve(directory, lockFileName + '.lock');
   let fileMutex;
   beforeEach(() => {
-    fileMutex = new _fileMutex.default(directory, lockFileName, options);
     jest.clearAllMocks();
+    fileMutex = new _fileMutex.default(directory, lockFileName, email, authFile, fileDeletionTimeoutConfig);
   });
   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, {
+    it('should create directory if it does not exist', async () => {
+      _fs.existsSync.mockReturnValue(false);
+      await fileMutex.createDirectoryIfNotExist();
+      expect(_fs.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();
+      _fs.existsSync.mockImplementation(filePath => filePath === authFile ? false : false);
+      _fs.writeFileSync.mockImplementation(() => {});
+      await fileMutex.acquire();
+      expect(_fs.writeFileSync).toHaveBeenCalledWith(fileMutex.lockFilePath, 'locked');
+    });
+    it('should resolve immediately if auth file exists', async () => {
+      _fs.existsSync.mockImplementation(filePath => filePath === authFile);
       await fileMutex.acquire();
-      expect(_fs.default.existsSync).toHaveBeenCalledWith(lockFilePath);
-      expect(_fs.default.writeFileSync).toHaveBeenCalledWith(lockFilePath, 'locked');
+      expect(_fs.existsSync).toHaveBeenCalledWith(authFile);
     });
-    it('should acquire the lock using proper-lockfile', async () => {
-      _fs.default.existsSync.mockReturnValue(true);
-      _properLockfile.default.lock.mockResolvedValue();
+    it('should wait for lock file deletion if it exists', async () => {
+      _fs.existsSync.mockImplementation(filePath => filePath === fileMutex.lockFilePath);
+      _fs.watch.mockImplementation((dir, callback) => {
+        setTimeout(() => {
+          _fs.existsSync.mockImplementation(() => false);
+          callback('rename', fileMutex.lockFileName);
+        }, fileDeletionTimeoutConfig);
+        return {
+          close: jest.fn()
+        };
+      });
       await fileMutex.acquire();
-      expect(_properLockfile.default.lock).toHaveBeenCalledWith(lockFilePath, options);
+      expect(_fs.watch).toHaveBeenCalledWith(directory, expect.any(Function));
     });
-    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}`);
+    it('should reject if watch timeout exceeds', async () => {
+      _fs.existsSync.mockImplementation(filePath => filePath === lockFilePath);
+      _fs.watch.mockImplementation(() => {
+        return {
+          close: jest.fn()
+        };
+      });
+      await expect(fileMutex.acquire()).rejects.toThrow('Watch timeout exceeded');
     });
   });
   describe('release', () => {
-    it('should release the lock using proper-lockfile', async () => {
-      _properLockfile.default.unlock.mockResolvedValue();
+    it('should delete the lock file if it exists', async () => {
+      _fs.existsSync.mockReturnValue(true);
+      _fs.unlinkSync.mockImplementation(() => {});
       await fileMutex.release();
-      expect(_properLockfile.default.unlock).toHaveBeenCalledWith(lockFilePath);
+      expect(_fs.existsSync).toHaveBeenCalledWith(lockFilePath);
+      expect(_fs.unlinkSync).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}`);
+    it('should release lock by deleting lock file', async () => {
+      _fs.existsSync.mockReturnValue(true);
+      _fs.unlinkSync.mockImplementation(() => {});
+      await fileMutex.release();
+      expect(_fs.unlinkSync).toHaveBeenCalledWith(lockFilePath);
+    });
+    it('should not attempt to delete the lock file if it does not exist', async () => {
+      _fs.existsSync.mockReturnValue(false);
+      await fileMutex.release();
+      expect(_fs.existsSync).toHaveBeenCalledWith(lockFilePath);
+      expect(_fs.unlinkSync).not.toHaveBeenCalled();
+    });
+    it('should log an error if deleting the lock file fails', async () => {
+      const errorMessage = 'Error deleting lock file';
+      _fs.existsSync.mockReturnValue(true);
+      _fs.unlinkSync.mockImplementation(() => {
+        throw new Error(errorMessage);
+      });
+      console.error = jest.fn();
+      await fileMutex.release();
+      expect(console.error).toHaveBeenCalledWith(`Error deleting lock file: ${errorMessage}`);
     });
   });
 });