@zohodesk/testinglibrary 0.1.9 → 0.1.12-experimental

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

@@ -0,0 +1,342 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _codeFrame = require("@babel/code-frame");
+var _configConstants = _interopRequireDefault(require("../constants/configConstants"));
+var _ConfigurationHelper = require("../configuration/ConfigurationHelper");
+var _readConfigFile = require("../readConfigFile");
+var _failureTagClassifier = require("../helpers/failureTagClassifier");
+const stage = (0, _ConfigurationHelper.getRunStage)();
+const {
+  failureSegregation = true
+} = (0, _readConfigFile.generateConfigFromFile)();
+
+// Walks the built suite tree and appends derived failure tags (CASE_failure, CODE_failure, ENVIRONMENT_failure) into each spec's tags array.
+const applyFailureTags = suite => {
+  for (const spec of suite.specs ?? []) {
+    const failureTags = (0, _failureTagClassifier.classifyFailureTags)(spec.tests, spec.title);
+    if (failureTags.length > 0) {
+      spec.tags = (0, _failureTagClassifier.mergeFailureTags)(spec.tags, failureTags);
+    }
+  }
+  for (const child of suite.suites ?? []) {
+    applyFailureTags(child);
+  }
+};
+class CustomJsonReporter {
+  constructor({
+    outputFile = 'test-results.json'
+  } = {}) {
+    this.outputFile = _path.default.resolve(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'test-results/', outputFile);
+    this.rootSuite = null;
+    this.report = {
+      config: {},
+      suites: []
+    };
+    this.testResultsById = new Map();
+    this.failureSegregation = failureSegregation;
+  }
+  onBegin = (config, suite) => {
+    this.rootSuite = suite;
+    this.report.config = config;
+  };
+  onTestEnd(test, result) {
+    var _result$errors, _result$steps;
+    const key = `${test.location.file}:${test.location.line}:${test.title}`;
+    let attachments = result.attachments ?? [];
+    if (this.failureSegregation && (0, _failureTagClassifier.isFailingResultStatus)(result.status)) {
+      const metadata = (0, _failureTagClassifier.classifyFailureDetailsFromResult)({
+        status: result.status,
+        workerIndex: result.workerIndex,
+        retry: result.retry,
+        stdout: result.stdout.map(out => stdioEntry(out)),
+        stderr: result.stderr.map(err => stdioEntry(err))
+      }, test.title);
+      attachments = (0, _failureTagClassifier.upsertFailureTagMetadataAttachment)(attachments, metadata);
+    }
+    const testResult = {
+      status: result.status,
+      attachments,
+      startTime: result.startTime,
+      retry: result.retry,
+      stderr: result.stderr.map(err => stdioEntry(err)),
+      stdout: result.stdout.map(out => stdioEntry(out)),
+      workerIndex: result.workerIndex,
+      duration: result.duration,
+      error: result.error,
+      errors: (_result$errors = result.errors) === null || _result$errors === void 0 ? void 0 : _result$errors.map(processError),
+      steps: ((_result$steps = result.steps) === null || _result$steps === void 0 ? void 0 : _result$steps.map(step => extractMergedSteps(this.report.config.rootDir, step))) ?? []
+    };
+    const existingResults = this.testResultsById.get(key) ?? [];
+    this.testResultsById.set(key, [...existingResults, testResult]);
+  }
+  onEnd() {
+    var _this$rootSuite;
+    (_this$rootSuite = this.rootSuite) === null || _this$rootSuite === void 0 || (_this$rootSuite = _this$rootSuite.suites) === null || _this$rootSuite === void 0 || _this$rootSuite.map(suite => {
+      const extracted = suite.suites.map(suite => extractMergedSuite(this.report.config.rootDir, suite, this.testResultsById));
+      this.report.suites.push(...extracted);
+    });
+    if (this.failureSegregation) {
+      this.report.suites.forEach(suite => applyFailureTags(suite));
+    }
+    const outputDirectory = _path.default.dirname(this.outputFile);
+    if (!_fs.default.existsSync(outputDirectory)) {
+      _fs.default.mkdirSync(outputDirectory, {
+        recursive: true
+      });
+    }
+    const writableStream = _fs.default.createWriteStream(this.outputFile);
+
+    // Playwright ends the process once onEnd settles. While merging the shard blob
+    // reports there is no further work keeping it alive, so the stream has to be
+    // flushed before returning. Reject on stream errors so Playwright cannot hang.
+    return new Promise((resolve, reject) => {
+      writableStream.on('error', reject);
+      writableStream.write('{\n');
+      writableStream.write(`  "config": ${JSON.stringify(this.report.config, null, 2)},\n`);
+      writableStream.write('  "suites": [\n');
+      for (let i = 0; i < this.report.suites.length; i++) {
+        const suite = this.report.suites[i];
+        let suiteStr = JSON.stringify(suite, null, 2).split('\n').map(line => '    ' + line).join('\n');
+        if (i < this.report.suites.length - 1) {
+          suiteStr += ',';
+        }
+        suiteStr += '\n';
+        writableStream.write(suiteStr);
+      }
+      writableStream.write('  ]\n');
+      writableStream.write('}\n');
+      writableStream.end(() => {
+        console.log(`Custom JSON report written to: ${this.outputFile}`);
+        resolve();
+      });
+    });
+  }
+}
+exports.default = CustomJsonReporter;
+const extractMergedSuite = (rootDir, suite, testResultsById) => {
+  var _suite$suites;
+  const specMap = new Map();
+  for (const test of suite.tests ?? []) {
+    const existingSpec = specMap.get(test.title);
+    if (existingSpec) {
+      const newTestInfo = extractTestDetails(test, testResultsById);
+      existingSpec.tests.push(newTestInfo);
+    } else {
+      const newSpec = createSpecEntry(rootDir, test, testResultsById);
+      specMap.set(test.title, newSpec);
+    }
+  }
+  return {
+    title: suite.title,
+    ...parseLocation(rootDir, suite.location),
+    ...(suite.location && {
+      snippet: formSnippet(rootDir, suite.location)
+    }),
+    ...(((_suite$suites = suite.suites) === null || _suite$suites === void 0 ? void 0 : _suite$suites.length) > 0 && {
+      suites: suite.suites.map(child => extractMergedSuite(rootDir, child, testResultsById))
+    }),
+    ...(specMap.size > 0 && {
+      specs: Array.from(specMap.values())
+    })
+  };
+};
+const createSpecEntry = (rootDir, test, testResultsById) => ({
+  title: test.title,
+  ...parseLocation(rootDir, test.location),
+  ...(test.location && {
+    snippet: formSnippet(test.location)
+  }),
+  tags: test.tags,
+  tests: [extractTestDetails(test, testResultsById)]
+});
+const extractTestDetails = (test, testResultsById) => {
+  var _test$location, _test$location2;
+  const key = `${(_test$location = test.location) === null || _test$location === void 0 ? void 0 : _test$location.file}:${(_test$location2 = test.location) === null || _test$location2 === void 0 ? void 0 : _test$location2.line}:${test.title}`;
+  return {
+    annotations: test.annotations,
+    expectedStatus: test.expectedStatus,
+    timeout: test.timeout,
+    retries: test.retries,
+    results: testResultsById.get(key) ?? [],
+    status: test.outcome()
+  };
+};
+const extractMergedSteps = (rootDir, step) => ({
+  title: step.title,
+  duration: step.duration,
+  ...(step.error && {
+    error: {
+      message: step.error.message,
+      stack: step.error.stack,
+      snippet: step.error.snippet
+    }
+  }),
+  ...parseLocation(rootDir, step.location),
+  status: step.status,
+  ...(step.location && {
+    snippet: formSnippet(rootDir, step.location)
+  }),
+  ...(step.steps && step.steps.length > 0 && {
+    steps: step.steps.map(subStep => extractMergedSteps(rootDir, subStep))
+  })
+});
+const formSnippet = (rootDir, location) => {
+  if (location && !(location !== null && location !== void 0 && location.file)) return '';
+  try {
+    const {
+      file,
+      line,
+      column
+    } = parseLocation(rootDir, location, false);
+    const raw = _fs.default.readFileSync(file, 'utf8');
+    return (0, _codeFrame.codeFrameColumns)(raw, {
+      start: {
+        line,
+        column
+      }
+    }, {
+      linesAbove: 2,
+      linesBelow: 2,
+      highlightCode: true
+    });
+  } catch {
+    return '';
+  }
+};
+const parseLocation = (rootDir, {
+  file,
+  line,
+  column
+} = {}, isRelative = true) => file ? {
+  file: isRelative ? _path.default.relative(rootDir, file) : file,
+  line,
+  column
+} : {};
+const stdioEntry = s => typeof s === 'string' ? {
+  text: s
+} : {
+  buffer: s.toString('base64')
+};
+const processError = error => {
+  const message = error.message || error.value || '';
+  const stack = error.stack;
+  if (!stack && !error.location) return {
+    message
+  };
+  const tokens = [];
+  const parsedStack = stack ? constructErrorStack(stack) : undefined;
+  tokens.push((parsedStack === null || parsedStack === void 0 ? void 0 : parsedStack.message) || message);
+  if (error.snippet) {
+    tokens.push('');
+    tokens.push(error.snippet);
+  }
+  if (parsedStack && parsedStack.stackLines.length) {
+    const dimmedStackLines = parsedStack.stackLines.split('\n').map(line => dimify(line));
+    tokens.push(dimmedStackLines.join('\n'));
+  }
+  let location = error.location;
+  if (parsedStack && !location) location = parsedStack.location;
+  if (error.cause) tokens.push(dimify('[cause]: ') + processError(error.cause).message);
+  return {
+    location,
+    message: tokens.join('\n')
+  };
+};
+const constructErrorStack = stack => parseErrorStack(stack, _path.default.sep, false);
+const dimify = text => `\x1b[2m${text}\x1b[22m`;
+const parseErrorStack = (stack, pathSeparator, showInternalStackFrames = false) => {
+  const lines = stack.split("\n");
+  let firstStackLineIndex = lines.findIndex(line => line.startsWith("    at "));
+  if (firstStackLineIndex === -1) firstStackLineIndex = lines.length;
+  const message = lines.slice(0, firstStackLineIndex).join("\n");
+  const stackStartIndex = indexLocator(stack, '\n', firstStackLineIndex) + 1 || 0;
+  const stackLinesString = stackStartIndex ? stack.slice(stackStartIndex) : '';
+  let location;
+  const stackLinesArr = stackLinesString.split('\n');
+  for (const line of stackLinesArr) {
+    const frame = parseStackFrame(line, pathSeparator, showInternalStackFrames);
+    if (!frame || !frame.file) continue;
+    if (isInNodeModules(frame.file, pathSeparator)) continue;
+    location = {
+      file: frame.file,
+      column: frame.column || 0,
+      line: frame.line || 0
+    };
+    break;
+  }
+  return {
+    message,
+    stackLines: stackLinesString,
+    location
+  };
+};
+const indexLocator = (str, pat, n) => {
+  let L = str.length,
+    i = -1;
+  while (n-- && i++ < L) {
+    i = str.indexOf(pat, i);
+    if (i < 0) break;
+  }
+  return i;
+};
+const isInNodeModules = (file, pathSeparator) => file.includes(`${pathSeparator}node_modules${pathSeparator}`);
+const parseStackFrame = (text, pathSeparator, showInternalStackFrames) => {
+  const re = new RegExp("^(?:\\s*at )?(?:(new) )?(?:(.*?) \\()?(?:eval at ([^ ]+) \\((.+?):(\\d+):(\\d+)\\), )?(?:(.+?):(\\d+):(\\d+)|(native))(\\)?)$");
+  const methodRe = /^(.*?) \[as (.*?)\]$/;
+  const match = text && text.match(re);
+  if (!match) return null;
+  let fname = match[2];
+  let file = match[7];
+  if (!file) return null;
+  if (!showInternalStackFrames && (file.startsWith("internal") || file.startsWith("node:"))) return null;
+  const line = match[8];
+  const column = match[9];
+  const closeParen = match[11] === ")";
+  const frame = {
+    file: "",
+    line: 0,
+    column: 0
+  };
+  if (line) frame.line = Number(line);
+  if (column) frame.column = Number(column);
+  if (closeParen && file) {
+    let closes = 0;
+    for (let i = file.length - 1; i > 0; i--) {
+      if (file.charAt(i) === ")") {
+        closes++;
+      } else if (file.charAt(i) === "(" && file.charAt(i - 1) === " ") {
+        closes--;
+        if (closes === -1 && file.charAt(i - 1) === " ") {
+          const before = file.slice(0, i - 1);
+          const after = file.slice(i + 1);
+          file = after;
+          fname += ` (${before}`;
+          break;
+        }
+      }
+    }
+  }
+  if (fname) {
+    const methodMatch = fname.match(methodRe);
+    if (methodMatch) fname = methodMatch[1];
+  }
+  if (file) {
+    if (file.startsWith("file://")) file = fileURLToPath(file, pathSeparator);
+    frame.file = file;
+  }
+  if (fname) frame.function = fname;
+  return frame;
+};
+const fileURLToPath = (fileUrl, pathSeparator) => {
+  if (!fileUrl.startsWith("file://")) return fileUrl;
+  let path = decodeURIComponent(fileUrl.slice(7));
+  if (path.startsWith("/") && /^[a-zA-Z]:/.test(path.slice(1))) path = path.slice(1);
+  return path.replace(/\//g, pathSeparator);
+};

package/build/core/playwright/spawnInheritChild.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.spawnInheritChild = spawnInheritChild;
+var _child_process = require("child_process");
+var _logger = require("../../utils/logger");
+function spawnInheritChild(command, args, options = {}) {
+  const {
+    successMessage,
+    failureMessage,
+    killOnParentExit,
+    exitOnSuccess
+  } = options;
+  return new Promise((resolve, reject) => {
+    const childProcess = (0, _child_process.spawn)(command, args, {
+      stdio: 'inherit',
+      env: {
+        ...process.env
+      }
+    });
+    childProcess.on('error', error => {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error);
+      if (!exitOnSuccess) {
+        reject(error);
+      }
+    });
+    childProcess.on('exit', (code, signal) => {
+      if (code !== 0) {
+        if (exitOnSuccess) {
+          _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Child Process Exited with Code ${code} and Signal ${signal}`);
+          process.exit(1);
+        } else if (failureMessage) {
+          reject(failureMessage(code));
+        } else {
+          reject(`Child Process Exited with Code ${code} and Signal ${signal}`);
+        }
+      } else {
+        if (successMessage) {
+          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, successMessage);
+        }
+        if (exitOnSuccess) {
+          process.exit(code);
+        } else {
+          resolve();
+        }
+      }
+    });
+    if (killOnParentExit) {
+      process.on('exit', () => {
+        if (exitOnSuccess) {
+          _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Terminating Playwright Process...');
+          childProcess.kill();
+        } else {
+          childProcess.kill();
+          reject('Terminating Playwright Process...');
+        }
+      });
+      process.on('SIGINT', () => {
+        childProcess.kill();
+        if (exitOnSuccess) {
+          _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Cleaning up...');
+          process.exit();
+        } else {
+          reject('Cleaning up...');
+        }
+      });
+    }
+  });
+}

package/build/core/playwright/tagProcessor.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _logger = require("../../utils/logger");
+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 _TagProcessor_brand = /*#__PURE__*/new WeakSet();
+class TagProcessor {
+  constructor(editionOrder) {
+    _classPrivateMethodInitSpec(this, _TagProcessor_brand);
+    this.editionOrder = editionOrder;
+  }
+  processTags(userArgs) {
+    const tagArgs = userArgs['tags'] || '';
+    const edition = userArgs['edition'] || null;
+    if (!edition) return tagArgs;
+    const editionsArray = edition.split(',');
+    const editionTags = editionsArray.length === 1 ? _assertClassBrand(_TagProcessor_brand, this, _processSingleEdition).call(this, editionsArray[0], tagArgs) : _assertClassBrand(_TagProcessor_brand, this, _processMultipleEditions).call(this, editionsArray, tagArgs);
+    return editionTags;
+  }
+}
+function _buildTagsString(tags, editionTags) {
+  return tags && tags !== '' ? `${tags} and not (${editionTags})` : `not (${editionTags})`;
+}
+function _parseEdition(edition) {
+  if (edition.startsWith('<=')) return ['<=', edition.slice(2)];
+  if (edition.startsWith('>=')) return ['>=', edition.slice(2)];
+  if (edition.startsWith('<')) return ['<', edition.slice(1)];
+  if (edition.startsWith('>')) return ['>', edition.slice(1)];
+  return [null, edition];
+}
+function _processSingleEdition(selectedEdition, tagArgs) {
+  const editionArgs = _assertClassBrand(_TagProcessor_brand, this, _getEditionArgs).call(this, selectedEdition);
+  if (editionArgs && editionArgs.length > 0) {
+    const editionTags = _assertClassBrand(_TagProcessor_brand, this, _buildEditionTags).call(this, editionArgs, 'or');
+    return _assertClassBrand(_TagProcessor_brand, this, _buildTagsString).call(this, tagArgs, editionTags);
+  }
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `No matching editions for ${selectedEdition} found. Running with default edition`);
+  return tagArgs;
+}
+function _processMultipleEditions(editionsArray, tagArgs) {
+  const filteredEditions = this.editionOrder.filter(edition => !editionsArray.includes(edition));
+  const editionTags = _assertClassBrand(_TagProcessor_brand, this, _buildEditionTags).call(this, filteredEditions, 'or');
+  return _assertClassBrand(_TagProcessor_brand, this, _buildTagsString).call(this, tagArgs, editionTags);
+}
+function _getEditionArgs(selectedEdition) {
+  const [operator, editionValue] = _assertClassBrand(_TagProcessor_brand, this, _parseEdition).call(this, selectedEdition.toLowerCase());
+  const index = this.editionOrder.findIndex(edition => edition.toLowerCase() === editionValue);
+  if (index === -1) {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `No matching editions for ${selectedEdition} found. Running with default edition`);
+    return [];
+  }
+  switch (operator) {
+    case '<=':
+      return this.editionOrder.slice(index + 1);
+    case '>=':
+      return this.editionOrder.slice(0, index);
+    case '<':
+      return this.editionOrder.slice(index);
+    case '>':
+      return this.editionOrder.slice(0, index + 1);
+    default:
+      return this.editionOrder.filter((_, i) => i !== index);
+  }
+}
+function _buildEditionTags(editionArgs, operator = 'or') {
+  return editionArgs.map(edition => `@edition_${edition}`).join(` ${operator} `);
+}
+module.exports = TagProcessor;

package/build/core/playwright/test-runner.js

@@ -5,120 +5,66 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _child_process = require("child_process");
+exports.runPreprocessing = runPreprocessing;
 var _path = _interopRequireDefault(require("path"));
-var _customCommands = require("./custom-commands");
-var _cliArgsToObject = require("../../utils/cliArgsToObject");
 var _envInitializer = require("./env-initializer");
-var _logger = require("../../utils/logger");
 var _readConfigFile = require("./readConfigFile");
 var _rootPath = require("../../utils/rootPath");
-var _tagProcessor = require("./tag-processor");
-var _configUtils = require("./setup/config-utils");
-var _browserTypes = require("./constants/browserTypes");
-var _parseUserArgs = _interopRequireDefault(require("./helpers/parseUserArgs"));
-function 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 _spawnInheritChild = require("./spawnInheritChild");
+var _tagProcessor = _interopRequireDefault(require("./tagProcessor"));
+var _ConfigurationHelper = require("./configuration/ConfigurationHelper");
+var _Configuration = _interopRequireDefault(require("./configuration/Configuration"));
+var _UserArgs = _interopRequireDefault(require("./configuration/UserArgs"));
+var _RunnerHelper = _interopRequireDefault(require("./runner/RunnerHelper"));
+var _Runner = _interopRequireDefault(require("./runner/Runner"));
 function runPreprocessing(tagArgs, configPath) {
   const beforeCommand = 'node';
-  const bddGenPath = _path.default.resolve(__dirname, '../', '../', 'bdd-framework', 'cli', 'index.js');
+  const bddGenPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('bddgen'));
   const beforeArgs = [bddGenPath, '-c', 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();
-    });
-    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}`);
-      }
-    });
-  });
-}
-function runPlaywright(command, args) {
-  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...');
-    });
+  return (0, _spawnInheritChild.spawnInheritChild)(beforeCommand, beforeArgs, {
+    successMessage: 'Feature Files Processed Successfully',
+    failureMessage: code => `BddGen exited with code ${code}`
   });
 }
 function main() {
-  const userArgsObject = (0, _parseUserArgs.default)();
+  // Getting the default config's from framework
+  const uatConfig = new _Configuration.default((0, _readConfigFile.getDefaultConfig)());
+  // overriding the application config's from project
+  const userArgConfig = new _Configuration.default(_UserArgs.default.parseToObject(process.argv.slice(2)));
+  const mode = userArgConfig.get("mode");
+  const stage = userArgConfig.get("stage");
+  uatConfig.addAll(new _Configuration.default((0, _ConfigurationHelper.getApplicationConfig)(stage, mode)));
+  // overriding the user config's from CLI
+  uatConfig.addAll(userArgConfig);
+  const modules = uatConfig.get('modules');
+  const tearDown = uatConfig.get('isTearDown');
+
+  //We need to change this process.env variable to pass the module name in future.
+  process.env.modules = modules;
+  process.env.tearDown = tearDown;
+  process.env.stage = stage;
   const {
+    isAuthMode,
+    editionOrder,
     debug,
-    mode = 'dev',
     bddMode = false,
-    headless = false,
-    editionOrder
-  } = (0, _readConfigFile.generateConfigFromFile)();
-  const tagArgs = (0, _tagProcessor.tagProcessor)(userArgsObject, editionOrder);
-  const playwrightArgs = getPlaywrightArgs(userArgsObject, debug, bddMode, tagArgs, headless);
-  (0, _envInitializer.initializeEnvConfig)(userArgsObject.mode ? userArgsObject.mode : mode);
-  const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
-  const command = playwrightPath;
-  const configPath = (0, _readConfigFile.isUserConfigFileAvailable)() ? require.resolve('./setup/config-creator.js') : require.resolve('../../../playwright.config.js');
-  const args = ['test', '--config', configPath].concat(playwrightArgs);
-  let promises = [];
-  if (bddMode) {
-    promises.push(runPreprocessing(tagArgs, configPath));
-  }
-  Promise.all(promises).then(() => runPlaywright(command, args)).catch(err => {
-    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, err);
-    process.exit();
-  });
+    headless = false
+  } = uatConfig.getAll();
+  (0, _envInitializer.initializeEnvConfig)(stage, mode, isAuthMode);
+
+  //This is only used for pass the user arguments to need places in legacy code. We need to rewamp that also.
+  const userArgsObject = userArgConfig.getAll();
+  const tagProcessor = new _tagProcessor.default(editionOrder);
+  const tagArgs = tagProcessor.processTags(uatConfig.getAll());
+  const runnerObj = new _Runner.default();
+  runnerObj.setTagArgs(tagArgs);
+  runnerObj.setUserArgs(userArgsObject);
+  runnerObj.setConfig(uatConfig);
+  const runner = _RunnerHelper.default.createRunner('spawn', runnerObj);
+  runner.run();
 }
 var _default = exports.default = main;

package/build/core/playwright/types.js

@@ -21,6 +21,7 @@
  * @property {string} uatDirectory - Directory in which uat configuration is places.
  * @property {string} headless - Headless Browsers mode.
  * @property {number} trace - trace for test cases.
+ * @property {string} smokeTestTrace - trace mode for the smokeTest project (e.g. 'on', 'off', 'retain-on-failure'). Default is 'on'.
  * @property {boolean} video - video for test cases,
  * @property {boolean} debug - debug mode
  * @property {string} mode: mode in which the test cases needs to run
@@ -31,7 +32,7 @@
  * @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 {number} testTimeout: time in milliseconds which the test should fail. Can be overridden per-scenario by tagging the scenario with `@timeout_<seconds>` (e.g. `@timeout_180`). `@timeout_0` disables the timeout. Browser scaling (Firefox 2x, Safari 4x) is preserved.
  * @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
@@ -39,5 +40,7 @@
  * @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.
+ * @property {string} modules: Modules name to be used for running the specific module test cases.
+ * @property {boolean} failureSegregation: When true, collect runtime browser logs on failure, classify failing tests into CODE/CASE/TOOL/ENVIRONMENT, attach additional_logs, and merge tags like CODE_failure into the report. Default: true.
  */
 "use strict";