@zohodesk/testinglibrary 0.0.9 → 0.0.10-n20-experimental

package/build/setup-folder-structure/samples/auth-setup-sample.js

@@ -1,72 +1,15 @@
 /* eslint-disable no-console */
 import { test as setup, expect } from '@zohodesk/testinglibrary';
-import path from 'path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import {
+  performLoginSteps,
+  getDefaultActor
+} from '@zohodesk/testinglibrary/helpers';
 
-const userdata = require('./authUsers.json');
+import { loginSteps , validateLogin } from './testSetup';
 
-const authDirectory = path.resolve(process.cwd(), 'uat', 'playwright', '.auth');
+const user = getDefaultActor();
 
-const authContent = { "cookies": [] };
-
-const LOGIN_ERR_MESSAGE = 'Need go be logged in';
-// const AUTH_ERR_MESSAGE = `Founded Path - ${path.resolve(process.cwd(),'uat','playwright','.auth')} \n Find if file is Properly Created. Cookies Cannot Be Read .. `
-
-
-function convertCookiesToParse(cookies, authFilePath) {
-  try {
-    return JSON.parse(cookies)
-  } catch (err) {
-    throw new Error(` Error while parsing cookies ${err} \n${path.resolve(process.cwd(), authFilePath)} File is Empty`)
-    // process.exit()
-  }
-}
-
-if (!existsSync(authDirectory)) {
-  console.log('Creating auth directory for the first time setup...');
-  mkdirSync(authDirectory, { recursive: true });
-}
-
-userdata.forEach((data) => {
-  const authFile = path.resolve(path.join(authDirectory, `${data.filename}`));
-  if (!existsSync(authFile)) {
-    console.log('creating auth file..');
-    writeFileSync(authFile, JSON.stringify(authContent, null, 2))
-  }
-  setup(data.description, async ({ page }) => {
-
-    try {
-      const cookies = readFileSync(authFile);
-      const parsedCookies = convertCookiesToParse(cookies, authFile);
-      await page.context().addCookies(parsedCookies.cookies === undefined ? [] : parsedCookies.cookies)
-      await page.goto(page.getBaseUrl());
-      await page.waitForLoadState();
-      if (await page.url().includes(process.env.domain)) {
-        await page.waitForSelector(data.locator);
-      } else {
-        throw new Error(LOGIN_ERR_MESSAGE);
-      }
-
-
-    } catch (err) {
-      if (err.message === LOGIN_ERR_MESSAGE) {
-
-        await expect(page.locator('.load-bg')).toBeHidden();
-        await page.locator('#login_id').type(data.useremail);
-        await page.locator('#nextbtn').click();
-        await page.locator('#password').type(data.password);
-        await page.locator('#nextbtn').click();
-
-        await page.waitForLoadState("networkidle");
-
-        await page.waitForSelector(data.locator)
-
-        await page.context().storageState({ path: authFile });
-      }
-
-    }
-
-  });
-
-
-})
+setup(`${user.edition} - Authentication`, async ({ page }) => {
+  //Implement performLoginSteps here
+  await performLoginSteps({page, ...user},validateLogin ,loginSteps);
+}); 

package/build/setup-folder-structure/samples/editions-index.js

@@ -0,0 +1,3 @@
+const free = require('./free.json');
+const editions = { free};
+module.exports = editions;

package/build/setup-folder-structure/samples/free-sample.json

@@ -0,0 +1,25 @@
+[
+    {
+      "id": "1",
+      "edition": "free",
+      "orgName": "orgFree",
+      "profiles": [
+        {
+          "profile": "admin",
+          "email": "admin+free@zohotest.com",
+          "password": "password@0987"
+        },
+        {
+          "profile": "agent",
+          "email": "agent@zohotest.com",
+          "password": "password@12345"
+        },
+        {
+          "profile": "lightagent",
+          "email": "lightagent@zohotest.com",
+          "password": "password@12345"
+        }
+      ]
+    }
+  ]
+  

package/build/setup-folder-structure/samples/git-ignore.sample.js

@@ -2,15 +2,19 @@ import { existsSync, readFileSync, writeFileSync } from 'fs';
 import path from 'path';
 import { Logger } from '../utils/logger';
 import { generateConfigFromFile } from '../core/playwright/readConfigFile';
