@zohodesk/testinglibrary 0.1.9-exp-actors → 0.1.12-experimental

package/build/core/playwright/reporter/PlaywrightReporter.js

@@ -0,0 +1,58 @@
+"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 _rootPath = require("../../../utils/rootPath");
+var _readConfigFile = require("../readConfigFile");
+var _configConstants = _interopRequireDefault(require("../constants/configConstants"));
+var _spawnInheritChild = require("../spawnInheritChild");
+var _Reporter = _interopRequireDefault(require("./Reporter"));
+// The framework reporters live next to the playwright configs, they are resolved
+// from here because this module no longer sits in the same folder as them.
+const SETUP_DIR = _path.default.resolve(__dirname, '..', 'setup');
+class PlaywrightReporter extends _Reporter.default {
+  static getType() {
+    return _Reporter.default.TYPES.PLAYWRIGHT;
+  }
+
+  /**
+   * Reporters used by a full run and by the merge of the shard blob reports.
+   *
+   * @returns {import('@playwright/test').PlaywrightTestConfig['reporter']}
+   */
+  static getReporter({
+    stage,
+    reportPath,
+    openReportOn,
+    customReporter
+  }) {
+    const reporter = [['html', {
+      outputFolder: reportPath,
+      open: openReportOn
+    }], ['list'], ['json', {
+      outputFile: _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'test-results', 'playwright-test-results.json')
+    }], [_path.default.join(SETUP_DIR, 'custom-reporter.js')], [_path.default.join(SETUP_DIR, 'qc-custom-reporter.js')]];
+    if (customReporter) {
+      return [customReporter, ...reporter];
+    }
+    return reporter;
+  }
+  static generate() {
+    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);
+    (0, _spawnInheritChild.spawnInheritChild)(command, args, {
+      exitOnSuccess: true,
+      killOnParentExit: true
+    });
+  }
+}
+exports.default = PlaywrightReporter;

package/build/core/playwright/reporter/Reporter.js

@@ -0,0 +1,65 @@
+"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 _configConstants = _interopRequireDefault(require("../constants/configConstants"));
+// Playwright accepts the shard as `current/total`. Anything else (a bare `--shard`
+// flag, for instance) is not a shard run and must keep the default reporters.
+const SHARD_PATTERN = /^\d+\/\d+$/;
+const REPORTER_TYPES = {
+  PLAYWRIGHT: 'playwright',
+  SHARD: 'shard'
+};
+
+/**
+ * Base of the report modes. Every mode exposes `getType()` and `getReporter(config)`,
+ * `merge()` is implemented by the shard mode alone.
+ */
+class Reporter {
+  static get TYPES() {
+    return REPORTER_TYPES;
+  }
+  static isShardedRun(shard) {
+    return typeof shard === 'string' && SHARD_PATTERN.test(shard);
+  }
+  static getBlobReportDir(stage) {
+    return _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'blob-report');
+  }
+
+  /**
+   * Resolves the report mode to use for a run.
+   *
+   * @returns {string} one of {@link REPORTER_TYPES}
+   */
+  static resolveType(shard) {
+    return Reporter.isShardedRun(shard) ? REPORTER_TYPES.SHARD : REPORTER_TYPES.PLAYWRIGHT;
+  }
+
+  /**
+   * Factory of the report modes. The modes are required lazily because they
+   * extend this class, a top level import would leave the class undefined.
+   *
+   * @returns {typeof Reporter}
+   */
+  static getReporterClass(type) {
+    switch (type) {
+      case REPORTER_TYPES.PLAYWRIGHT:
+        return require('./PlaywrightReporter').default;
+      case REPORTER_TYPES.SHARD:
+        return require('./ShardReporter').default;
+      default:
+        throw new Error(`Unknown reporter type "${type}"`);
+    }
+  }
+  static getType() {
+    throw new Error('getType() has to be implemented by the reporter');
+  }
+  static merge() {
+    throw new Error('merge() is supported by the shard reporter alone');
+  }
+}
+exports.default = Reporter;

