@zohodesk/testinglibrary 0.4.48-experimental → 0.4.50-experimental

package/build/setup-folder-structure/setupProject.js

@@ -10,9 +10,8 @@ var _path = _interopRequireDefault(require("path"));
 var _logger = require("../utils/logger");
 function getScriptsToBeAdded() {
   return {
-    "uat": "ZDTestingFramework test --mode=dev --headed",
-    "uat-debug": "ZDTestingFramework test --mode=dev --debug",
-    "uat-validate": "ZDTestingFramework validate",
+    "uat": "ZDTestingFramework test --mode=prod --headed",
+    "uat-debug": "ZDTestingFramework test --mode=prod --debug",
     "uat-report": "ZDTestingFramework report --port=9009",
     "codegen": "ZDTestingFramework codegen deskclientapp.localzoho.com/agent"
   };
@@ -72,11 +71,8 @@ function createAuthenticationFile() {
         });
       }
       (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'auth.setup.js'), getSetupFileAsString('auth-setup-sample.js'), null, 2);
+      (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'authUsers.json'), getSetupFileAsString('authUsers-sample.json'), null, 2);
       _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating Authentication File ....');
-      (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'accountLogin.js'), getSetupFileAsString('accountLogin-sample.js'), null, 2);
-      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating login script File ....');
-      (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'testSetup.js'), getSetupFileAsString('testSetup-sample.js'), null, 2);
-      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating testSetup File ....');
     } catch (err) {
       _logger.Logger.error(err);
       _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Something went wrong ! Folder not Created. Please re-initialize npm init-uat');
@@ -88,21 +84,8 @@ function createAuthenticationFile() {
 function createConfigJson() {
   const uatFolder = _path.default.resolve(process.cwd(), 'uat');
   if ((0, _fs.existsSync)(uatFolder)) {
-    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating settings.json file inside UAT Folder');
-    if (!(0, _fs.existsSync)(_path.default.resolve(uatFolder, 'conf', 'default'))) {
-      (0, _fs.mkdirSync)(_path.default.resolve(uatFolder, 'conf', 'default'), {
-        recursive: true
-      });
-    }
-    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', './settings.json'), getSetupFileAsString('settings.json'), null, 2);
-    if (!(0, _fs.existsSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions'))) {
-      (0, _fs.mkdirSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions'), {
-        recursive: true
-      });
-    }
-    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions', 'free.json'), getSetupFileAsString('free-sample.json'), null, 2);
-    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions', 'index.js'), getSetupFileAsString('editions-index.js'), null, 2);
-    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'index.js'), getSetupFileAsString('actors-index.js'), null, 2);
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating env-config file inside UAT Folder');
+    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, './env-config.json'), getSetupFileAsString('env-config-sample.json'), null, 2);
   } else {
     _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Something went wrong. Please re-initialize the @zohodesk/testinglibrary');
   }

package/build/test/core/playwright/__tests__/tagProcessor.test.js

@@ -2,6 +2,7 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _tagProcessor = _interopRequireDefault(require("../../../../../src/core/playwright/tagProcessor"));
+var _Configuration = _interopRequireDefault(require("../../../../../src/core/playwright/configuration/Configuration.js"));
 var _logger = require("../../../../utils/logger");
 jest.mock('../../../../utils/logger');
 describe('TagProcessor', () => {
@@ -11,83 +12,83 @@ describe('TagProcessor', () => {
   });
   test('should return tagArgs if no edition is provided', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: null
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1');
   });
   test('should handle a single edition with <= operator', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: '<=edition2'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition3 or @edition_edition4)');
   });
   test('should handle a single edition with >= operator', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: '>=edition2'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition1)');
   });
   test('should handle a single edition with < operator', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: '<edition3'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition3 or @edition_edition4)');
   });
   test('should handle a single edition with > operator', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: '>edition1'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition1)');
   });
   test('should handle a single edition with no operator', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: 'edition2'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition1 or @edition_edition3 or @edition_edition4)');
   });
   test('should log a message if edition is not found', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: 'nonexistentEdition'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1');
     expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.INFO_TYPE, expect.stringContaining('No matching editions for nonexistentEdition found.'));
   });
   test('should handle multiple editions', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: 'tag1',
       edition: 'edition1,edition3'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('tag1 and not (@edition_edition2 or @edition_edition4)');
   });
   test('should build tags correctly when tags are empty', () => {
     const tagProcessor = new _tagProcessor.default(editionOrder);
-    const userArgs = {
+    const userArgs = new _Configuration.default({
       tags: '',
       edition: 'edition1'
-    };
+    });
     const result = tagProcessor.processTags(userArgs);
     expect(result).toBe('not (@edition_edition2 or @edition_edition3 or @edition_edition4)');
   });

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

@@ -24,7 +24,7 @@ describe('getUATFileName', () => {
   });
   test('return the default config files for pipeline matched files not exists', () => {
     const mode = 'ci';
-    const defaultPath = `${mockCwd}/uat/conf/default/uat.config.js`;
+    const defaultPath = `${mockCwd}/uat.config.js`;
     _fs.existsSync.mockReturnValue(false);
     _path.default.resolve.mockImplementation((...args) => args.join('/'));
     const result = (0, _configFileNameProvider.getUATFileName)(mode);

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