@zohodesk/testinglibrary 0.1.9 → 0.1.16-experimental

package/build/core/playwright/fixtures.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _test = require("@playwright/test");
+var _playwrightBdd = require("playwright-bdd");
+var _readConfigFile = require("./readConfigFile");
+var _builtInFixtures = _interopRequireDefault(require("./builtInFixtures"));
+var _getUserFixtures = _interopRequireDefault(require("./helpers/getUserFixtures"));
+const {
+  bddMode
+} = (0, _readConfigFile.generateConfigFromFile)();
+let base = bddMode ? _playwrightBdd.test : _test.test;
+const buildInFixtures = (0, _builtInFixtures.default)(bddMode);
+const buildInFixturesTest = base.extend({
+  ...buildInFixtures
+});
+const userFixtures = (0, _getUserFixtures.default)();
+const userFixturesTest = base.extend({
+  ...userFixtures
+});
+const test = (0, _test.mergeTests)(buildInFixturesTest, userFixturesTest);
+module.exports = {
+  test
+};

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

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.additionProfiles = additionProfiles;
+var _getUsers = require("./auth/getUsers");
+var _customFixturesHelper = require("./customFixturesHelper");
+function additionProfiles(tags) {
+  const {
+    editionInfo,
+    betaFeature,
+    portalInfo
+  } = (0, _customFixturesHelper.extractTagInfo)(tags);
+  const additionalProfileTags = tags.filter(tag => tag.startsWith('@additional_profile_'));
+  let additionalProfileActors = {};
+  if (additionalProfileTags.length > 0) {
+    additionalProfileTags.forEach(tag => {
+      const additionalProfile = tag.replace('@additional_profile_', '');
+      const actorDetails = (0, _getUsers.getUserForSelectedEditionAndProfile)(editionInfo, additionalProfile, betaFeature, portalInfo);
+      additionalProfileActors[additionalProfile] = actorDetails;
+    });
+  }
+  return additionalProfileActors;
+}

package/build/core/playwright/helpers/auth/accountLogin.js

@@ -13,6 +13,9 @@ async function accountLogin(page, useremail, password) {
   await page.locator('#nextbtn').click();
   const domainUrlOrigin = (0, _getUrlOrigin.default)(process.env.domain);
   await page.waitForNavigation();
-  await Promise.race([page.waitForURL(`${domainUrlOrigin}/**`), page.waitForURL('**/announcement/**')]);
+  if (!page.url().includes(domainUrlOrigin)) {
+    await page.goto(domainUrlOrigin);
+  }
+  await page.waitForURL(`${domainUrlOrigin}/**`);
 }
 var _default = exports.default = accountLogin;

package/build/core/playwright/helpers/auth/checkAuthCookies.js

@@ -4,44 +4,48 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.authDirectory = void 0;
+exports.getAuthFileDirectory = getAuthFileDirectory;
 exports.loadCookiesIfPresent = loadCookiesIfPresent;
+exports.storeFilteredStorageState = storeFilteredStorageState;
 exports.verifyIfCookieFileExists = verifyIfCookieFileExists;
 var _path = _interopRequireDefault(require("path"));
 var _fs = require("fs");
 var _readConfigFile = require("../../readConfigFile");
+var _fileUtils = require("../../../../utils/fileUtils");
+var _logger = require("../../../../utils/logger");
 /* eslint-disable no-console */
 
