@zohodesk/testinglibrary 0.0.1 → 0.0.2-n20-experimental

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;

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

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnvConfigFilePath = getEnvConfigFilePath;
+exports.getReportFileName = getReportFileName;
+exports.getUATFileName = getUATFileName;
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _auth = require("./auth");
+function getUATFileName(mode) {
+  mode = mode || (0, _auth.getRunMode)();
+  const uatConfFilePath = _path.default.resolve(process.cwd(), `uat/conf/${mode}/uat.config.js`);
+  if (_fs.default.existsSync(uatConfFilePath)) {
+    return uatConfFilePath;
+  }
+  return _path.default.resolve(process.cwd(), `uat/conf/default/uat.config.js`);
+}
+function getEnvConfigFilePath(mode) {
+  const confFilePath = _path.default.resolve(process.cwd(), `uat/conf/${mode}/settings.json`);
+  // TODO: Actors Mode as config
+  if (_fs.default.existsSync(confFilePath)) {
+    return `uat/conf/${mode}/settings.json`;
+  }
+  return `uat/conf/default/settings.json`;
+}
+function getReportFileName() {
+  return `test-summary.json`;
+}

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

@@ -0,0 +1,71 @@
+"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 _fs = require("fs");
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var _FileMutex_brand = /*#__PURE__*/new WeakSet();
+class FileMutex {
+  constructor(directory, lockFileName, fileDeletionTimeoutConfig) {
+    _classPrivateMethodInitSpec(this, _FileMutex_brand);
+    this.directory = directory;
+    this.lockFileName = lockFileName + ".lock";
+    this.fileDeletionTimeout = fileDeletionTimeoutConfig.timeout;
+    this.lockFilePath = _assertClassBrand(_FileMutex_brand, this, _getLockFilePath).call(this);
+    _assertClassBrand(_FileMutex_brand, this, _createDirectoryIfNotExist).call(this);
+  }
+  async acquire() {
+    return new Promise((resolve, reject) => {
+      if (!(0, _fs.existsSync)(this.lockFilePath)) {
+        (0, _fs.writeFileSync)(this.lockFilePath, 'locked');
+        console.log(`Lock file created: ${this.lockFilePath}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+        return resolve();
+      }
+      const timeout = setTimeout(() => {
+        watcher.close();
+        reject(new Error('Watch timeout exceeded'));
+      }, this.fileDeletionTimeout);
+      const watcher = (0, _fs.watch)(this.directory, (eventType, filename) => {
+        try {
+          if (eventType === 'rename' && filename === this.lockFileName) {
+            clearTimeout(timeout);
+            console.log(`Lock file deleted! Proceeding, worker index - ${process.env.TEST_WORKER_INDEX}`);
+            watcher.close();
+            resolve();
+          }
+        } catch (err) {
+          console.error(`Error watching for lock file deletion: ${err.message}`);
+          watcher.close();
+        }
+      });
+    });
+  }
+  async release() {
+    try {
+      if ((0, _fs.existsSync)(this.lockFilePath)) {
+        (0, _fs.unlinkSync)(this.lockFilePath);
+        console.log(`Lock file deleted: ${this.lockFilePath}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+      }
+    } catch (err) {
+      console.error(`Error deleting lock file: ${err.message}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+      throw err;
+    }
+  }
+}
+function _getLockFilePath() {
+  return _path.default.resolve(_path.default.join(this.directory, this.lockFileName));
+}
+async function _createDirectoryIfNotExist() {
+  if (!(0, _fs.existsSync)(this.directory)) {
+    (0, _fs.mkdirSync)(this.directory, {
+      recursive: true
+    });
+  }
+}
+var _default = exports.default = FileMutex;

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _logger = require("../../../utils/logger");
+var _readConfigFile = require("../readConfigFile");
+function getUserFixtures() {
+  const {
+    additionalPages
+  } = (0, _readConfigFile.generateConfigFromFile)();
+
+  // if (additionalPages.page || additionalPages.context) {
+  //   // Logger.log(
+  //   //   Logger.INFO_TYPE,
+  //   //   'Not allowed to override the page and context fixture. Use Test Setup in uat configuration'
+  //   // );
+  // }
+
+  return additionalPages;
+}
+var _default = exports.default = getUserFixtures;

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeObjects = mergeObjects;
+// Utility function to merge objects using spread operator
+function mergeObjects(obj1, obj2) {
+  return {
+    ...obj1,
+    ...obj2
+  };
+}

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

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseUserArgs = parseUserArgs;
+var _cliArgsToObject = require("../../../utils/cliArgsToObject");
+function parseUserArgs() {
+  return (0, _cliArgsToObject.cliArgsToObject)(process.argv.slice(2));
+}

package/build/core/playwright/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBdd = void 0;
+Object.defineProperty(exports, "expect", {
+  enumerable: true,
+  get: function () {
+    return _test.expect;
+  }
+});
+Object.defineProperty(exports, "test", {
+  enumerable: true,
+  get: function () {
+    return _playwrightBdd.test;
+  }
+});
+var _playwrightBdd = require("playwright-bdd");
+var _test = require("@playwright/test");
+let createBdd = function () {
+  return (0, _playwrightBdd.createBdd)(_playwrightBdd.test);
+};
+exports.createBdd = createBdd;

package/build/core/playwright/readConfigFile.js

@@ -0,0 +1,147 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateConfigFromFile = generateConfigFromFile;
+exports.getAuthFilePath = getAuthFilePath;
+exports.getDefaultConfig = getDefaultConfig;
+exports.isUserConfigFileAvailable = isUserConfigFileAvailable;
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../utils/logger");
+var _configFileNameProvider = require("./helpers/configFileNameProvider");
+var _mergeObjects = require("./helpers/mergeObjects");
+var _Configuration = _interopRequireDefault(require("./configuration/Configuration"));
+var _UserArgs = _interopRequireDefault(require("./configuration/UserArgs"));
+var _ConfigurationHelper = require("./configuration/ConfigurationHelper");
+let cachedConfig = null;
+function getDefaultConfig() {
+  return {
+    uatDirectory: _path.default.join(process.cwd(), 'uat'),
+    headless: false,
+    browsers: ['Chrome'],
+    forbidOnly: false,
+    retries: 0,
+    trace: false,
+    video: false,
+    isAuthMode: false,
+    openReportOn: 'never',
+    reportPath: _path.default.join(process.cwd(), 'uat', 'playwright-report'),
+    bddMode: false,
+    expectTimeout: 5 * 1000,
+    testTimeout: 60 * 1000,
+    authFilePath: 'uat/playwright/.auth/user.json',
+    viewport: {
+      width: 1280,
+      height: 720
+    },
+    debug: false,
+    testIdAttribute: 'data-testid',
+    additionalPages: {},
+    featureFilesFolder: 'feature-files',
+    stepDefinitionsFolder: 'steps',
+    testSetup: {},
+    editionOrder: ['Free', 'Express', 'Standard', 'Professional', 'Enterprise']
+  };
+}
+function combineDefaultConfigWithUserConfig(userConfiguration) {
+  let defaultConfig = getDefaultConfig();
+  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);
+}
+/**
+ * @typedef {Object|null} viewportConfig
+ * @property {number} width - width of the viewport
+ * @property {number} height - height of the viewport
+ */
+/**
+ * @typedef {Object|null} viewportConfig
+ * @property {number} width - width of the viewport
+ * @property {number} height - height of the viewport
+ */
+
+/**
+ * @typedef {Object|null} testSetupConfig
+ * @property {any} page - Function that will be called while setting up page fixtures
+ * @property {any} context - Function that will be called while setting up context fixtures
+ */
+
+/**
+ * Represents the user configuration object.
+ * @typedef {Object} UserConfig
+ * @property {string} uatDirectory - Directory in which uat configuration is places.
+ * @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 {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
+ * @property {Array} editionOrder: Order in the form of larger editions in the back. Edition with the most privelages should be last
+ * @property {testSetupConfig} testSetup: Specify page and context functions that will be called while intilaizing fixtures.
+ */
+
+/**
+ * Generates a configuration object from a file, if it exists.
+ *
+ * @returns {UserConfig}
+ */
+
+function getConfigFilePath() {
+  return _path.default.resolve(process.cwd(), (0, _configFileNameProvider.getUATFileName)());
+}
+function generateConfigFromFile() {
+  if (cachedConfig === null) {
+    // Getting the default config's from framework
+    const uatConfig = new _Configuration.default(getDefaultConfig());
+    // overriding the application config's from project
+    const appConfig = new _Configuration.default((0, _ConfigurationHelper.getApplicationConfig)());
+    const userArgConfig = new _Configuration.default(_UserArgs.default.parseToObject(process.argv.slice(2)));
+    // overriding the user config's from CLI
+    uatConfig.addAll(appConfig);
+    uatConfig.addAll(userArgConfig);
+    cachedConfig = uatConfig.getAll();
+  }
+  return cachedConfig;
+}
+function isUserConfigFileAvailable() {
+  const filePath = getConfigFilePath();
+  if ((0, _fs.existsSync)(filePath)) {
+    return true;
+  }
+  return false;
+}
+function getAuthFilePath(filePath) {
+  try {
+    if ((0, _fs.existsSync)(filePath)) {
+      return filePath;
+    } else {
+      return {};
+    }
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Founded Path - ${filePath} Authetication file not Exist ...`);
+    _logger.Logger.error(err);
+  }
+}

package/build/core/playwright/report-generator.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateReport;
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../utils/logger");
+var _rootPath = require("../../utils/rootPath");
+var _readConfigFile = require("./readConfigFile");
+async function generateReport() {
+  // await preProcessReport()
+  const userArgs = process.argv.slice(3);
+  const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
+  const command = playwrightPath;
+  const {
+    reportPath: htmlPath
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  const args = ['show-report', htmlPath].concat(userArgs);
+  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();
+  });
+}

package/build/core/playwright/runner/Runner.js

@@ -0,0 +1,22 @@
+"use strict";
+
+class Runner {
+  constructor(config) {
+    this.tagArgs = "";
+    this.userArgs = "";
+    this.config = config;
+  }
+  setUserArgs(userArgs) {
+    this.userArgs = userArgs;
+  }
+  setTagArgs(tagArgs) {
+    this.tagArgs = tagArgs;
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+  run() {
+    throw new Error("Method 'run()' must be implemented.");
+  }
+}
+module.exports = Runner;

package/build/core/playwright/runner/RunnerHelper.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _RunnerTypes = _interopRequireDefault(require("./RunnerTypes"));
+var _configUtils = require("../setup/config-utils");
+var _cliArgsToObject = require("../../../utils/cliArgsToObject");
+var _browserTypes = require("../constants/browserTypes");
+var _customCommands = require("../custom-commands");
+class RunnerHelper {
+  static createRunner(type, runnerObj) {
+    const runnerClass = _RunnerTypes.default.getRunnerClass(type, runnerObj);
+    if (!runnerClass) {
+      throw new Error("Invalid runner type");
+    }
+    return runnerClass;
+  }
+  static getPlaywrightArgs(userArgsObject, debug, bddMode, tagArgs, headless) {
+    const {
+      browsers = null
+    } = userArgsObject;
+    let browserList = (0, _configUtils.getBrowsersList)(browsers);
+    const playwrightArgs = (0, _cliArgsToObject.objectToCliArgs)(userArgsObject, key => !_customCommands.CUSTOM_COMMANDS.includes(key));
+    if (debug) {
+      playwrightArgs.push('--debug');
+    }
+    if (!bddMode && tagArgs) {
+      playwrightArgs.push('--grep');
+      playwrightArgs.push(tagArgs);
+    }
+    if (!headless && !userArgsObject.headed) {
+      playwrightArgs.push('--headed');
+    }
+    if (browserList && browserList.length > 0) {
+      browserList.map(browser => playwrightArgs.push(`--project=${_browserTypes.BROWSER_PROJECT_MAPPING[browser.toUpperCase()]}`));
+    }
+    return playwrightArgs;
+  }
+}
+var _default = exports.default = RunnerHelper;

package/build/core/playwright/runner/RunnerTypes.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _SpawnRunner = _interopRequireDefault(require("./SpawnRunner"));
+class RunnerTypes {
+  static getRunnerClass(type, runnerObj) {
+    const RunnerClass = this.runnerTypes[type];
+    if (!RunnerClass) {
+      throw new Error("Invalid runner type");
+    }
+    return new RunnerClass(runnerObj);
+  }
+  static runnerTypes = {
+    spawn: _SpawnRunner.default //require("./SpawnRunner"), // used lazy loading to reduce circular dependencies 
+  };
+}
+module.exports = RunnerTypes;