@zohodesk/testinglibrary 0.0.1 → 0.0.2-n20-experimental

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

@@ -0,0 +1,110 @@
+"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"));
+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() {
+    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

@@ -0,0 +1,113 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+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,
+  openReportOn,
+  reportPath,
+  bddMode,
+  expectTimeout,
+  testTimeout,
+  authFilePath,
+  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, {
+  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 smokeTestDir = (0, _configUtils.getTestDir)(bddMode, {
+  featureFilesFolder: _path.default.join(process.cwd(), 'uat', 'smokeTest', '**', '*.feature'),
+  stepDefinitionsFolder: _path.default.join(process.cwd(), 'uat', 'smokeTest', '**', '*smokeTest.spec.js'),
+  outputDir: _path.default.join(process.cwd(), 'uat', '.features-smoke-gen'),
+  uatPath: _path.default.join(process.cwd(), 'uat', 'smokeTest')
+});
+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() {
+  const commonConfig = {
+    storageState: isAuthMode ? (0, _readConfigFile.getAuthFilePath)(_path.default.resolve(process.cwd(), authFilePath)) : {}
+  };
+  const dependencies = isAuthMode ? ['setup'] : [];
+  const smokeTestProject = {
+    name: 'smokeTest',
+    testDir: smokeTestDir,
+    use: {
+      ...commonConfig
+    },
+    dependencies: dependencies
+  };
+  const playwrightConfig = {
+    testDir,
+    globalTimeout: globalTimeout || 3600000,
+    outputDir: _path.default.join(process.cwd(), 'uat', 'test-results'),
+    fullyParallel: true,
+    reporter,
+    timeout: testTimeout,
+    expect: {
+      timeout: expectTimeout
+    },
+    use,
+    projects: isAuthMode ? [{
+      name: 'setup',
+      testMatch: /.*\.setup\.js/,
+      testDir: _path.default.join(process.cwd(), 'uat'),
+      teardown: 'cleanup'
+    }, ...(isSmokeTest ? [smokeTestProject] : []), {
+      name: 'cleanup',
+      testMatch: /.*\.teardown\.js/,
+      testDir: _path.default.join(process.cwd(), 'uat')
+    }, ...projects] : [...projects, ...(isSmokeTest ? [smokeTestProject] : [])],
+    ...uatConfig
+  };
+  return playwrightConfig;
+}
+var _default = exports.default = (0, _test.defineConfig)(getPlaywrightConfig());

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

@@ -0,0 +1,189 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBrowsersList = getBrowsersList;
+exports.getModulePathForFeatureFiles = getModulePathForFeatureFiles;
+exports.getPathsForFeatureFiles = getPathsForFeatureFiles;
+exports.getProjects = getProjects;
+exports.getTestDir = getTestDir;
+var _test = require("@playwright/test");
+var _path = _interopRequireDefault(require("path"));
+var _readConfigFile = require("../readConfigFile");
+var _playwrightBdd = require("playwright-bdd");
+var _logger = require("../../../utils/logger");
+var _browserTypes = require("../constants/browserTypes");
+var _fileUtils = require("../../../utils/fileUtils");
+/**
+ ** Playwright project configuration
+ * @returns {import('@playwright/test').Project}
+ */
+
+function getBrowserConfig({
+  browserName,
+  isAuthMode,
+  isSmokeTest,
+  authFilePath,
+  expectTimeout,
+  testTimeout,
+  viewport
+}) {
+  const browser = browserName.toLowerCase();
+  const commonConfig = {
+    viewport,
+    storageState: isAuthMode ? (0, _readConfigFile.getAuthFilePath)(_path.default.resolve(process.cwd(), authFilePath)) : {}
+  };
+  // Determine dependencies based on the mode and smoke test status
+  let dependencies = isAuthMode ? ['setup'] : [];
+  dependencies = isSmokeTest ? [...dependencies, 'smokeTest'] : dependencies;
+  if (browser === 'chrome') {
+    return {
+      name: _browserTypes.BROWSER_PROJECT_MAPPING.CHROME,
+      use: {
+        ..._test.devices['Desktop Chrome'],
+        ...commonConfig
+      },
+      dependencies,
+      timeout: testTimeout,
+      expect: {
+        timeout: expectTimeout
+      }
+    };
+  } else if (browser === 'edge') {
+    return {
+      name: _browserTypes.BROWSER_PROJECT_MAPPING.EDGE,
+      timeout: testTimeout,
+      expect: {
+        timeout: expectTimeout
+      },
+      use: {
+        ..._test.devices['Desktop Chrome'],
+        channel: 'msedge',
+        ...commonConfig
+      },
+      dependencies
+    };
+  } else if (browser === 'firefox') {
+    return {
+      name: _browserTypes.BROWSER_PROJECT_MAPPING.FIREFOX,
+      timeout: 2 * testTimeout,
+      expect: {
+        timeout: 2 * expectTimeout
+      },
+      use: {
+        ..._test.devices['Desktop Firefox'],
+        ...commonConfig
+      },
+      dependencies
+    };
+  } else if (browser === 'safari') {
+    return {
+      name: _browserTypes.BROWSER_PROJECT_MAPPING.SAFARI,
+      timeout: 4 * testTimeout,
+      expect: {
+        timeout: 4 * expectTimeout
+      },
+      use: {
+        ..._test.devices['Desktop Safari'],
+        ...commonConfig
+      },
+      dependencies
+    };
+  } else {
+    return false;
+  }
+}
+
+/**
+ *
+ * @param {*} param0
+ * @returns {import('@playwright/test').Project[]}
+ */
+function getProjects({
+  browsers,
+  isAuthMode,
+  isSmokeTest,
+  authFilePath,
+  expectTimeout,
+  testTimeout,
+  viewport
+}) {
+  return browsers.map(browserName => getBrowserConfig({
+    browserName,
+    isAuthMode,
+    isSmokeTest,
+    authFilePath,
+    expectTimeout,
+    testTimeout,
+    viewport
+  })).filter(Boolean);
+}
+function getBrowsersList(browserFromArgs) {
+  if (browserFromArgs) {
+    if (typeof browserFromArgs === 'string') {
+      let listOfbrowsers = browserFromArgs.split(',').map(browser => browser.trim().toLowerCase());
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Using browsers from command line args');
+      return listOfbrowsers;
+    }
+  }
+  return [];
+}
+function getPathsForFeatureFiles(cwd) {
+  if (process.env.isRerunFailedCases) {
+    let {
+      reportPath
+    } = (0, _readConfigFile.generateConfigFromFile)();
+    let filePathFromArgs = process.env.filePath;
+    let filePath = filePathFromArgs ? filePathFromArgs : reportPath;
+    const testSummary = (0, _fileUtils.readFileContents)(filePath);
+    if (testSummary !== null) {
+      const {
+        failed = []
+      } = JSON.parse(testSummary);
+      const casesToRun = failed.map(filePath => _path.default.join(cwd, 'uat', filePath.replace(/\.spec\.js$|\.js$/, '')));
+      return casesToRun;
+    } else {
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Unable to read test summary from the ${reportPath}. Verify If File Exists in the path`);
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Going to run all test cases');
+    }
+  } else if (process.env.modules !== 'undefined' && process.env.modules.length > 0) {
+    let modules = process.env.modules;
+    let moduleList = modules.split(',');
+    return getModulePathForFeatureFiles(moduleList);
+  }
+  return [_path.default.join(cwd, 'uat', '**', '*.feature')];
+}
+function getModulePathForFeatureFiles(moduleList) {
+  let validModuleList = [];
+  moduleList.forEach(moduleName => {
+    let modulePath = _path.default.join(process.cwd(), 'uat', 'modules', '**', `${moduleName}`);
+    if ((0, _fileUtils.checkIfFolderExistsWithPattern)(modulePath)) {
+      validModuleList.push(_path.default.join(modulePath, '**', '*.feature'));
+    } else {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Module ${moduleName} does not exist, Please check the module name`);
+      validModuleList = [];
+      return validModuleList;
+    }
+  });
+  return validModuleList;
+}
+function getTestDir(bddMode, {
+  featureFilesFolder,
+  stepDefinitionsFolder,
+  outputDir,
+  uatPath
+}) {
+  return bddMode ? (0, _playwrightBdd.defineBddConfig)({
+    features: featureFilesFolder,
+    steps: [stepDefinitionsFolder, require.resolve('../fixtures.js')],
+    importTestFrom: require.resolve('../fixtures.js'),
+    featuresRoot: uatPath,
+    outputDir: outputDir,
+    disableWarnings: {
+      importTestFrom: true
+    },
+    publish: true
+  }) : uatPath;
+}

