@zohodesk/testinglibrary 0.0.9 → 0.0.11-n20-experimental

package/build/core/playwright/index.js

@@ -3,110 +3,22 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.When = exports.Then = exports.Given = void 0;
-Object.defineProperty(exports, "createBdd", {
+exports.createBdd = void 0;
+Object.defineProperty(exports, "expect", {
   enumerable: true,
   get: function () {
-    return _bddFramework.createBdd;
+    return _test.expect;
   }
 });
-Object.defineProperty(exports, "expect", {
+Object.defineProperty(exports, "test", {
   enumerable: true,
   get: function () {
-    return _test.expect;
+    return _playwrightBdd.test;
   }
 });
-exports.test = void 0;
-var _bddFramework = require("../../bdd-framework");
+var _playwrightBdd = require("playwright-bdd");
 var _test = require("@playwright/test");
-var _readConfigFile = require("./readConfigFile");
-// function test(descrition, callback) {
-//   return test(descrition, ({ page }) => {
-//     const { locator, ...custompage } = page
-//     callback({ page: custompage })
-//   })
-// }
-
-// class FilteredPage {
-//   constructor(page) {
-//     this.page = page;
-//     this.allowedMethods = ['getByText', 'getByTitle'];
-//     this.context = page.context;
-//   }
-
-//   goto(...args) {
-//     return this.page['goto'](...args);
-//   }
-
-//   getByRole(...args) {
-//     return this.page['getByRole'](...args);
-//   }
-// }
-
-// function FilteredPage(page) {
-//   return {
-//     getByRole: () => {
-//       throw new Error('You cannnot use getByRole property')
-//     }
-//   }
-// }
-const {
-  additionalPages,
-  bddMode
-} = (0, _readConfigFile.generateConfigFromFile)();
-let base = bddMode ? _bddFramework.test : _test.test;
-const test = base.extend({
-  page: async ({
-    page
-  }, use) => {
-    // const proxyPage = new Proxy(page, {
-    //   get: function (obj, prop) {
-    //     console.log('Gettig Priop', prop);
-    //     let filterMethod = FilteredPage(page)[prop];
-    //     if (filterMethod) {
-    //       return filterMethod;
-    //     } else {
-    //       return obj[prop] ? obj[prop] : 'property does not exist';
-    //     }
-    //   }
-    // })
-    page.getBaseUrl = function () {
-      if (process.env.mode === 'dev') {
-        return `${process.env.domain}?devURL=${process.env.devUrl}`;
-      }
-      return `${process.env.domain}`;
-    };
-    page.getCustomPageUrl = function (url) {
-      if (process.env.mode === 'dev') {
-        return `${process.env.domain}/${url}?devURL=${process.env.devUrl}`;
-      }
-      return `${process.env.domain}/${url}`;
-    };
-    await use(page);
-
-    //await use(new FilteredPage(page));
-
-    // await use(async (page) => {
-    //   delete page.getByTestId;
-    //   await page;
-    // });
-  },
-
-  context: async ({
-    context
-  }, use) => {
-    // eslint-disable-next-line no-undef
-    await context.addInitScript(() => window.localStorage.setItem('isDnBannerHide', true));
-    await use(context);
-  },
-  ...additionalPages
-});
-exports.test = test;
-const {
-  Given,
-  When,
-  Then
-} = (0, _bddFramework.createBdd)();
-exports.Then = Then;
-exports.When = When;
-exports.Given = Given;
+let createBdd = function () {
+  return (0, _playwrightBdd.createBdd)(_playwrightBdd.test);
+};
+exports.createBdd = createBdd;

package/build/core/playwright/readConfigFile.js

@@ -4,18 +4,26 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.fileName = void 0;
 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");
-const fileName = 'uat.config.js';
-exports.fileName = fileName;
+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,
@@ -30,36 +38,58 @@ function getDefaultConfig() {
       height: 720
     },
     debug: false,
-    mode: 'dev',
-    additionalPages: {}
+    testIdAttribute: 'data-testid',
+    additionalPages: {},
+    featureFilesFolder: 'feature-files',
+    stepDefinitionsFolder: 'steps',
+    testSetup: {},
+    editionOrder: ['Free', 'Express', 'Standard', 'Professional', 'Enterprise']
   };
 }
 function combineDefaultConfigWithUserConfig(userConfiguration) {
   let defaultConfig = getDefaultConfig();
-  return {
-    ...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);
 }
-
 /**
  * @typedef {Object|null} viewportConfig
  * @property {number} width - width of the viewport
- * @property {number} height - height 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 {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) 
+ * @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
@@ -67,26 +97,37 @@ function combineDefaultConfigWithUserConfig(userConfiguration) {
  * @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
+ * @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() {
-  const filePath = _path.default.resolve(process.cwd(), fileName);
-  if ((0, _fs.existsSync)(filePath)) {
-    /** @type {UserConfig} */
-    const config = require(filePath);
-    const modifiedConfiguration = combineDefaultConfigWithUserConfig(config);
-    return modifiedConfiguration;
+  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 {};
+  return cachedConfig;
 }
 function isUserConfigFileAvailable() {
-  const filePath = _path.default.resolve(process.cwd(), fileName);
+  const filePath = getConfigFilePath();
   if ((0, _fs.existsSync)(filePath)) {
     return true;
   }
@@ -101,5 +142,6 @@ function getAuthFilePath(filePath) {
     }
   } 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

@@ -10,14 +10,15 @@ var _path = _interopRequireDefault(require("path"));
 var _logger = require("../../utils/logger");
 var _rootPath = require("../../utils/rootPath");
 var _readConfigFile = require("./readConfigFile");
-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);
-function generateReport() {
+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'
   });

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;

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