package/build/core/playwright/reporter/ShardReporter.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../../utils/logger");
+var _rootPath = require("../../../utils/rootPath");
+var _ConfigurationHelper = require("../configuration/ConfigurationHelper");
+var _UserArgs = _interopRequireDefault(require("../configuration/UserArgs"));
+var _spawnInheritChild = require("../spawnInheritChild");
+var _Reporter = _interopRequireDefault(require("./Reporter"));
+class ShardReporter extends _Reporter.default {
+  static getType() {
+    return _Reporter.default.TYPES.SHARD;
+  }
+
+  /**
+   * A shard only records its results as a blob. The report files are written once
+   * by `ZDTestingFramework merge-reports`, so the shards do not overwrite them.
+   *
+   * @returns {import('@playwright/test').PlaywrightTestConfig['reporter']}
+   */
+  static getReporter({
+    stage,
+    shard
+  }) {
+    return [['blob', {
+      outputDir: _Reporter.default.getBlobReportDir(stage),
+      fileName: `report-${shard.replace('/', '-')}.zip`
+    }], ['list']];
+  }
+  static merge() {
+    // `merge-reports` is its own CLI command, so nothing has resolved the stage yet.
+    // It is resolved once here and exported before the spawn, because the playwright
+    // child reads it back through getRunStage() while loading merge-config.js.
+    const stage = _UserArgs.default.parseToObject(process.argv.slice(2)).stage || (0, _ConfigurationHelper.getRunStage)();
+    process.env.stage = stage;
+    const blobReportDir = _Reporter.default.getBlobReportDir(stage);
+    if (!(0, _fs.existsSync)(blobReportDir)) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `No blob reports found at ${blobReportDir} for stage "${stage}". Run the tests with --shard first (Usage: -- --shard=1/4)`);
+      process.exit(1);
+    }
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Merging blob reports from ${blobReportDir}`);
+    const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
+    const command = playwrightPath;
+    const configPath = _path.default.resolve(__dirname, '../', 'setup', 'merge-config.js');
+    const args = ['merge-reports', blobReportDir, '--config', require.resolve(configPath)];
+    (0, _spawnInheritChild.spawnInheritChild)(command, args, {
+      successMessage: 'Blob Reports Merged Successfully',
+      exitOnSuccess: true
+    });
+  }
+}
+exports.default = ShardReporter;

package/build/core/playwright/reporter/UnitReporter.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
+var _os = require("os");
+var _logger = require("../../../utils/logger");
+var _reporterConstants = _interopRequireDefault(require("../constants/reporterConstants"));
+class UnitReporter {
+  static generate() {
+    const reportPath = _path.default.resolve(process.cwd(), _reporterConstants.default.DEFAULT_UNIT_TEST_REPORTER_PATH);
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `Opening unit test report: ${reportPath}`);
+    const os = (0, _os.platform)();
+    const openCommand = os === 'darwin' ? 'open' : os === 'win32' ? 'start' : 'xdg-open';
+    (0, _child_process.execFile)(openCommand, [reportPath], error => {
+      if (error) {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to open report: ${error.message}`);
+      }
+      process.exit();
+    });
+  }
+}
+exports.default = UnitReporter;

