@zohodesk/testinglibrary 0.4.75-n18-experimental → 0.4.77-n18-experimental

package/build/core/playwright/builtInFixtures/page.js

@@ -9,6 +9,8 @@ var _auth = require("../helpers/auth");
 var _readConfigFile = require("../readConfigFile");
 /* eslint-disable global-require */
 
+//import { additionProfiles } from '../helpers/additionalProfiles';
+
 function getTagInputFromSelectedTags(tags, inputString) {
   const selectedTag = [...tags].reverse().find(tag => tag.startsWith(inputString));
   let tagInput = null;
@@ -18,7 +20,7 @@ function getTagInputFromSelectedTags(tags, inputString) {
   return tagInput;
 }
 function getCustomAccountDetails(tags) {
-  const tagsTobeFiltered = ['@profile', '@edition', '@beta', '@portal'];
+  const tagsTobeFiltered = ['@profile', '@edition', '@beta', '@portal', '@additional_profile'];
   const filteredTags = tags.filter(tag => tagsTobeFiltered.some(prefix => tag.startsWith(prefix)));
   if (filteredTags && filteredTags.length > 0) {
     const portalInfo = getTagInputFromSelectedTags(filteredTags, '@portal');

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.additionProfiles = additionProfiles;
+var _getUsers = require("./auth/getUsers");
+function additionProfiles(tags, editionInfo, betaFeature, portalInfo) {
+  const additionalProfileTags = tags.filter(tag => tag.startsWith('@additional_profile_'));
+  let additionalProfileActors = [];
+  if (additionalProfileTags.length > 0 && editionInfo) {
+    additionalProfileActors = additionalProfileTags.map(tag => {
+      const additionalProfile = tag.replace('@additional_profile_', '');
+      return (0, _getUsers.getUserForSelectedEditionAndProfile)(editionInfo, additionalProfile, betaFeature, portalInfo);
+    });
+  }
+  return additionalProfileActors;
+}

package/build/core/playwright/helpers/auth/accountLogin.js

@@ -13,6 +13,9 @@ async function accountLogin(page, useremail, password) {
   await page.locator('#nextbtn').click();
   const domainUrlOrigin = (0, _getUrlOrigin.default)(process.env.domain);
   await page.waitForNavigation();
-  await Promise.race([page.waitForURL(`${domainUrlOrigin}/**`), page.waitForURL('**/announcement/**')]);
+  if (!page.url().includes(domainUrlOrigin)) {
+    await page.goto(domainUrlOrigin);
+  }
+  await page.waitForURL(`${domainUrlOrigin}/**`);
 }
 var _default = exports.default = accountLogin;

package/build/core/playwright/helpers/auth/loginSteps.js

@@ -10,7 +10,6 @@ var _fileMutex = _interopRequireDefault(require("../fileMutex"));
 var _fileMutexConfig = require("../../constants/fileMutexConfig");
 var _checkAuthCookies = require("./checkAuthCookies");
 var _checkAuthDirectory = require("../checkAuthDirectory");
-var _fs = require("fs");
 /* eslint-disable no-console */
 
 async function performLoginSteps(testInfo, isLoggedIn, loginSteps) {

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

@@ -80,7 +80,7 @@ class SpawnRunner extends _Runner.default {
     const args = ['test', '--config', require.resolve(configPath)].concat(playwrightArgs);
     return new Promise((resolve, reject) => {
       const childProcessForRunningPlaywright = (0, _child_process.spawn)(command, args, {
-        stdio: 'pipe',
+        stdio: 'inherit',
         env: {
           ...process.env
         }
@@ -88,14 +88,6 @@ class SpawnRunner extends _Runner.default {
       childProcessForRunningPlaywright.on('error', error => {
         _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error);
       });
-      childProcessForRunningPlaywright.stdout.on('data', data => {
-        let stdoutData = data.toString();
-        if (stdoutData.includes('failed') && stdoutData.includes('smokeTest')) {
-          console.log(stdoutData);
-          console.log("Smoke test execution failed, so the main execution was skipped");
-          _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Smoke Test Failed');
-        }
-      });
       childProcessForRunningPlaywright.on('exit', (code, signal) => {
         if (code !== 0) {
           reject(`Child Process Exited with Code ${code} and Signal ${signal}`);

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

@@ -38,9 +38,17 @@ const projects = (0, _configUtils.getProjects)({
   testTimeout,
   viewport
 });
-const testDir = (0, _configUtils.getTestDir)(bddMode, process.cwd(), {
-  featureFilesFolder,
-  stepDefinitionsFolder
+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')
 });
 const use = {
   trace,
@@ -52,8 +60,8 @@ let reporter = [['html', {
   outputFolder: reportPath,
   open: openReportOn
 }], ['list'], ['json', {
-  outputFile: _path.default.join(process.cwd(), 'uat', 'test-results', 'test-results.json')
-}], ['./custom-reporter.js']];
+  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];
 }
@@ -71,8 +79,7 @@ function getPlaywrightConfig() {
   const dependencies = isAuthMode ? ['setup'] : [];
   const smokeTestProject = {
     name: 'smokeTest',
-    testMatch: /.*\.smokeTest\.js/,
-    testDir: _path.default.join(process.cwd(), 'uat'),
+    testDir: smokeTestDir,
     use: {
       ...commonConfig
     },

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getBrowsersList = getBrowsersList;
 exports.getModulePathForFeatureFiles = getModulePathForFeatureFiles;
+exports.getPathsForFeatureFiles = getPathsForFeatureFiles;
 exports.getProjects = getProjects;
 exports.getTestDir = getTestDir;
 var _test = require("@playwright/test");
@@ -168,18 +169,21 @@ function getModulePathForFeatureFiles(moduleList) {
   });
   return validModuleList;
 }
-function getTestDir(bddMode, cwd, {
-  stepDefinitionsFolder
+function getTestDir(bddMode, {
+  featureFilesFolder,
+  stepDefinitionsFolder,
+  outputDir,
+  uatPath
 }) {
   return bddMode ? (0, _playwrightBdd.defineBddConfig)({
-    features: getPathsForFeatureFiles(cwd),
-    steps: [_path.default.join(cwd, 'uat', '**', stepDefinitionsFolder, '*.spec.js'), require.resolve('../fixtures.js')],
+    features: featureFilesFolder,
+    steps: [stepDefinitionsFolder, require.resolve('../fixtures.js')],
     importTestFrom: require.resolve('../fixtures.js'),
-    featuresRoot: _path.default.join(cwd, 'uat'),
-    outputDir: _path.default.join(cwd, 'uat', '.features-gen'),
+    featuresRoot: uatPath,
+    outputDir: outputDir,
     disableWarnings: {
       importTestFrom: true
     },
     publish: true
-  }) : _path.default.join(cwd, 'uat');
+  }) : uatPath;
 }

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

@@ -0,0 +1,291 @@
+"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");
+class CustomJsonReporter {
+  constructor({
+    outputFile = 'test-results.json'
+  } = {}) {
+    this.outputFile = _path.default.resolve(process.cwd(), 'uat/test-results/', outputFile);
+    this.rootSuite = null;
+    this.report = {
+      config: {},
+      suites: []
+    };
+    this.testResultsById = new Map();
+  }
+  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}`;
+    const testResult = {
+      status: result.status,
+      attachments: result.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);
+    });
+    const writableStream = _fs.default.createWriteStream(this.outputFile);
+    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}`);
+  }
+}
+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)
+  }),
+  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,
+    tags: test.tags,
+    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/test-runner.js

@@ -105,7 +105,7 @@ function main() {
   //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(userArgsObject);
+  const tagArgs = tagProcessor.processTags(uatConfig.getAll());
   const runnerObj = new _Runner.default();
   runnerObj.setTagArgs(tagArgs);
   runnerObj.setUserArgs(userArgsObject);

package/build/test/Test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+delete require.cache[require.resolve('../core/playwright/runner/Runner')];
+function test() {
+  const inputString = "@hc";
+  const selectedTag = ["@hc_1234"].reverse().find(tag => tag.startsWith(inputString));
+  let tagInput = null;
+  if (selectedTag) {
+    tagInput = selectedTag.split(`${inputString}_`).pop().toLowerCase();
+  }
+  console.log(tagInput);
+}
+test();