@zohodesk/testinglibrary 3.0.9 → 3.1.1

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _page = require("./page");
+var _default = exports.default = {
+  executionContext: async ({
+    $tags
+  }, use) => {
+    let testPortalActorDetails = {
+      actorInfo: (0, _page.getCustomAccountDetails)($tags)
+    };
+    await use(testPortalActorDetails);
+  }
+};

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

@@ -11,6 +11,7 @@ var _cacheLayer = _interopRequireDefault(require("./cacheLayer"));
 var _addTags = _interopRequireDefault(require("./addTags"));
 var _i18N = _interopRequireDefault(require("./i18N"));
 var _unauthenticatedPage = _interopRequireDefault(require("./unauthenticatedPage"));
+var _executionContext = _interopRequireDefault(require("./executionContext"));
 function extractTagsFromTitle(text) {
   return text.match(/@\w+/g) || [];
 }
@@ -20,7 +21,8 @@ function getBuiltInFixtures(bddMode) {
     ..._context.default,
     ..._cacheLayer.default,
     ..._i18N.default,
-    ..._unauthenticatedPage.default
+    ..._unauthenticatedPage.default,
+    ..._executionContext.default
   };
   if (bddMode) {
     builtInFixtures = {

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+exports.getCustomAccountDetails = getCustomAccountDetails;
 var _auth = require("../helpers/auth");
 var _readConfigFile = require("../readConfigFile");
 /* eslint-disable global-require */
@@ -57,9 +58,10 @@ var _default = exports.default = {
   page: async ({
     context,
     $tags,
-    page
+    page,
+    executionContext
   }, use, testInfo) => {
-    let testPortalDetails = getCustomAccountDetails($tags);
+    let testPortalDetails = executionContext.actorInfo;
     let testDetails = {
       page,
       $tags,
@@ -78,7 +80,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();
 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/buildInFixtures/__tests__/executionContext.test.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _page = require("../../../../../core/playwright/builtInFixtures/page");
+var _executionContext = _interopRequireDefault(require("../../../../../core/playwright/builtInFixtures/executionContext"));
+jest.mock('../../../../../core/playwright/builtInFixtures/page');
+describe('executionContext', () => {
+  test('should pass actorInfo with details from getCustomAccountDetails to use', async () => {
+    const mockTags = ['tag1', 'tag2'];
+    const mockActorInfo = {
+      id: '1',
+      edition: 'enterprise',
+      orgName: 'orgName',
+      profile: 'admin',
+      email: 'xxx.x+uat@zohotest.com'
+    };
+    _page.getCustomAccountDetails.mockReturnValue(mockActorInfo);
+    const use = jest.fn();
+    await _executionContext.default.executionContext({
+      $tags: mockTags
+    }, use);
+    expect(_page.getCustomAccountDetails).toHaveBeenCalledWith(mockTags);
+    expect(use).toHaveBeenCalledWith({
+      actorInfo: mockActorInfo
+    });
+  });
+});

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}`);
     });
   });
 });