package/build/core/playwright/reporter/helpers/mergeAbortedTests.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = mergeAbortedTestsIntoLastRun;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../../../utils/logger");
+var _fileUtils = require("../../../../utils/fileUtils");
+var _reporterConstants = _interopRequireDefault(require("../../constants/reporterConstants"));
+function mergeAbortedTestsIntoLastRun() {
+  let resultsFile = _path.default.resolve(process.cwd(), _reporterConstants.default.DEFAULT_REPORTER_PATH),
+    lastRunFile = _path.default.resolve(process.cwd(), _reporterConstants.default.LAST_RUN_REPORTER_PATH);
+  try {
+    let report;
+    try {
+      report = JSON.parse(_fs.default.readFileSync(resultsFile, 'utf-8'));
+    } catch (e) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to parse results file: ${resultsFile}`, e);
+      return;
+    }
+    const abortedTests = collectAbortedSpecIds(report);
+    let lastRunData = {
+      status: 'passed',
+      failedTests: []
+    };
+    if (_fs.default.existsSync(lastRunFile)) {
+      try {
+        const parsed = JSON.parse(_fs.default.readFileSync(lastRunFile, 'utf-8'));
+        lastRunData.status = parsed.status || lastRunData.status;
+        lastRunData.failedTests = Array.isArray(parsed.failedTests) ? parsed.failedTests : [];
+      } catch (e) {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to parse existing last-run file: ${lastRunFile}`, e);
+      }
+    }
+
+    // Merge existing failed tests + aborted tests
+    const failedSet = new Set(lastRunData.failedTests);
+    for (const id of abortedTests) {
+      failedSet.add(id);
+    }
+    lastRunData.failedTests = [...failedSet];
+    lastRunData.status = failedSet.size > 0 ? 'failed' : lastRunData.status;
+    (0, _fileUtils.writeFileContents)(lastRunFile, JSON.stringify(lastRunData, null, 2));
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Updated ${abortedTests.size} aborted tests in .last-run.json file \n`);
+    return lastRunData;
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Error updating .last-run.json: ${err.message}`);
+  }
+}
+function collectAbortedSpecIds(report) {
+  const aborted = new Set();
+  if (!Array.isArray(report.suites)) {
+    return aborted;
+  }
+  const isAbortedSpec = spec => {
+    var _spec$tests;
+    const tags = Array.isArray(spec.tags) ? spec.tags : [];
+    return (_spec$tests = spec.tests) === null || _spec$tests === void 0 ? void 0 : _spec$tests.some(t => !tags.includes('skip') && t.projectName === 'chromium' && t.status === 'skipped');
+  };
+  const testResultsObj = report.suites;
+  while (testResultsObj.length > 0) {
+    const suite = testResultsObj.pop();
+    if (Array.isArray(suite.specs)) {
+      for (const spec of suite.specs) {
+        if (spec && isAbortedSpec(spec)) {
+          aborted.add(spec.id);
+        }
+      }
+    }
+    if (Array.isArray(suite.suites)) {
+      for (const child of suite.suites) testResultsObj.push(child);
+    }
+  }
+  return aborted;
+}

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,93 @@
+"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 _spawnInheritChild = require("../spawnInheritChild");
+var _RunnerHelper = _interopRequireDefault(require("./RunnerHelper"));
+var _Runner = _interopRequireDefault(require("./Runner"));
+var _commonUtils = require("../../../utils/commonUtils");
+var _retryConstants = require("../../playwright/constants/retryConstants");
+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.runPreprocessingWithRetry());
+    }
+    Promise.all(promises).then(() => this.runPlaywright()).catch(err => {
+      _logger.Logger.error(err);
+      process.exit(1);
+    });
+  }
+
+  // This below Retry wrapper function for preprocessing the feature files Missing Step Definitions Issue
+
+  async runPreprocessingWithRetry(maxRetries = _retryConstants.PREPROCESSING_RETRY_MAX_ATTEMPTS, delayMs = _retryConstants.PREPROCESSING_RETRY_DELAY_MS) {
+    for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
+      try {
+        await this.runPreprocessing();
+        return;
+      } catch (err) {
+        if (attempt > maxRetries) {
+          _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Preprocessing failed after ${attempt} attempts`);
+          throw err;
+        }
+        _logger.Logger.log(_logger.Logger.INFO_TYPE, `Preprocessing failed (attempt ${attempt} of ${maxRetries + 1}). Retrying in ${delayMs}ms...`);
+        await new Promise(resolve => setTimeout(resolve, delayMs));
+      }
+    }
+  }
+  runPreprocessing() {
+    //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 (0, _spawnInheritChild.spawnInheritChild)(beforeCommand, beforeArgs, {
+      successMessage: 'Feature Files Processed Successfully',
+      failureMessage: code => `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 (0, _spawnInheritChild.spawnInheritChild)(command, args, {
+      successMessage: 'Test Ran Successfully',
+      killOnParentExit: true
+    });
+  }
+}
+module.exports = SpawnRunner;

package/build/core/playwright/setup/Project.js

@@ -0,0 +1,35 @@
+"use strict";
+
+class Project {
+  constructor(name) {
+    this.properties = {};
+    this.properties.name = name;
+  }
+  setTestDir(value) {
+    this.properties.testDir = value;
+  }
+  setTestMatch(value) {
+    this.properties.testMatch = value;
+  }
+  setRetries(value) {
+    this.properties.retries = value;
+  }
+  setUse(value) {
+    this.properties.use = value;
+  }
+  setTearDown(value) {
+    this.properties.teardown = value;
+  }
+  setDependencies(value) {
+    this.properties.dependencies = value;
+  }
+  setProperty(key, value) {
+    this.properties[key] = value;
+  }
+  getProperties() {
+    return this.properties;
+  }
+}
+module.exports = {
+  Project
+};

package/build/core/playwright/setup/ProjectConfiguration.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanupConfig = cleanupConfig;
+exports.setupConfig = setupConfig;
+exports.smokeTestConfig = smokeTestConfig;
+var _path = _interopRequireDefault(require("path"));
+var _Project = require("./Project");
+var _configUtils = require("./config-utils");
+var _readConfigFile = require("../readConfigFile");
+var _configConstants = _interopRequireDefault(require("../constants/configConstants"));
+var _ConfigurationHelper = require("../configuration/ConfigurationHelper");
+const stage = (0, _ConfigurationHelper.getRunStage)();
+const uatConfig = (0, _readConfigFile.generateConfigFromFile)();
+const {
+  isAuthMode,
+  isSmokeTest,
+  bddMode,
+  authFilePath,
+  trace,
+  smokeTestTrace,
+  video,
+  testIdAttribute,
+  viewport,
+  stepDefinitionsFolder
+} = uatConfig;
+function setupConfig() {
+  const setupProject = new _Project.Project('setup');
+  setupProject.setTestMatch(/.*\.setup\.js/);
+  setupProject.setTestDir(_path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER));
+  const isTearDown = JSON.parse(process.env.tearDown);
+  setupProject.setTearDown(isTearDown ? 'cleanup' : '');
+  const setupProjectConfig = [setupProject.getProperties()];
+  return setupProjectConfig;
+}
+function smokeTestConfig() {
+  const smokeTestProject = new _Project.Project('smokeTest');
+  const smokeTestDir = (0, _configUtils.getTestDir)(bddMode, {
+    featureFilesFolder: _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'smokeTest', '**', '*.feature'),
+    stepDefinitionsFolder: _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, '**', '**', stepDefinitionsFolder, '*.spec.js'),
+    outputDir: _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, _configConstants.default.FEATURES_SMOKE_GEN_DIR),
+    uatPath: _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'smokeTest')
+  });
+  const commonConfig = {
+    storageState: isAuthMode ? (0, _readConfigFile.getAuthFilePath)(_path.default.resolve(process.cwd(), authFilePath)) : {},
+    trace: smokeTestTrace
+  };
+  smokeTestProject.setTestDir(smokeTestDir);
+  smokeTestProject.setRetries(0);
+  smokeTestProject.setUse({
+    ...commonConfig
+  });
+  smokeTestProject.setDependencies(isAuthMode ? ['setup'] : []);
+  const smokeTestProjectConfig = [smokeTestProject.getProperties()];
+  return smokeTestProjectConfig;
+}
+function cleanupConfig() {
+  const cleanupProject = new _Project.Project('cleanup');
+  cleanupProject.setTestMatch(/.*\.teardown\.js/);
+  cleanupProject.setTestDir(_path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER));
+  const cleanupProjectConfig = [cleanupProject.getProperties()];
+  return cleanupProjectConfig;
+}