package/build/core/playwright/setup/custom-reporter.js

@@ -0,0 +1,136 @@
+"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 _readline = _interopRequireDefault(require("readline"));
+var _fileUtils = require("../../../utils/fileUtils");
+var _readConfigFile = require("../readConfigFile");
+var _logger = require("../../../utils/logger");
+var _configFileNameProvider = require("../helpers/configFileNameProvider");
+class JSONSummaryReporter {
+  constructor() {
+    this.durationInMS = -1;
+    this.passed = [];
+    this.skipped = [];
+    this.failed = [];
+    this.warned = [];
+    this.errored = [];
+    this.interrupted = [];
+    this.timedOut = [];
+    this.flakey = [];
+    this.failedSteps = [];
+    this.status = 'unknown';
+    this.startedAt = 0;
+    this._open = (0, _readConfigFile.generateConfigFromFile)().openReportOn;
+  }
+  onBegin() {
+    this.startedAt = Date.now();
+  }
+  getTitle(test) {
+    const title = [];
+    const fileName = [];
+    let clean = true;
+    for (const s of test.titlePath()) {
+      if (s === '' && clean) {
+        continue;
+      }
+      clean = false;
+      title.push(s);
+      if (s.endsWith('.ts') || s.endsWith('.js')) {
+        fileName.push(s);
+      }
+    }
+
+    //Using the fullTitle variable in the push will push a full test name + test description
+
+    return {
+      fullTitle: title.join(' > '),
+      fileName: fileName[0] || ''
+    };
+  }
+  onTestEnd(test, result) {
+    const {
+      fullTitle,
+      fileName
+    } = this.getTitle(test);
+
+    // Set the status
+    const stepTitleList = result.steps.filter(step => step.error).map(step => ({
+      title: step.title,
+      error: step.error,
+      testTitle: fullTitle
+    }));
+    if (stepTitleList.length > 0) {
+      this.failedSteps = [...this.failedSteps, ...stepTitleList];
+    }
+    const status = !['passed', 'skipped'].includes(result.status) && fullTitle.includes('@warn') ? 'warned' : result.status;
+    // Logic to push the results into the correct array
+    if (result.status === 'passed' && result.retry >= 1) {
+      this.flakey.push(fileName);
+    } else {
+      this[status].push(fileName);
+    }
+    this[status].push(fileName);
+  }
+  onError(error) {
+    this.errored.push({
+      error: error.message,
+      stack: error.stack
+    });
+  }
+  onEnd(result) {
+    this.durationInMS = Date.now() - this.startedAt;
+    this.status = result.status;
+
+    // removing duplicate tests from passed array
+    this.passed = this.passed.filter((element, index) => {
+      return this.passed.indexOf(element) === index;
+    });
+    // removing duplicate tests from the failed array
+    this.failed = this.failed.filter((element, index) => {
+      if (!this.passed.includes(element)) {
+        return this.failed.indexOf(element) === index;
+      }
+    });
+    // removing duplicate tests from the skipped array
+    this.skipped = this.skipped.filter((element, index) => {
+      return this.skipped.indexOf(element) === index;
+    });
+    // removing duplicate tests from the timedOut array
+    this.timedOut = this.timedOut.filter((element, index) => {
+      return this.timedOut.indexOf(element) === index;
+    });
+    // removing duplicate tests from the interrupted array
+    this.interrupted = this.interrupted.filter((element, index) => {
+      return this.interrupted.indexOf(element) === index;
+    });
+    this.errored = this.errored.filter((element, index) => {
+      return this.errored.indexOf(element) === index;
+    });
+    if (this.errored.length > 0) {
+      // Reflect setup failures in the final report status
+      this.status = "failed";
+    }
+
+    // fs.writeFileSync('./summary.json', JSON.stringify(this, null, '  '));
+    let {
+      reportPath
+    } = (0, _readConfigFile.generateConfigFromFile)();
+    (0, _fileUtils.writeFileContents)(_path.default.join(reportPath, './', (0, _configFileNameProvider.getReportFileName)()), JSON.stringify(this, null, '  '));
+  }
+  onExit() {
+    const shouldClearLastLine = this._open !== 'always' || this._open !== 'on-failure';
+    if (shouldClearLastLine) {
+      /**Below code is to replace the playwright default report commond with abstraction tool command */
+      _readline.default.moveCursor(process.stdout, 0, -2); // up two line
+      _readline.default.clearLine(process.stdout, 1); // from cursor to end
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'npx ZDTestingFramework report or npm run uat-report');
+      return;
+    }
+  }
+}
+var _default = exports.default = JSONSummaryReporter;