@zohodesk/testinglibrary 0.0.2 → 0.0.3-n20-experimental

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = exports.default = {
+  unauthenticatedPage: async ({
+    browser
+  }, use) => {
+    const context = await browser.newContext({
+      storageState: null
+    });
+    const unauthenticatedPage = await context.newPage();
+    await use(unauthenticatedPage);
+    await context.close();
+  }
+};

package/build/core/playwright/clear-caches.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _fileUtils = require("../../utils/fileUtils");
+var _logger = require("../../utils/logger");
+var _readConfigFile = require("./readConfigFile");
+var _checkAuthDirectory = require("./helpers/checkAuthDirectory");
+function deleteAuthFiles(authFilePath) {
+  authFilePath = _path.default.resolve(process.cwd(), authFilePath);
+  const authFileFolder = _path.default.dirname(authFilePath);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting auth files present in ${authFileFolder}`);
+  (0, _fileUtils.deleteFolder)(authFileFolder);
+}
+function deletePlaywrightReport(reportPath) {
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting Playwright report ${reportPath}`);
+  (0, _fileUtils.deleteFolder)(reportPath);
+}
+function deleteGeneratedFeatures() {
+  const featuresGenPath = _path.default.resolve(process.cwd(), 'uat', '.features-gen');
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting generated features at ${featuresGenPath}`);
+  (0, _fileUtils.deleteFolder)(featuresGenPath);
+}
+function deleteLockFiles() {
+  const lockFilePath = (0, _checkAuthDirectory.getLockDirectoryPath)();
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting lock files at ${lockFilePath}`);
+  (0, _fileUtils.deleteFolder)(lockFilePath);
+}
+function clearCaches() {
+  try {
+    const {
+      authFilePath,
+      reportPath
+    } = (0, _readConfigFile.generateConfigFromFile)();
+    deleteAuthFiles(authFilePath);
+    deletePlaywrightReport(reportPath);
+    deleteGeneratedFeatures();
+    deleteLockFiles();
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Caches Cleared. Now you can try running npm run uat');
+  } catch (err) {
+    _logger.Logger.error(err);
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Error While clearing cookies. Try manually delete folder uat/playwright and uat/playwright-report');
+  }
+}
+var _default = exports.default = clearCaches;

