@zohodesk/testinglibrary 0.0.3 → 0.0.4-n20-experimental

package/build/setup-folder-structure/samples/uat-config-sample.js

@@ -0,0 +1,46 @@
+const testSetup = require('../../fixtures/testSetup');
+/**
+ * @typedef {Object|null} viewportConfig
+ * @property {number} width - width of the viewport
+ * @property {number} height - height of the viewport 
+ */
+/**
+ * Represents the user configuration object.
+ * @typedef {Object} UserConfig
+ * @property {string} headless - Headless Browsers mode.
+ * @property {number} trace - trace for test cases.
+ * @property {boolean} video - video for test cases,
+ * @property {boolean} debug - debug mode
+ * @property {string} mode: mode in which the test cases needs to run
+ * @property {boolean} isAuthMode -  Auth Mode. config whether authentication step needed before running test cases
+ * @property {string} authFilePath - File Path where the cookies stored
+ * @property {any} browsers: List of browsers
+ * @property {string} openReportOn: default Option value (never, on-failure and always) 
+ * @property {any} reportPath : directory where report is generate
+ * @property {boolean} bddMode: Feature files needs to be processed
+ * @property {number} expectTimeout: time in milliseconds which the expect condition should fail
+ * @property {number} testTimeout: time in milliseconds which the test should fail
+ * @property {Object} additionalPages: custom pages configuration
+ * @property {string} featureFilesFolder: folder name under which feature-files will be placed. Default is feature-files
+ * @property {string} stepDefinitionsFolder: folder name under which step implementations will be placed. Default is steps
+ * @property {viewportConfig} viewport: viewport configuration for the browser. Default is { width: 1280, height: 720 }
+ * @property {string} testIdAttribute: Change the default data-testid attribute. configure what attribute to search while calling getByTestId
+ */
+
+/**
+* @type {UserConfig}
+*/
+module.exports = {
+  headless: false,
+  browsers: ['Chrome', 'Firefox', 'Safari', 'Edge'],
+  mode: 'dev',
+  isAuthMode: true,
+  authFilePath: 'uat/playwright/.auth/user.json',
+  trace: true,
+  video: true,
+  bddMode: true,
+  featureFilesFolder: 'feature-files',
+  stepDefinitionsFolder: 'steps',
+  viewport: { width: 1280, height: 720 },
+  testSetup
+}

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