@@ -0,0 +1,115 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _readConfigFile = require("../readConfigFile");
+var _rootPath = require("../../../utils/rootPath");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../../utils/logger");
+var _child_process = require("child_process");
+var _RunnerHelper = _interopRequireDefault(require("./RunnerHelper"));
+var _Runner = _interopRequireDefault(require("./Runner"));
+var _commonUtils = require("../../../utils/commonUtils");
+class SpawnRunner extends _Runner.default {
+  constructor(runnerObj) {
+    super(runnerObj);
+    this.runnerObj = runnerObj;
+  }
+  run() {
+    const {
+      config
+    } = this.runnerObj;
+    let promises = [];
+    const {
+      bddMode
+    } = config.getAll();
+    if (bddMode) {
+      promises.push(this.runPreprocessing());
+    }
+    Promise.all(promises).then(() => this.runPlaywright()).catch(err => {
+      _logger.Logger.error(err);
+      process.exit();
+    });
+  }
+  runPreprocessing() {
+    console.log("Node version:", process.version);
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, "Node version- " + process.version);
+    //This below functoin is called to copy the data generator spec files to the current project
+    (0, _commonUtils.copyCommonSpecs)();
+    const {
+      tagArgs
+    } = this.runnerObj;
+    const configPath = (0, _readConfigFile.isUserConfigFileAvailable)() ? _path.default.resolve(__dirname, '../', 'setup', 'config-creator.js') : _path.default.resolve(__dirname, '../', '../', '../', '../', 'playwrightConfig.js');
+    const beforeCommand = 'node';
+    const bddGenPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('bddgen'));
+    const beforeArgs = [bddGenPath, '-c', require.resolve(configPath)];
+    if (tagArgs) {
+      beforeArgs.push('--tags');
+      beforeArgs.push(tagArgs);
+    }
+    return new Promise((resolve, reject) => {
+      const childProcessForPreprocessing = (0, _child_process.spawn)(beforeCommand, beforeArgs, {
+        stdio: 'inherit',
+        env: {
+          ...process.env
+        }
+      });
+      childProcessForPreprocessing.on('error', data => {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, data);
+        reject(data);
+      });
+      childProcessForPreprocessing.on('exit', code => {
+        if (code === 0) {
+          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Feature Files Processed Successfully');
+          resolve();
+        } else {
+          reject(`BddGen exited with code ${code}`);
+        }
+      });
+    });
+  }
+  runPlaywright() {
+    const {
+      tagArgs,
+      config,
+      userArgs
+    } = this.runnerObj;
+    const {
+      debug,
+      bddMode = false,
+      headless = false
+    } = config.getAll();
+    const playwrightArgs = _RunnerHelper.default.getPlaywrightArgs(userArgs, debug, bddMode, tagArgs, headless);
+    const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
+    const command = playwrightPath;
+    const configPath = (0, _readConfigFile.isUserConfigFileAvailable)() ? _path.default.resolve(__dirname, '../', 'setup', 'config-creator.js') : _path.default.resolve('../', '../', '../', '../', 'playwrightConfig.js');
+    const args = ['test', '--config', require.resolve(configPath)].concat(playwrightArgs);
+    return new Promise((resolve, reject) => {
+      const childProcessForRunningPlaywright = (0, _child_process.spawn)(command, args, {
+        stdio: 'inherit',
+        env: {
+          ...process.env
+        }
+      });
+      childProcessForRunningPlaywright.on('error', error => {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error);
+      });
+      childProcessForRunningPlaywright.on('exit', (code, signal) => {
+        if (code !== 0) {
+          reject(`Child Process Exited with Code ${code} and Signal ${signal}`);
+        } else {
+          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Test Ran Successfully');
+          resolve();
+        }
+      });
+      process.on('exit', () => {
+        childProcessForRunningPlaywright.kill();
+        reject('Terminating Playwright Process...');
+      });
+      process.on('SIGINT', () => {
+        childProcessForRunningPlaywright.kill();
+        reject('Cleaning up...');
+      });
+    });
+  }
+}
+module.exports = SpawnRunner;

package/build/core/playwright/setup/config-creator.js