-const {
-  uatDirectory
-} = (0, _readConfigFile.generateConfigFromFile)();
-const authDirectory = exports.authDirectory = _path.default.resolve(_path.default.join(uatDirectory, 'playwright', '.auth'));
-const authContent = {
-  cookies: []
-};
+const authCookieNameKeys = ['iamadt', 'iambdt', 'iamsdt'];
+function getAuthFileDirectory() {
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  return _path.default.resolve(_path.default.join(uatDirectory, 'playwright', '.auth'));
+}
 function verifyIfCookieFileExists(authFile) {
-  if (!(0, _fs.existsSync)(authDirectory)) {
-    console.log('Creating auth directory for the first time setup...');
-    (0, _fs.mkdirSync)(authDirectory, {
-      recursive: true
-    });
-  }
-  if (!(0, _fs.existsSync)(authFile)) {
-    console.log('creating auth file..');
-    (0, _fs.writeFileSync)(authFile, JSON.stringify(authContent, null, 2));
-  }
+  return (0, _fs.existsSync)(authFile);
 }
 function convertCookiesToParse(cookies, authFilePath) {
   try {
     return JSON.parse(cookies);
   } catch (err) {
+    _logger.Logger.error(err);
     throw new Error(` Error while parsing cookies ${err} \n${_path.default.resolve(process.cwd(), authFilePath)} File is Empty`);
-    // process.exit()
   }
 }
 async function loadCookiesIfPresent(page, authFile) {
-  verifyIfCookieFileExists(authFile);
-  const cookies = (0, _fs.readFileSync)(authFile);
-  const parsedCookies = convertCookiesToParse(cookies, authFile);
-  await page.context().addCookies(parsedCookies.cookies === undefined ? [] : parsedCookies.cookies);
+  if (verifyIfCookieFileExists(authFile)) {
+    const fileContent = (0, _fs.readFileSync)(authFile);
+    const stroageState = convertCookiesToParse(fileContent, authFile);
+    if (stroageState.cookies) {
+      await page.context().addCookies(stroageState.cookies);
+    }
+  }
+}
+async function storeFilteredStorageState(page, authFile) {
+  const storageState = await page.context().storageState();
+  const filteredCookies = storageState.cookies.filter(cookie => authCookieNameKeys.some(key => cookie.name.includes(key)));
+  (0, _fileUtils.writeFileContents)(authFile, JSON.stringify({
+    cookies: filteredCookies
+  }, null, 2));
 }

package/build/core/playwright/helpers/auth/getUsers.js

@@ -4,69 +4,116 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getListOfUsers = getListOfUsers;
-exports.getPrimaryUser = getPrimaryUser;
+exports.getDefaultActor = getDefaultActor;
+exports.getDefaultActorConf = getDefaultActorConf;
+exports.getListOfActors = getListOfActors;
+exports.getRunMode = getRunMode;
 exports.getUserForSelectedEditionAndProfile = getUserForSelectedEditionAndProfile;
 exports.isCI = isCI;
+exports.isDevelopmentSetup = isDevelopmentSetup;
 var _path = _interopRequireDefault(require("path"));
-var _readConfigFile = require("../../readConfigFile");
+var _fs = require("fs");
+var _configPathResolver = require("../configPathResolver");
+var _ConfigurationHelper = require("./../../configuration/ConfigurationHelper");
+var _configConstants = _interopRequireDefault(require("../../constants/configConstants"));
 /* eslint-disable global-require */
+function getRunMode() {
+  let {
+    mode
+  } = process.env;
+  return mode || 'dev';
+}
 function isCI() {
-  return process.env.mode === 'CI' || process.env.mode === 'ci';
+  const mode = getRunMode();
+  return mode === 'CI' || mode === 'ci';
 }