package/build/core/playwright/codegen.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateCodegen;
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../utils/logger");
+var _rootPath = require("../../utils/rootPath");
+function generateCodegen() {
+  const domainUrl = process.argv.slice(3);
+  const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
+  const command = playwrightPath;
+  const args = ['codegen'].concat(domainUrl);
+  const childProcess = (0, _child_process.spawn)(command, args, {
+    stdio: 'inherit'
+  });
+  childProcess.on('error', error => {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error);
+  });
+  childProcess.on('exit', (code, signal) => {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Child Process Exited with Code ${code} and Signal ${signal}`);
+    process.exit();
+  });
+  process.on('exit', () => {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Terminating Playwright Process...');
+    //childProcess.kill();
+    return;
+  });
+  process.on('SIGINT', () => {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Cleaning up...');
+    //childProcess.kill();
+    process.exit();
+  });
+}
+
+// Another way to record. Below way will load the url in autheticated state if present
+// function generateCodegen() {
+//   (async () => {
+//     // Make sure to run headed.
+//     const browser = await chromium.launch({ headless: false });
+
+//     // Setup context however you like.
+//     const context = await browser.newContext({ storageState: path.resolve(process.cwd(), 'uat', 'playwright/.auth/user.json') });
+//     await context.route('**/*', route => route.continue());
+
+//     // Pause the page, and start recording manually.
+//     const page = await context.newPage();
+//     console.log(userArgs.join(''));
+//     await page.goto(`https://${userArgs.join('')}`);
+//     await page.pause();
+//   })();
+// }

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

@@ -0,0 +1,25 @@
+"use strict";
+
+var _ConfigurationHelper = require("./ConfigurationHelper");
+class Configuration {
+  properties = {};
+  constructor(props) {
+    this.properties = props;
+  }
+  add(key, value) {
+    this.properties[key] = value;
+  }
+  addAll(newConfig) {
+    this.properties = (0, _ConfigurationHelper.combineConfiguration)(this.properties, newConfig.getAll());
+  }
+  get(key) {
+    return this.properties[key];
+  }
+  getAll() {
+    return this.properties;
+  }
+  delete(key) {
+    delete this.properties[key];
+  }
+}
+module.exports = Configuration;

package/build/core/playwright/configuration/ConfigurationHelper.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.combineConfiguration = combineConfiguration;
+exports.getApplicationConfig = getApplicationConfig;
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../../utils/logger");
+var _configFileNameProvider = require("../helpers/configFileNameProvider");
+var _mergeObjects = require("../helpers/mergeObjects");
+var _fs = require("fs");
+const Configuration = require("./Configuration");
+function combineConfiguration(defaultConfig, userConfiguration) {
+  let configurationObj = {};
+  Object.keys(userConfiguration).forEach(configKey => {
+    let configValue = userConfiguration[configKey];
+    if (configValue !== null && configValue !== undefined) {
+      configurationObj[configKey] = configValue;
+    } else if (defaultConfig[configKey]) {
+      configurationObj[configKey] = defaultConfig[configKey];
+    } else {
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `key - ${configKey} is not yet supported in uat configuration. This will not be used while creating playwright configuration`);
+    }
+  });
+  return (0, _mergeObjects.mergeObjects)(defaultConfig, configurationObj);
+}
+function getApplicationConfig(mode) {
+  let filePath = "";
+  try {
+    filePath = _path.default.resolve(process.cwd(), (0, _configFileNameProvider.getUATFileName)(mode));
+    if (!(0, _fs.existsSync)(filePath)) {
+      throw new Error("Exception while getting the uat file from the application - " + filePath);
+    }
+    const config = require(filePath);
+    return config;
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Founded Path - ${filePath} Application config file not Exist ...`);
+    _logger.Logger.error(err);
+    return {};
+  }
+}

package/build/core/playwright/configuration/UserArgs.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _cliArgsToObject = require("../../../utils/cliArgsToObject");
+class UserArgs {
+  static parseToObject(config) {
+    return (0, _cliArgsToObject.cliArgsToObject)(config);
+  }
+  static parseToArgs(object) {
+    return (0, _cliArgsToObject.objectToCliArgs)(object);
+  }
+}
+module.exports = UserArgs;

package/build/core/playwright/constants/browserTypes.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BROWSER_PROJECT_MAPPING = void 0;
+const BROWSER_PROJECT_MAPPING = exports.BROWSER_PROJECT_MAPPING = {
+  CHROME: 'chromium',
+  EDGE: 'Microsoft Edge',
+  FIREFOX: 'firefox',
+  SAFARI: 'webkit'
+};

package/build/core/playwright/constants/fileMutexConfig.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fileDeletionTimeoutConfig = void 0;
+const fileDeletionTimeoutConfig = exports.fileDeletionTimeoutConfig = {
+  timeout: 45000
+};

package/build/core/playwright/custom-commands.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CUSTOM_COMMANDS = void 0;
+const CUSTOM_COMMANDS = exports.CUSTOM_COMMANDS = ['mode', 'tags', 'edition', 'browsers', 'filePath', 'headless', 'modules'];

package/build/core/playwright/env-initializer.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initializeEnvConfig = initializeEnvConfig;
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _configFileNameProvider = require("./helpers/configFileNameProvider");
+var _logger = require("../../utils/logger");
+var _getUsers = require("./helpers/auth/getUsers");
+function setEnvironmentVariables(configJSON) {
+  for (const key in configJSON) {
+    process.env[key] = configJSON[key];
+  }
+}
+function addHelperLogsForEnvInitialization() {
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Mode under which test cases should run has not been specified in args.`);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Please specify --mode='dev/prod' while running ZDTestingFramework test`);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Going to use default mode as dev`);
+}
+function initializeEnvConfig(mode, isAuthMode) {
+  try {
+    if (!mode) {
+      addHelperLogsForEnvInitialization();
+      mode = 'dev';
+    }
+    const configFile = (0, _fs.readFileSync)(_path.default.resolve(process.cwd(), `./${(0, _configFileNameProvider.getEnvConfigFilePath)(mode)}`));
+    const configJSON = JSON.parse(configFile);
+    setEnvironmentVariables({
+      ...configJSON,
+      mode
+    });
+    if (isAuthMode) {
+      const defaultActorConfiguration = (0, _getUsers.getDefaultActorConf)();
+      setEnvironmentVariables(defaultActorConfiguration);
+    }
+  } catch (err) {
+    _logger.Logger.error(err);
+    throw new Error(`Config File Not Exists. Please provide a config file ${(0, _configFileNameProvider.getEnvConfigFilePath)(mode)} to intiailize the environment variables `);
+  }
+}

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,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.additionProfiles = additionProfiles;
+var _getUsers = require("./auth/getUsers");
+function additionProfiles(tags, editionInfo, betaFeature, portalInfo) {
+  const additionalProfileTags = tags.filter(tag => tag.startsWith('@additional_profile_'));
+  let additionalProfileActors = [];
+  if (additionalProfileTags.length > 0 && editionInfo) {
+    additionalProfileActors = additionalProfileTags.map(tag => {
+      const additionalProfile = tag.replace('@additional_profile_', '');
+      return (0, _getUsers.getUserForSelectedEditionAndProfile)(editionInfo, additionalProfile, betaFeature, portalInfo);
+    });
+  }
+  return additionalProfileActors;
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _getUrlOrigin = _interopRequireDefault(require("./getUrlOrigin"));
+async function accountLogin(page, useremail, password) {
+  await page.locator('#login_id').fill(useremail);
+  await page.locator('#nextbtn').click();
+  await page.locator('#password').fill(password);
+  await page.locator('#nextbtn').click();
+  const domainUrlOrigin = (0, _getUrlOrigin.default)(process.env.domain);
+  await page.waitForNavigation();
+  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

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAuthFileDirectory = getAuthFileDirectory;
+exports.loadCookiesIfPresent = loadCookiesIfPresent;
+exports.verifyIfCookieFileExists = verifyIfCookieFileExists;
+var _path = _interopRequireDefault(require("path"));
+var _fs = require("fs");
+var _readConfigFile = require("../../readConfigFile");
+var _logger = require("../../../../utils/logger");
+/* eslint-disable no-console */
+
+function getAuthFileDirectory() {
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  return _path.default.resolve(_path.default.join(uatDirectory, 'playwright', '.auth'));
+}
+function verifyIfCookieFileExists(authFile) {
+  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`);
+  }
+}
+async function loadCookiesIfPresent(page, authFile) {
+  if (verifyIfCookieFileExists(authFile)) {
+    const fileContent = (0, _fs.readFileSync)(authFile);
+    const stroageState = convertCookiesToParse(fileContent, authFile);
+    if (stroageState.cookies) {
+      await page.context().addCookies(stroageState.cookies);
+    }
+  }
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function getUrlOrigin(url) {
+  const {
+    origin
+  } = new URL(url);
+  return origin;
+}
+var _default = exports.default = getUrlOrigin;

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

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 _fs = require("fs");
+var _readConfigFile = require("../../readConfigFile");
+/* eslint-disable global-require */
+function getRunMode() {
+  let {
+    mode
+  } = process.env;
+  return mode || 'dev';
+}
+function isCI() {
+  const mode = getRunMode();
+  return mode === 'CI' || mode === 'ci';
+}
+function isDevelopmentSetup() {
+  const mode = getRunMode();
+  return mode === 'DEV' || mode === 'dev';
+}
+function getDefaultActorConf() {
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  const modeSettingsFile = `conf/${getRunMode()}/settings.json`;
+  const filePath = _path.default.join(uatDirectory, modeSettingsFile);
+  try {
+    if (!(0, _fs.existsSync)(filePath)) {
+      const defaultSettingsFile = _path.default.join(uatDirectory, `conf/default/settings.json`);
+      return require(defaultSettingsFile);
+    }
+    return require(filePath);
+  } catch (error) {
+    throw new Error(`${defaultSettingFile} ${filePath} both files are missing.`);
+  }
+}
+function getDefaultActor() {
+  const {
+    edition,
+    profile
+  } = getDefaultActorConf();
+  return getUserForSelectedEditionAndProfile(edition, profile);
+}
+function getListOfActors(betaFeature) {
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  const mode = getRunMode();
+  let configFile = _path.default.join(uatDirectory, `conf/${mode}/actors/index.js`);
+  let betaReference = mode;
+  if (!(0, _fs.existsSync)(configFile)) {
+    configFile = _path.default.join(uatDirectory, `conf/default/actors/index.js`);
+    betaReference = "default";
+  }
+  if (betaFeature) {
+    configFile = _path.default.join(uatDirectory, `conf/${betaReference}/actors/beta/${betaFeature}/index.js`);
+    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}`);
+  }
+}
+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
+  } = actorsData;
+  const defaultConf = getDefaultActorConf();
+  const edition = preferedEdition || defaultConf.edition;
+  const profile = preferredProfile || defaultConf.profile;
+  let selectedProfile = {};
+
+  // 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}" edition configured.`);
+  }
+  if (testDataPortal !== null) {
+    testingPortal = userdata[edition].find(editionData => editionData.orgName === testDataPortal);
+    if (!testingPortal) {
+      throw new Error(`There is no "${testDataPortal}" portal configured in "${edition}" edition.`);
+    }
+  } else {
+    testingPortal = userdata[edition] ? userdata[edition][0] : {};
+  }
+  const {
+    profiles,
+    ...editionData
+  } = testingPortal;
+  selectedProfile = profiles.find(user => user.profile === profile);
+  if (!selectedProfile) {
+    throw new Error(`There is no "${profile}" profile configured in "${edition}" edition.`);
+  }
+  return {
+    ...editionData,
+    ...selectedProfile
+  };
+}

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

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "accountLogin", {
+  enumerable: true,
+  get: function () {
+    return _accountLogin.default;
+  }
+});
+Object.defineProperty(exports, "getDefaultActor", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.getDefaultActor;
+  }
+});
+Object.defineProperty(exports, "getDefaultActorConf", {
+  enumerable: true,
+  get: function () {
+    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, "getUserForSelectedEditionAndProfile", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.getUserForSelectedEditionAndProfile;
+  }
+});
+Object.defineProperty(exports, "isCI", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.isCI;
+  }
+});
+Object.defineProperty(exports, "isDevelopmentSetup", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.isDevelopmentSetup;
+  }
+});
+Object.defineProperty(exports, "loadCookiesIfPresent", {
+  enumerable: true,
+  get: function () {
+    return _checkAuthCookies.loadCookiesIfPresent;
+  }
+});
+Object.defineProperty(exports, "performLoginSteps", {
+  enumerable: true,
+  get: function () {
+    return _loginSteps.default;
+  }
+});
+Object.defineProperty(exports, "verifyIfCookieFileExists", {
+  enumerable: true,
+  get: function () {
+    return _checkAuthCookies.verifyIfCookieFileExists;
+  }
+});
+var _accountLogin = _interopRequireDefault(require("./accountLogin"));
+var _checkAuthCookies = require("./checkAuthCookies");
+var _getUsers = require("./getUsers");
+var _loginSteps = _interopRequireDefault(require("./loginSteps"));

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

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+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(testInfo, isLoggedIn, loginSteps) {
+  let {
+    page,
+    authFilePrefix,
+    email
+  } = testInfo;
+  authFilePrefix = authFilePrefix || email;
+  const authFile = _path.default.resolve(_path.default.join((0, _checkAuthCookies.getAuthFileDirectory)(), `${authFilePrefix}-cookies.json`));
+  const lockFileName = email.replace(/[@.]/g, '_');
+  const fileMutex = new _fileMutex.default((0, _checkAuthDirectory.getLockDirectoryPath)(), lockFileName, _fileMutexConfig.fileDeletionTimeoutConfig);
+  let loginUsingCookie = false;
+  try {
+    if ((0, _checkAuthCookies.verifyIfCookieFileExists)(authFile)) {
+      console.log(`${email} 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 page.context().storageState({
+        path: authFile
+      });
+    }
+  } catch (error) {
+    console.error(`Error during login for ${email}:`, error);
+  } finally {
+    if (!loginUsingCookie) {
+      await fileMutex.release();
+    }
+  }
+}
+var _default = exports.default = performLoginSteps;