@@ -9,8 +9,10 @@ var _test = require("@playwright/test");
 var _path = _interopRequireDefault(require("path"));
 var _readConfigFile = require("../readConfigFile");
 var _configUtils = require("./config-utils");
+const uatConfig = (0, _readConfigFile.generateConfigFromFile)();
 const {
   browsers,
+  isSmokeTest,
   trace,
   video,
   isAuthMode,
@@ -20,49 +22,96 @@ const {
   expectTimeout,
   testTimeout,
   authFilePath,
-  viewport
-} = (0, _readConfigFile.generateConfigFromFile)();
+  viewport,
+  featureFilesFolder,
+  stepDefinitionsFolder,
+  testIdAttribute,
+  globalTimeout,
+  customReporter
+} = uatConfig;
 const projects = (0, _configUtils.getProjects)({
   browsers,
   isAuthMode,
+  isSmokeTest,
   authFilePath,
   expectTimeout,
   testTimeout,
   viewport
 });
-const testDir = (0, _configUtils.getTestDir)(bddMode, process.cwd());
+const testDir = (0, _configUtils.getTestDir)(bddMode, {
+  featureFilesFolder: (0, _configUtils.getPathsForFeatureFiles)(process.cwd()),
+  stepDefinitionsFolder: _path.default.join(process.cwd(), 'uat', '**', 'steps', '*.spec.js'),
+  outputDir: _path.default.join(process.cwd(), 'uat', '.features-gen'),
+  uatPath: _path.default.join(process.cwd(), 'uat')
+});
+const use = {
+  trace,
+  video,
+  viewport,
+  testIdAttribute
+};
+let reporter = [['html', {
+  outputFolder: reportPath,
+  open: openReportOn
+}], ['list'], ['json', {
+  outputFile: _path.default.join(process.cwd(), 'uat', 'test-results', 'playwright-test-results.json')
+}], ['./custom-reporter.js'], ['./qc-custom-reporter.js']];
+if (customReporter) {
+  reporter = [customReporter, ...reporter];
+}
+
+/**
+ * Playwright configuration object
+ *
+ * @returns {import('@playwright/test').PlaywrightTestConfig}
+ */
+
 function getPlaywrightConfig() {
-  return {
+  const commonConfig = {
+    storageState: isAuthMode ? (0, _readConfigFile.getAuthFilePath)(_path.default.resolve(process.cwd(), authFilePath)) : {}
+  };
+  const dependencies = isAuthMode ? ['setup'] : [];
+  const smokeTestProject = isSmokeTest ? smokeTestConfig() : [];
+  function smokeTestConfig() {
+    const smokeTestDir = (0, _configUtils.getTestDir)(bddMode, {
+      featureFilesFolder: _path.default.join(process.cwd(), 'uat', 'smokeTest', '**', '*.feature'),
+      stepDefinitionsFolder: _path.default.join(process.cwd(), 'uat', '**', 'steps', '*.spec.js'),
+      outputDir: _path.default.join(process.cwd(), 'uat', '.features-smoke-gen'),
+      uatPath: _path.default.join(process.cwd(), 'uat', 'smokeTest')
+    });
+    return [{
+      name: 'smokeTest',
+      testDir: smokeTestDir,
+      use: {
+        ...commonConfig
+      },
+      dependencies: dependencies,
+      retries: 0
+    }];
+  }
+  const playwrightConfig = {
     testDir,
+    globalTimeout: globalTimeout || 3600000,
     outputDir: _path.default.join(process.cwd(), 'uat', 'test-results'),
     fullyParallel: true,
-    forbidOnly: !!process.env.CI,
-    retries: process.env.CI ? 2 : 0,
-    workers: process.env.CI ? 1 : 1,
-    reporter: [['html', {
-      outputFolder: reportPath,
-      open: openReportOn
-    }]],
+    reporter,
     timeout: testTimeout,
     expect: {
       timeout: expectTimeout
     },
-    use: {
-      viewport,
-      trace: trace ? 'on' : 'off',
-      video: video ? {
-        mode: 'on',
-        size: {
-          ...viewport
-        }
-      } : 'off'
-    },
+    use,
     projects: isAuthMode ? [{
       name: 'setup',
       testMatch: /.*\.setup\.js/,
+      testDir: _path.default.join(process.cwd(), 'uat'),
+      teardown: 'cleanup'
+    }, ...smokeTestProject, {
+      name: 'cleanup',
+      testMatch: /.*\.teardown\.js/,
       testDir: _path.default.join(process.cwd(), 'uat')
-    }, ...projects] : [...projects]
+    }, ...projects] : [...projects, ...smokeTestProject],
+    ...uatConfig
   };
+  return playwrightConfig;
 }
-var _default = (0, _test.defineConfig)(getPlaywrightConfig());
-exports.default = _default;
+var _default = exports.default = (0, _test.defineConfig)(getPlaywrightConfig());