@zohodesk/testinglibrary 2.9.6 → 2.9.8

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

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

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,16 +21,13 @@ 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);
-    await page.goto(process.env.domain);
-    await Promise.race([page.waitForNavigation(), page.waitForLoadState('networkidle'), page.waitForTimeout(5000)]);
     const isAlreadyLoggedIn = await isLoggedIn(testInfo);
     if (!isAlreadyLoggedIn) {
       await loginSteps(testInfo);
-      await page.goto(process.env.domain);
       await isLoggedIn(testInfo);
       await page.context().storageState({
         path: authFile
@@ -39,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();
 class FileMutex {
-  constructor(directory, lockFileName, options = {}) {
+  constructor(directory, lockFileName, email, authFile, fileDeletionTimeoutConfig) {
     _classPrivateMethodInitSpec(this, _FileMutex_brand);
     this.directory = directory;
     this.lockFileName = lockFileName + ".lock";
-    this.options = options;
+    this.email = email;
+    this.authFile = authFile;
+    this.fileDeletionTimeout = fileDeletionTimeoutConfig.timeout;
+    this.createDirectoryIfNotExist();
+    this.lockFilePath = _assertClassBrand(_FileMutex_brand, this, _getLockFilePath).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() {
   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/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}`);
     });
   });
 });