-
+const gitIgnoreAbsolutePath = path.resolve(process.cwd(), '../', '../')
 
 const { reportPath = path.resolve(process.cwd(), 'uat', 'playwright-reports') } = generateConfigFromFile();
 const testResultsPath = path.resolve(process.cwd(), 'uat', 'test-results');
 
-const testResultsRelativepath = path.relative(path.resolve(process.cwd(), '../', '../'), testResultsPath)
-const reportRelativepath = path.relative(path.resolve(process.cwd(), '../', '../'), reportPath)
+const testResultsRelativepath = path.relative(gitIgnoreAbsolutePath, testResultsPath)
+const reportRelativepath = path.relative(gitIgnoreAbsolutePath, reportPath)
+
+
+const absolutePathfeaturegen = path.resolve(process.cwd(), 'uat', '.features-gen');
+const featuregenRelativePath = path.relative(gitIgnoreAbsolutePath,absolutePathfeaturegen)
 
-const dirpathtoIgnore = `${testResultsRelativepath}\n${reportRelativepath}`
+const dirpathtoIgnore = `${testResultsRelativepath}\n${reportRelativepath}\n${featuregenRelativePath}`
 
 function updateGitIgnore() {
   if (existsSync(path.resolve(process.cwd(), '../', '../', '.gitignore'))) {

package/build/setup-folder-structure/samples/settings.json

@@ -0,0 +1,7 @@
+{
+  "environment": "dev",
+  "edition": "enterprise",
+  "profile": "admin",
+  "domain": "https://zdesk-devops25.csez.zohocorpin.com:31037/agent",
+  "devUrl" : "" 
+}

package/build/setup-folder-structure/samples/testSetup-sample.js

@@ -0,0 +1,14 @@
+/* eslint-disable global-require */
+const accountLogin = require('./accountLogin');
+
+async function verifyPageIsLoaded({page}) {
+
+    //Implement your validation logic here
+    //Refer deskclientapp testSetup.js
+}
+
+module.exports = {
+  loginSteps:accountLogin,
+  validateLogin:verifyPageIsLoaded,
+  page:()=>{}
+};

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

@@ -1,3 +1,4 @@
+const testSetup = require('../../fixtures/testSetup');
 /**
  * @typedef {Object|null} viewportConfig
  * @property {number} width - width of the viewport
@@ -11,7 +12,7 @@
  * @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
+ * @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) 
@@ -22,7 +23,8 @@
  * @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 {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
  */
 
 /**
@@ -36,7 +38,9 @@ module.exports = {
   authFilePath: 'uat/playwright/.auth/user.json',
   trace: true,
   video: true,
+  bddMode: true,
   featureFilesFolder: 'feature-files',
   stepDefinitionsFolder: 'steps',
-  viewport: null
+  viewport: { width: 1280, height: 720 },
+  testSetup
 }

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

@@ -10,8 +10,9 @@ var _path = _interopRequireDefault(require("path"));
 var _logger = require("../utils/logger");
 function getScriptsToBeAdded() {
   return {
-    "uat": "ZDTestingFramework test --mode=prod --headed",
-    "uat-debug": "ZDTestingFramework test --mode=prod --debug",
+    "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"
   };
@@ -61,15 +62,23 @@ function createUatConfig() {
 function createAuthenticationFile() {
   const isUATexist = _path.default.resolve(process.cwd(), 'uat');
   if ((0, _fs.existsSync)(isUATexist)) {
-    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating Authentication File ....');
     try {
-      (0, _fs.mkdirSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures'));
-      (0, _fs.mkdirSync)(_path.default.resolve(process.cwd(), 'uat', 'playwright', '.auth'), {
-        recursive: true
-      });
+      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);
-      (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');
     }
   } else {
@@ -79,8 +88,21 @@ 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 env-config file inside UAT Folder');
-    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, './env-config.json'), getSetupFileAsString('env-config-sample.json'), null, 2);
+    _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');
   }
@@ -91,6 +113,7 @@ function setupProject() {
   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(() => {

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)());
+  });
+});