-function getListOfUsers() {
-  let users;
-  const {
-    uatDirectory
-  } = (0, _readConfigFile.generateConfigFromFile)();
-  if (isCI()) {
-    users = require(_path.default.join(uatDirectory, 'conf/ci/actors/index'));
-  } else {
-    users = require(_path.default.join(uatDirectory, 'conf/dev/actors/index'));
+function isDevelopmentSetup() {
+  const mode = getRunMode();
+  return mode === 'DEV' || mode === 'dev';
+}
+function getDefaultActorConf() {
+  const stage = (0, _ConfigurationHelper.getRunStage)();
+  const stagePath = (0, _configPathResolver.getConfigPath)(stage);
+  const modeSettingsFile = `${stagePath}/${getRunMode()}/${_configConstants.default.SETTINGS_FILE}`;
+  const filePath = _path.default.join(_path.default.resolve(process.cwd(), modeSettingsFile));
+  try {
+    if (!(0, _fs.existsSync)(filePath)) {
+      const defaultSettingsFile = _path.default.join(_path.default.resolve(process.cwd(), `${stagePath}/${_configConstants.default.DEFAULT_CONFIG_DIR}/${_configConstants.default.SETTINGS_FILE}`));
+      return require(defaultSettingsFile);
+    }
+    return require(filePath);
+  } catch (error) {
+    throw new Error(`${filePath} file missing.`);
   }
-  return users;
 }
-function getPrimaryUser() {
-  let primaryUser;
+function getDefaultActor() {
   const {
-    uatDirectory
-  } = (0, _readConfigFile.generateConfigFromFile)();
-  if (isCI()) {
-    primaryUser = require(_path.default.join(uatDirectory, 'conf/ci/settings.json'));
-  } else {
-    primaryUser = require(_path.default.join(uatDirectory, 'conf/dev/settings.json'));
+    edition,
+    profile
+  } = getDefaultActorConf();
+  return getUserForSelectedEditionAndProfile(edition, profile);
+}
+function getListOfActors(betaFeature) {
+  const mode = getRunMode();
+  const stage = (0, _ConfigurationHelper.getRunStage)();
+  const stagePath = (0, _configPathResolver.getConfigPath)(stage);
+  let configFile = _path.default.join(_path.default.resolve(process.cwd(), `${stagePath}/${mode}/${_configConstants.default.ACTOR_DIR}/${_configConstants.default.INDEX_FILE}`));
+  let betaReference = mode;
+  if (!(0, _fs.existsSync)(configFile)) {
+    configFile = _path.default.join(_path.default.resolve(process.cwd(), `${stagePath}/${_configConstants.default.DEFAULT_CONFIG_DIR}/${_configConstants.default.ACTOR_DIR}/${_configConstants.default.INDEX_FILE}`));
+    betaReference = "default";
+  }
+  if (betaFeature) {
+    configFile = _path.default.join(_path.default.resolve(process.cwd(), `${stagePath}/${betaReference}/${_configConstants.default.ACTOR_DIR}/${_configConstants.default.BETA_DIR}/${betaFeature}/${_configConstants.default.INDEX_FILE}`));
+    if (!(0, _fs.existsSync)(configFile)) {
+      throw new Error(`There is no beta feature configured with the name "${betaFeature}"`);
+    }
+  }
+  try {
+    return require(configFile);
+  } catch (error) {
+    throw new Error(`Error loading actor configuration from ${configFile}`);
   }
-  return primaryUser;
 }
-function getUserForSelectedEditionAndProfile(preferedEdition, preferredProfile, darkLaunchFeature) {
+function getUserForSelectedEditionAndProfile(preferedEdition, preferredProfile, betaFeature, testDataPortal = null) {
+  const actorsData = getListOfActors(betaFeature);
+  if (!actorsData || !actorsData.editions) {
+    throw new Error("The actors data is missing.");
+  }
   const {
-    editions: userdata,
-    darkLaunch
-  } = getListOfUsers();
-  const primaryUser = getPrimaryUser();
-  const edition = preferedEdition || primaryUser.edition;
-  const profile = preferredProfile || primaryUser.role;
+    editions: userdata
+  } = actorsData;
+  const defaultConf = getDefaultActorConf();
+  const edition = preferedEdition || defaultConf.edition;
+  const profile = preferredProfile || defaultConf.profile;
   let selectedProfile = {};
-  if (darkLaunchFeature && darkLaunchFeature !== null) {
-    const {
-      profiles: darkLaunchProfiles,
-      ...darkLaunchEditionData
-    } = darkLaunch[darkLaunchFeature] ? darkLaunch[darkLaunchFeature][0] : {};
-    selectedProfile = darkLaunchProfiles.find(user => user.role === profile);
-    return {
-      ...darkLaunchEditionData,
-      ...selectedProfile
-    };
-  }
-  // TODO: We are returning the first data from array. We need to check the possiblity of having multiple users for same role and possibly round robin
+
+  // TODO: We are returning the first data from array. We need to check the possiblity of having multiple users for same profile and possibly round robin
   // For this we need to get the data from ci environment.
+
+  let testingPortal = null;
+  if (!userdata.hasOwnProperty(edition)) {
+    throw new Error(`There is no edition configured with the name "${edition}"`);
+  }
+  if (testDataPortal !== null) {
+    testingPortal = userdata[edition].find(editionData => editionData.orgName === testDataPortal);
+    if (!testingPortal) {
+      throw new Error(`There is no portal configured with the name "${testDataPortal}" in the "${edition}" edition.`);
+    }
+  } else {
+    testingPortal = userdata[edition] ? userdata[edition][0] : {};
+  }
   const {
     profiles,
     ...editionData
-  } = userdata[edition] ? userdata[edition][0] : {};
-  selectedProfile = profiles.find(user => user.role === profile);
+  } = testingPortal;
+  selectedProfile = profiles.find(user => user.profile === profile);
+  if (!selectedProfile) {
+    throw new Error(`There is no profile configured with the name "${profile}" in the "${edition}" edition.`);
+  }
   return {
     ...editionData,
-    ...selectedProfile
+    ...selectedProfile,
+    'beta': betaFeature
   };
 }

package/build/core/playwright/helpers/auth/index.js

@@ -10,16 +10,34 @@ Object.defineProperty(exports, "accountLogin", {
     return _accountLogin.default;
   }
 });
-Object.defineProperty(exports, "getListOfUsers", {
+Object.defineProperty(exports, "getDefaultActor", {
   enumerable: true,
   get: function () {
-    return _getUsers.getListOfUsers;
+    return _getUsers.getDefaultActor;
   }
 });
-Object.defineProperty(exports, "getPrimaryUser", {
+Object.defineProperty(exports, "getDefaultActorConf", {
   enumerable: true,
   get: function () {
-    return _getUsers.getPrimaryUser;
+    return _getUsers.getDefaultActorConf;
+  }
+});
+Object.defineProperty(exports, "getListOfActors", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.getListOfActors;
+  }
+});
+Object.defineProperty(exports, "getRunMode", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.getRunMode;
+  }
+});
+Object.defineProperty(exports, "getRunStage", {
+  enumerable: true,
+  get: function () {
+    return _ConfigurationHelper.getRunStage;
   }
 });
 Object.defineProperty(exports, "getUserForSelectedEditionAndProfile", {
@@ -34,6 +52,12 @@ Object.defineProperty(exports, "isCI", {
     return _getUsers.isCI;
   }
 });
+Object.defineProperty(exports, "isDevelopmentSetup", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.isDevelopmentSetup;
+  }
+});
 Object.defineProperty(exports, "loadCookiesIfPresent", {
   enumerable: true,
   get: function () {
@@ -55,4 +79,5 @@ Object.defineProperty(exports, "verifyIfCookieFileExists", {
 var _accountLogin = _interopRequireDefault(require("./accountLogin"));
 var _checkAuthCookies = require("./checkAuthCookies");
 var _getUsers = require("./getUsers");
-var _loginSteps = _interopRequireDefault(require("./loginSteps"));
+var _loginSteps = _interopRequireDefault(require("./loginSteps"));
+var _ConfigurationHelper = require("../../configuration/ConfigurationHelper");

package/build/core/playwright/helpers/auth/loginDefaultStepsHelper.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.executeDefaultLoginSteps = executeDefaultLoginSteps;
+exports.getAuthenticationPrefix = getAuthenticationPrefix;
+exports.loginSteps = loginSteps;
+exports.performDefaultPageSteps = performDefaultPageSteps;
+exports.verifyPageIsLoaded = verifyPageIsLoaded;
+var _auth = require("../auth");
+var _readConfigFile = require("../../readConfigFile");
+var _logger = require("../../../../utils/logger");
+let {
+  testSetup,
+  isAuthMode
+} = (0, _readConfigFile.generateConfigFromFile)();
+async function loginSteps(pageDetail) {
+  const {
+    page
+  } = pageDetail;
+  if (testSetup.loginSteps && typeof testSetup.loginSteps === 'function') {
+    return await testSetup.loginSteps(pageDetail);
+  } else {
+    await page.goto(process.env.domain);
+  }
+}
+async function performDefaultPageSteps(testInfo) {
+  if (testSetup.page && typeof testSetup.page === 'function') {
+    await testSetup.page(testInfo);
+  }
+}
+async function verifyPageIsLoaded(testInfo) {
+  if (testSetup.validateLogin && typeof testSetup.validateLogin === 'function') {
+    return await testSetup.validateLogin(testInfo);
+  }
+  return true;
+}
+async function getAuthenticationPrefix(testDetails) {
+  if (testSetup.getAuthenticationPrefix && typeof testSetup.getAuthenticationPrefix === 'function') {
+    return await testSetup.getAuthenticationPrefix(testDetails);
+  }
+  return process.env.authFilePrefix;
+}
+async function executeDefaultLoginSteps(context, testInfo, testDetails, testPortalDetails) {
+  if (!isAuthMode) {
+    return;
+  }
+  try {
+    const projectName = testInfo.project.name;
+    testDetails.authFilePrefix = await getAuthenticationPrefix(testDetails);
+    if (testPortalDetails && projectName !== 'setup' && projectName !== 'cleanup') {
+      await context.clearCookies();
+      await (0, _auth.performLoginSteps)(testDetails, async testInfo => {
+        return await verifyPageIsLoaded(testInfo);
+      }, loginSteps);
+      process.env.actorInfo = JSON.stringify(testPortalDetails);
+    }
+  } catch (error) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Error while executing the default login steps:', error);
+  }
+}

package/build/core/playwright/helpers/auth/loginSteps.js

@@ -6,31 +6,49 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _path = _interopRequireDefault(require("path"));
-var _accountLogin = _interopRequireDefault(require("./accountLogin"));
+var _fileMutex = _interopRequireDefault(require("../fileMutex"));
+var _fileMutexConfig = require("../../constants/fileMutexConfig");
 var _checkAuthCookies = require("./checkAuthCookies");
+var _checkAuthDirectory = require("../checkAuthDirectory");
 /* eslint-disable no-console */
 
-async function performLoginSteps({
-  page,
-  role,
-  useremail,
-  password
-}, isLoggedIn) {
-  const authFile = _path.default.resolve(_path.default.join(_checkAuthCookies.authDirectory, `${role}-cookies.json`));
-  await (0, _checkAuthCookies.loadCookiesIfPresent)(page, authFile);
-  await page.goto(process.env.domain);
-  await page.waitForNavigation();
-  const loginStatus = await isLoggedIn(page);
-  if (!loginStatus) {
-    await (0, _accountLogin.default)(page, useremail, password);
-    await page.goto(process.env.domain);
-
-    // await page.waitForLoadState();
-
-    await isLoggedIn(page);
-    await page.context().storageState({
-      path: authFile
-    });
+async function performLoginSteps(testInfo, isLoggedIn, loginSteps) {
+  let {
+    page,
+    authFilePrefix,
+    email
+  } = testInfo;
+  let authFileName;
+  if (authFilePrefix) {
+    authFileName = `${authFilePrefix}-${email}`;
+    process.env.authFilePrefix = authFilePrefix;
+  } else {
+    authFileName = `${email}`;
+  }
+  const authFile = _path.default.resolve(_path.default.join((0, _checkAuthCookies.getAuthFileDirectory)(), `${authFileName}-cookies.json`));
+  const lockFileName = `${authFileName}`.replace(/[@.]/g, '_');
+  const fileMutex = new _fileMutex.default((0, _checkAuthDirectory.getLockDirectoryPath)(), lockFileName, _fileMutexConfig.fileDeletionTimeoutConfig);
+  let loginUsingCookie = false;
+  try {
+    if ((0, _checkAuthCookies.verifyIfCookieFileExists)(authFile)) {
+      console.log(`${authFileName} Cookie file exists. Loading cookies, worker index - ${process.env.TEST_WORKER_INDEX}`);
+      loginUsingCookie = true;
+    } else {
+      await fileMutex.acquire();
+    }
+    await (0, _checkAuthCookies.loadCookiesIfPresent)(page, authFile);
+    const isAlreadyLoggedIn = await isLoggedIn(testInfo);
+    if (!isAlreadyLoggedIn) {
+      await loginSteps(testInfo);
+      await isLoggedIn(testInfo);
+      await (0, _checkAuthCookies.storeFilteredStorageState)(page, authFile);
+    }
+  } catch (error) {
+    console.error(`Error during login for ${authFileName}:`, error);
+  } finally {
+    if (!loginUsingCookie) {
+      await fileMutex.release();
+    }
   }
 }
 var _default = exports.default = performLoginSteps;

package/build/core/playwright/helpers/browserTimeoutFactor.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBrowserTimeoutFactor = getBrowserTimeoutFactor;
+var _browserTypes = require("../constants/browserTypes");
+function getBrowserTimeoutFactor(projectName) {
+  if (projectName === _browserTypes.BROWSER_PROJECT_MAPPING.FIREFOX) {
+    return 2;
+  }
+  if (projectName === _browserTypes.BROWSER_PROJECT_MAPPING.SAFARI) {
+    return 4;
+  }
+  return 1;
+}

package/build/core/playwright/helpers/caseTimeoutResolver.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TIMEOUT_TAG_PATTERN = void 0;
+exports.findTimeoutTags = findTimeoutTags;
+exports.parseTimeoutSeconds = parseTimeoutSeconds;
+exports.resolveCaseTimeoutMs = resolveCaseTimeoutMs;
+var _logger = require("../../../utils/logger");
+var _browserTimeoutFactor = require("./browserTimeoutFactor");
+const TIMEOUT_TAG_PATTERN = exports.TIMEOUT_TAG_PATTERN = /^@timeout_(\d+)$/;
+function findTimeoutTags(tags) {
+  if (!Array.isArray(tags)) {
+    return [];
+  }
+  return tags.filter(tag => typeof tag === 'string' && TIMEOUT_TAG_PATTERN.test(tag));
+}
+function parseTimeoutSeconds(tag) {
+  const match = tag.match(TIMEOUT_TAG_PATTERN);
+  return match ? Number(match[1]) : null;
+}
+function resolveCaseTimeoutMs(tags, projectName) {
+  const matched = findTimeoutTags(tags);
+  if (matched.length === 0) {
+    return null;
+  }
+  if (matched.length > 1) {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Multiple @timeout_* tags found (${matched.join(', ')}). Using the first one: ${matched[0]}`);
+  }
+  const seconds = parseTimeoutSeconds(matched[0]);
+  if (seconds === 0) {
+    return 0;
+  }
+  const factor = (0, _browserTimeoutFactor.getBrowserTimeoutFactor)(projectName);
+  return seconds * 1000 * factor;
+}

package/build/core/playwright/helpers/checkAuthDirectory.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAuthDirectoryIfNotExist = createAuthDirectoryIfNotExist;
+exports.getLockDirectoryPath = getLockDirectoryPath;
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _checkAuthCookies = require("./auth/checkAuthCookies");
+var _readConfigFile = require("../readConfigFile");
+function createAuthDirectoryIfNotExist() {
+  const authDirectory = (0, _checkAuthCookies.getAuthFileDirectory)();
+  if (!(0, _fs.existsSync)(authDirectory)) {
+    console.log('Creating auth directory for the first time setup...');
+    (0, _fs.mkdirSync)(authDirectory, {
+      recursive: true
+    });
+  }
+}
+function getLockDirectoryPath() {
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  return _path.default.resolve(_path.default.join(uatDirectory, 'playwright', '.lock'));
+}

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

@@ -1,17 +1,38 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getEnvConfigFilePath = getEnvConfigFilePath;
 exports.getReportFileName = getReportFileName;
 exports.getUATFileName = getUATFileName;
-function getUATFileName() {
-  return 'uat.config.js';
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _auth = require("./auth");
+var _ConfigurationHelper = require("./../configuration/ConfigurationHelper");
+var _configPathResolver = require("./configPathResolver");
+var _configConstants = _interopRequireDefault(require("../constants/configConstants"));
+function getUATFileName(stage, mode) {
+  stage = stage || (0, _ConfigurationHelper.getRunStage)();
+  mode = mode || (0, _auth.getRunMode)();
+  const stagePath = (0, _configPathResolver.getConfigPath)(stage);
+  const uatConfFilePath = _path.default.resolve(process.cwd(), `${stagePath}/${mode}/${_configConstants.default.UAT_CONFIG_FILE}`);
+  if (_fs.default.existsSync(uatConfFilePath)) {
+    return uatConfFilePath;
+  }
+  ;
+  return _path.default.resolve(process.cwd(), `${stagePath}/${_configConstants.default.DEFAULT_CONFIG_DIR}/${_configConstants.default.UAT_CONFIG_FILE}`);
 }
-function getEnvConfigFilePath() {
-  return `uat/env-config.json`;
+function getEnvConfigFilePath(stage, mode) {
+  const stagePath = (0, _configPathResolver.getConfigPath)(stage);
+  const confFilePath = `${stagePath}/${mode}/${_configConstants.default.SETTINGS_FILE}`;
+  // TODO: Actors Mode as config
+  if (_fs.default.existsSync(confFilePath)) {
+    return confFilePath;
+  }
+  return `${stagePath}/${_configConstants.default.DEFAULT_CONFIG_DIR}/${_configConstants.default.SETTINGS_FILE}`;
 }
 function getReportFileName() {
-  return `test-summary.json`;
+  return `${_configConstants.default.TEST_SUMMARY_FILE}`;
 }

package/build/core/playwright/helpers/configPathResolver.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConfigPath = getConfigPath;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _propertiesReader = _interopRequireDefault(require("properties-reader"));
+var _logger = require("../../../utils/logger");
+var _configConstants = _interopRequireDefault(require("../constants/configConstants"));
+//This function reads a properties file and returns the entire properties
+
+function readPropertiesFile(relativeFilePath) {
+  const filePath = _path.default.resolve(process.cwd(), relativeFilePath);
+  let properties;
+  if (_fs.default.existsSync(filePath)) {
+    properties = (0, _propertiesReader.default)(filePath);
+  } else {
+    // we have to remove this logic after adding all the projects with proper config files
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Properties file ${filePath} not found. Using default configurations.`);
+    properties = (0, _propertiesReader.default)();
+    properties.set('uat', 'uat/conf');
+  }
+  return properties;
+}
+
+// This function return the value for the passed arguments key
+
+function getConfigPath(stage) {
+  const props = readPropertiesFile(_configConstants.default.STAGE_CONFIG_MAP_FILE);
+  const configPath = props.get(stage);
+  if (!configPath) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `No config mapping found for stage: "${stage}"`);
+  }
+  return configPath;
+}