@@ -0,0 +1,122 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = setupProject;
+var _fs = require("fs");
+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-report": "ZDTestingFramework report --port=9009",
+    "codegen": "ZDTestingFramework codegen deskclientapp.localzoho.com/agent"
+  };
+}
+function updatePackageJSONScripts() {
+  const packageJsonPath = _path.default.resolve(process.cwd(), './package.json');
+  if ((0, _fs.existsSync)(packageJsonPath)) {
+    const packageContents = (0, _fs.readFileSync)(packageJsonPath);
+    const configJSON = JSON.parse(packageContents);
+    const {
+      scripts = {}
+    } = configJSON;
+    const modifiedScripts = {
+      ...scripts,
+      ...getScriptsToBeAdded()
+    };
+    const modifiedConfigJSON = {
+      ...configJSON,
+      scripts: modifiedScripts
+    };
+    (0, _fs.writeFileSync)(packageJsonPath, JSON.stringify(modifiedConfigJSON, null, 2));
+  } else {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Unable to find package json. Run init command in the root path of the project.');
+  }
+}
+function createFolderForUAT() {
+  const uatFolder = _path.default.resolve(process.cwd(), 'uat');
+  if ((0, _fs.existsSync)(uatFolder)) {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Uat Folder already Exists.');
+  } else {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating Uat Folder');
+    (0, _fs.mkdirSync)(uatFolder);
+  }
+}
+function getSetupFileAsString(fileName) {
+  return (0, _fs.readFileSync)(_path.default.resolve(__dirname, './samples/', fileName)).toString();
+}
+function createUatConfig() {
+  const uatConfigPath = _path.default.resolve(process.cwd(), 'uat.config.js');
+  if ((0, _fs.existsSync)(uatConfigPath)) {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Uat Config already Exists.');
+  } else {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating Uat config file...');
+    (0, _fs.writeFileSync)(uatConfigPath, getSetupFileAsString('uat-config-sample.js'), null, 2);
+  }
+}
+function createAuthenticationFile() {
+  const isUATexist = _path.default.resolve(process.cwd(), 'uat');
+  if ((0, _fs.existsSync)(isUATexist)) {
+    try {
+      if (!(0, _fs.existsSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures'))) {
+        (0, _fs.mkdirSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures'));
+      }
+      if (!(0, _fs.existsSync)(_path.default.resolve(process.cwd(), 'uat', 'playwright', '.auth'))) {
+        (0, _fs.mkdirSync)(_path.default.resolve(process.cwd(), 'uat', 'playwright', '.auth'), {
+          recursive: true
+        });
+      }
+      (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'auth.setup.js'), getSetupFileAsString('auth-setup-sample.js'), 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');
+    }
+  } else {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Something went wrong. Please re-initialize the @zohodesk/testinglibrary');
+  }
+}
+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);
+  } else {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Something went wrong. Please re-initialize the @zohodesk/testinglibrary');
+  }
+}
+function setupProject() {
+  updatePackageJSONScripts();
+  createUatConfig();
+  createFolderForUAT();
+  createConfigJson();
+  createAuthenticationFile();
+  //updateGitIgnore()
+  // Create folder for playwright . Inside .auth folder needs to be created. user.json
+  // Add playwright and test-results to .gitignore
+  setTimeout(() => {
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Setup Project is Ready ..');
+  }, 2000);
+}

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

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _tagProcessor = _interopRequireDefault(require("../../../../../src/core/playwright/tagProcessor"));
+var _logger = require("../../../../utils/logger");
+jest.mock('../../../../utils/logger');
+describe('TagProcessor', () => {
+  const editionOrder = ['edition1', 'edition2', 'edition3', 'edition4'];
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('should return tagArgs if no edition is provided', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      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 = {
+      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 = {
+      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 = {
+      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 = {
+      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 = {
+      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 = {
+      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 = {
+      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 = {
+      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/__tests__/validateFeature.test.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _validateFeature = _interopRequireDefault(require("../../../../core/playwright/validateFeature"));
+var _parseUserArgs = _interopRequireDefault(require("../../../../core/playwright/helpers/parseUserArgs"));
+var _readConfigFile = require("../../../../core/playwright/readConfigFile");
+var _tagProcessor = _interopRequireDefault(require("../../../../core/playwright/tagProcessor"));
+var _testRunner = require("../../../../core/playwright/test-runner");
+var _logger = require("../../../../utils/logger");
+jest.mock('../../../../core/playwright/helpers/parseUserArgs', () => ({
+  __esModule: true,
+  default: jest.fn()
+}));
+jest.mock('../../../../core/playwright/readConfigFile');
+jest.mock('../../../../core/playwright/tagProcessor');
+jest.mock('../../../../core/playwright/test-runner');
+jest.mock('../../../../utils/logger', () => ({
+  __esModule: true,
+  Logger: {
+    log: jest.fn(),
+    SUCCESS_TYPE: 'success',
+    FAILURE_TYPE: 'failure'
+  }
+}));
+describe('validateFeatureFiles', () => {
+  let tagProcessorInstance;
+  beforeEach(() => {
+    jest.clearAllMocks();
+    tagProcessorInstance = {
+      processTags: jest.fn()
+    };
+    _tagProcessor.default.mockImplementation(() => tagProcessorInstance);
+  });
+  test('runPreprocessing with correct arguments and log success', async () => {
+    const mockUserArgs = {
+      mode: 'dev'
+    };
+    _parseUserArgs.default.mockReturnValue(mockUserArgs);
+    const mockConfig = {
+      editionOrder: ["beta", "enterprice"]
+    };
+    _readConfigFile.generateConfigFromFile.mockReturnValue(mockConfig);
+    _readConfigFile.isUserConfigFileAvailable.mockReturnValue(true);
+    const mockTagArgs = ['@beta_admin'];
+    tagProcessorInstance.processTags.mockReturnValue(mockTagArgs);
+    _testRunner.runPreprocessing.mockResolvedValueOnce();
+    await (0, _validateFeature.default)();
+    expect(_parseUserArgs.default).toHaveBeenCalled();
+    expect(_readConfigFile.generateConfigFromFile).toHaveBeenCalled();
+    expect(_readConfigFile.isUserConfigFileAvailable).toHaveBeenCalled();
+    expect(tagProcessorInstance.processTags).toHaveBeenCalledWith(mockUserArgs);
+    expect(_testRunner.runPreprocessing).toHaveBeenCalledWith(mockTagArgs, expect.stringContaining('config-creator.js'));
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.SUCCESS_TYPE, 'Feature files validated successfully.');
+  });
+  test('runPreprocessing with playwright conf', async () => {
+    const mockTagArgs = ['@beta_admin'];
+    tagProcessorInstance.processTags.mockReturnValue(mockTagArgs);
+    _readConfigFile.isUserConfigFileAvailable.mockReturnValue(false);
+    _testRunner.runPreprocessing.mockResolvedValueOnce();
+    await (0, _validateFeature.default)();
+    expect(_testRunner.runPreprocessing).toHaveBeenCalledWith(mockTagArgs, expect.stringContaining('playwright.config.js'));
+  });
+  test('error when runPreprocessing fails', async () => {
+    const mockError = new Error('Test error');
+    _testRunner.runPreprocessing.mockRejectedValueOnce(mockError);
+    await await (0, _validateFeature.default)();
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, `Error while validating the feature files - ${mockError}`);
+  });
+});

package/build/test/core/playwright/buildInFixtures/__tests__/executionContext.test.js

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

package/build/test/core/playwright/configuration/__tests__/Configuration.test.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const Configuration = require("../../../../../core/playwright/configuration/Configuration");
+const {
+  combineConfiguration
+} = require("../../../../../core/playwright/configuration/ConfigurationHelper");
+jest.mock('../../../../../core/playwright/configuration/ConfigurationHelper', () => ({
+  combineConfiguration: jest.fn()
+}));
+describe('Configuration Class', () => {
+  let config;
+  let sampleData;
+  beforeEach(() => {
+    // Sample data as a JSON object
+    sampleData = {
+      headless: false,
+      trace: true,
+      video: true,
+      bddMode: true
+    };
+
+    // Initialize the Configuration instance with sample data
+    config = new Configuration(sampleData);
+  });
+  test('should add new key-value pair to the configuration', () => {
+    config.add('newKey', 'newValue');
+    expect(config.get('newKey')).toBe('newValue');
+  });
+  test('should combine configurations correctly using addAll', () => {
+    const newConfig = new Configuration({
+      newKey1: 'newValue1',
+      trace: false // existing key to test override
+    });
+    const combinedConfig = {
+      headless: false,
+      trace: false,
+      // trace overridden
+      video: true,
+      bddMode: true,
+      newKey1: 'newValue1'
+    };
+    combineConfiguration.mockReturnValue(combinedConfig);
+    config.addAll(newConfig);
+    expect(combineConfiguration).toHaveBeenCalledWith(sampleData, newConfig.getAll());
+    expect(config.getAll()).toEqual(combinedConfig);
+  });
+  test('should return correct value for a given key', () => {
+    expect(config.get('headless')).toBe(false);
+    expect(config.get('trace')).toBe(true);
+    expect(config.get('video')).toBe(true);
+    expect(config.get('bddMode')).toBe(true);
+  });
+});

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

@@ -0,0 +1,45 @@
+"use strict";
+
+var _additionalProfiles = require("../../../../../core/playwright/helpers/additionalProfiles");
+jest.mock('../../../../../core/playwright/helpers/auth/getUsers', () => ({
+  getUserForSelectedEditionAndProfile: jest.fn((edition, profile, betaFeature, portalInfo) => {
+    return {
+      email: 'manager.m@zohotest.com',
+      id: '1',
+      edition: edition || 'enterprise',
+      orgName: 'orgName',
+      profile: profile || 'admin',
+      betaFeature: betaFeature || null,
+      portalInfo: portalInfo || null
+    };
+  })
+}));
+const defaultTags = ['@profile_admin', '@edition_enterprise'];
+const editionTags = ['@profile_admin', '@edition_enterprise', '@additional_profile_manager', '@additional_profile_agent'];
+const editionAndPortalTags = ['@profile_admin', '@edition_enterprise', '@beta_parentchild', '@portal_clientuat2', '@additional_profile_manager'];
+describe('additionalProfiles', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('should return empty object when no additional profile tags are present', () => {
+    const result = (0, _additionalProfiles.additionProfiles)(defaultTags);
+    expect(result).toEqual({});
+  });
+  test('should return additional profile actors when additional profile tags and editionInfo are present', () => {
+    const result = (0, _additionalProfiles.additionProfiles)(editionTags);
+    expect(Object.keys(result)).toEqual(['manager', 'agent']);
+    expect(result.manager).toHaveProperty('email');
+    expect(result.agent).toHaveProperty('email');
+    expect(result.manager.profile).toBe('manager');
+    expect(result.manager.betaFeature).toBe(null);
+    expect(result.agent.portalInfo).toBe(null);
+  });
+  test('should return additional profile actors when all actor details are present', () => {
+    const result = (0, _additionalProfiles.additionProfiles)(editionAndPortalTags);
+    expect(Object.keys(result)).toEqual(['manager']);
+    expect(result.manager).toHaveProperty('email');
+    expect(result.manager.profile).toBe('manager');
+    expect(result.manager.betaFeature).toBe("parentchild");
+    expect(result.manager.portalInfo).toBe("clientuat2");
+  });
+});

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

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _configFileNameProvider = require("../../../../../core/playwright/helpers/configFileNameProvider");
+jest.mock('fs');
+jest.mock('path');
+const mockCwd = '/mock/current/directory';
+_path.default.resolve = jest.fn();
+process.cwd = jest.fn(() => mockCwd);
+describe('getUATFileName', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('return the pipeline matched config files for pipeline matched files exists', () => {
+    const mode = 'cd';
+    const mockPath = `${mockCwd}/uat/conf/${mode}/uat.config.js`;
+    _fs.existsSync.mockReturnValue(true);
+    _path.default.resolve.mockImplementation((...args) => args.join('/'));
+    const result = (0, _configFileNameProvider.getUATFileName)(mode);
+    expect(_fs.existsSync).toHaveBeenCalledWith(mockPath);
+    expect(result).toBe(mockPath);
+  });
+  test('return the default config files for pipeline matched files not exists', () => {
+    const mode = 'ci';
+    const defaultPath = `${mockCwd}/uat/conf/default/uat.config.js`;
+    _fs.existsSync.mockReturnValue(false);
+    _path.default.resolve.mockImplementation((...args) => args.join('/'));
+    const result = (0, _configFileNameProvider.getUATFileName)(mode);
+    expect(_fs.existsSync).toHaveBeenCalledWith(`${mockCwd}/uat/conf/${mode}/uat.config.js`);
+    expect(result).toBe(defaultPath);
+  });
+});

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

@@ -0,0 +1,51 @@
+"use strict";
+
+var _customFixturesHelper = require("../../../../../core/playwright/helpers/customFixturesHelper");
+var _logger = require("../../../../../utils/logger");
+var _getUsers = require("../../../../../core/playwright/helpers/auth/getUsers");
+jest.mock('../../../../../core/playwright/helpers/auth/getUsers', () => ({
+  getUserForSelectedEditionAndProfile: jest.fn((edition, profile, betaFeature, portalInfo) => ({
+    email: 'manager.m@zohotest.com',
+    id: '1',
+    edition: edition || 'enterprise',
+    orgName: 'orgName',
+    profile: profile || 'admin',
+    betaFeature: betaFeature || null,
+    portalInfo: portalInfo || null
+  })),
+  getDefaultActor: jest.fn(() => ({
+    edition: 'enterprise',
+    profile: 'admin'
+  }))
+}));
+jest.mock('../../../../../utils/logger', () => ({
+  Logger: {
+    log: jest.fn(),
+    FAILURE_TYPE: 'FAILURE'
+  }
+}));
+const mockTags = ['@profile_admin', '@edition_enterprise', '@beta_feature', '@portal_clientuat'];
+describe('getCustomAccountDetails', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('returns selected user when any tag info is present', () => {
+    const result = (0, _customFixturesHelper.getCustomAccountDetails)(mockTags);
+    expect(_getUsers.getUserForSelectedEditionAndProfile).toHaveBeenCalledWith('enterprise', 'admin', 'feature', 'clientuat');
+    expect(result).toHaveProperty('email', 'manager.m@zohotest.com');
+  });
+  test('logs and returns undefined if getCustomAccountDetails function throws', () => {
+    const error = new Error('failed to get user');
+    _getUsers.getUserForSelectedEditionAndProfile.mockImplementation(() => {
+      throw error;
+    });
+    const result = (0, _customFixturesHelper.getCustomAccountDetails)(mockTags);
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, 'Error while getting accounts details:', error);
+    expect(result).toBeUndefined();
+  });
+  test('returns default actor when no tag info is not provided', () => {
+    const result = (0, _customFixturesHelper.getCustomAccountDetails)([]);
+    expect(_getUsers.getDefaultActor).toHaveBeenCalledTimes(1);
+    expect(result).toEqual((0, _getUsers.getDefaultActor)());
+  });
+});

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

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fileMutex = _interopRequireDefault(require("../../../../../core/playwright/helpers/fileMutex"));
+var _path = _interopRequireDefault(require("path"));
+var _fs = require("fs");
+jest.mock('fs');
+describe('FileMutex', () => {
+  const directory = '/tmp/locks';
+  const lockFileName = 'test-lock';
+  const fileDeletionTimeoutConfig = {
+    timeout: 1000
+  };
+  const lockFilePath = _path.default.resolve(directory, lockFileName + '.lock');
+  let fileMutex;
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fileMutex = new _fileMutex.default(directory, lockFileName, fileDeletionTimeoutConfig);
+  });
+  describe('acquire', () => {
+    it('should create the lock file if it does not exist', async () => {
+      _fs.writeFileSync.mockImplementation(() => {});
+      await fileMutex.acquire();
+      expect(_fs.writeFileSync).toHaveBeenCalledWith(fileMutex.lockFilePath, 'locked');
+    });
+    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(_fs.watch).toHaveBeenCalledWith(directory, expect.any(Function));
+    });
+    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 delete the lock file if it exists', async () => {
+      _fs.existsSync.mockReturnValue(true);
+      _fs.unlinkSync.mockImplementation(() => {});
+      await fileMutex.release();
+      expect(_fs.existsSync).toHaveBeenCalledWith(lockFilePath);
+      expect(_fs.unlinkSync).toHaveBeenCalledWith(lockFilePath);
+    });
+    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);
+      });
+      await expect(fileMutex.release()).rejects.toThrow(errorMessage);
+    });
+  });
+});