@zohodesk/testinglibrary 0.0.7 → 0.0.8-n20-experimental

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,80 @@
+"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");
+const uatConfig = (0, _readConfigFile.generateConfigFromFile)();
+const {
+  isAuthMode,
+  isSmokeTest,
+  bddMode,
+  authFilePath,
+  trace,
+  video,
+  testIdAttribute,
+  viewport
+} = uatConfig;
+function setupConfig() {
+  const setupProject = new _Project.Project('setup');
+  setupProject.setTestMatch(/.*\.setup\.js/);
+  setupProject.setTestDir(_path.default.join(process.cwd(), 'uat'));
+  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(), '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')
+  });
+  const commonConfig = {
+    storageState: isAuthMode ? (0, _readConfigFile.getAuthFilePath)(_path.default.resolve(process.cwd(), authFilePath)) : {}
+  };
+  smokeTestProject.setTestDir(smokeTestDir);
+  smokeTestProject.setRetries(0);
+  smokeTestProject.setUse({
+    ...commonConfig
+  });
+  smokeTestProject.setDependencies(isAuthMode ? ['setup'] : []);
+  const smokeTestProjectConfig = [smokeTestProject.getProperties()];
+  return smokeTestProjectConfig;
+}
+function defaultConfig() {
+  const defaultProject = new _Project.Project('default');
+  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
+  };
+  defaultProject.setUse(use);
+  defaultProject.setTestDir(testDir);
+  defaultProject.setDependencies(isSmokeTest ? ['smokeTest'] : []);
+  const defaultProjectConfig = [defaultProject.getProperties()];
+  return defaultProjectConfig;
+}
+function cleanupConfig() {
+  const cleanupProject = new _Project.Project('cleanup');
+  cleanupProject.setTestMatch(/.*\.teardown\.js/);
+  cleanupProject.setTestDir(_path.default.join(process.cwd(), 'uat'));
+  const cleanupProjectConfig = [cleanupProject.getProperties()];
+  return cleanupProjectConfig;
+}

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

@@ -7,111 +7,83 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _test = require("@playwright/test");
 var _path = _interopRequireDefault(require("path"));
-var _bddFramework = require("../../../bdd-framework");
 var _readConfigFile = require("../readConfigFile");
-// @ts-check
-
-// import { cpus } from 'os';
-// const numOfCpus = cpus().length;
-const defaultBrowser = ['Chrome'];
+var _configUtils = require("./config-utils");
+var _ProjectConfiguration = require("./ProjectConfiguration");
+const uatConfig = (0, _readConfigFile.generateConfigFromFile)();
 const {
-  browsers = defaultBrowser,
-  trace = false,
-  video = false,
+  bddMode,
+  browsers,
+  isSmokeTest,
   isAuthMode,
   openReportOn,
-  reportPath = _path.default.join(process.cwd(), 'uat', 'playwright-report'),
-  bddMode = false,
-  expectTimeout = 5 * 1000,
-  testTimeout = 60 * 1000,
-  authFilePath = 'uat/playwright/.auth/user.json'
-} = (0, _readConfigFile.generateConfigFromFile)();
-let projects = browsers.map(browserName => {
-  let browser = browserName.toLowerCase();
-  if (browser === 'chrome') {
-    return {
-      name: 'chromium',
-      use: {
-        ..._test.devices['Desktop Chrome'],
-        storageState: isAuthMode ? (0, _readConfigFile.getAuthFilePath)(_path.default.resolve(process.cwd(), authFilePath)) : {}
-      },
-      dependencies: isAuthMode ? ['setup'] : []
-    };
-  } else if (browser === 'edge') {
-    return {
-      name: 'Microsoft Edge',
-      use: {
-        ..._test.devices['Desktop Chrome'],
-        channel: 'msedge',
-        storageState: isAuthMode ? (0, _readConfigFile.getAuthFilePath)(_path.default.resolve(process.cwd(), authFilePath)) : {}
-      },
-      dependencies: isAuthMode ? ['setup'] : []
-    };
-  } else if (browser === 'firefox') {
-    return {
-      name: 'firefox',
-      timeout: 4 * 60 * 1000,
-      expect: {
-        timeout: 80 * 1000
-      },
-      use: {
-        ..._test.devices['Desktop Firefox'],
-        storageState: isAuthMode ? (0, _readConfigFile.getAuthFilePath)(_path.default.resolve(process.cwd(), authFilePath)) : {}
-      },
-      dependencies: isAuthMode ? ['setup'] : []
-    };
-  } else if (browser === 'safari') {
-    return {
-      name: 'webkit',
-      timeout: 2 * 60 * 1000,
-      expect: {
-        timeout: 80 * 1000
-      },
-      use: {
-        ..._test.devices['Desktop Safari'],
-        storageState: isAuthMode ? (0, _readConfigFile.getAuthFilePath)(_path.default.resolve(process.cwd(), authFilePath)) : {}
-      },
-      dependencies: isAuthMode ? ['setup'] : null
-    };
-  }
-}).filter(Boolean);
-const testPath = _path.default.join(_path.default.resolve(process.cwd()), 'uat');
-const testDir = bddMode ? (0, _bddFramework.defineBddConfig)({
-  paths: [`${testPath}/**/*.feature`],
-  import: [`${testPath}/**/steps/*.spec.js`],
-  featuresRoot: `${testPath}`,
-  outputDir: `${testPath}/.features-gen`,
-  publish: true
-}) : _path.default.join(_path.default.resolve(process.cwd()), 'uat');
-var _default = (0, _test.defineConfig)({
-  testDir,
-  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
-  }]],
-  timeout: testTimeout,
-  expect: {
-    timeout: expectTimeout
-  },
-  use: {
-    trace: trace ? 'on' : 'off',
-    video: video ? {
-      mode: 'on',
-      size: {
-        width: 640,
-        height: 480
-      }
-    } : 'off'
-  },
-  projects: isAuthMode ? [{
-    name: 'setup',
-    testMatch: /.*\.setup\.js/,
-    testDir: _path.default.join(_path.default.resolve(process.cwd()), 'uat')
-  }, ...projects] : [...projects]
+  reportPath,
+  expectTimeout,
+  testTimeout,
+  authFilePath,
+  viewport,
+  globalTimeout,
+  customReporter,
+  trace,
+  video,
+  testIdAttribute
+} = uatConfig;
+const projects = (0, _configUtils.getProjects)({
+  browsers,
+  isAuthMode,
+  isSmokeTest,
+  authFilePath,
+  expectTimeout,
+  testTimeout,
+  viewport
+});
+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}
+ */
+
+const use = {
+  trace,
+  video,
+  viewport,
+  testIdAttribute
+};
+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')
 });
-exports.default = _default;
+function getPlaywrightConfig() {
+  const smokeTestProject = isSmokeTest ? (0, _ProjectConfiguration.smokeTestConfig)() : [];
+  const setupProject = isAuthMode ? (0, _ProjectConfiguration.setupConfig)() : [];
+  const isTearDown = JSON.parse(process.env.tearDown);
+  const cleanupProject = isTearDown ? (0, _ProjectConfiguration.cleanupConfig)() : [];
+  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: [...setupProject, ...smokeTestProject, ...projects, ...cleanupProject],
+    ...uatConfig
+  };
+  return playwrightConfig;
+}
+var _default = exports.default = (0, _test.defineConfig)(getPlaywrightConfig());

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

@@ -0,0 +1,188 @@
+"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', 'modules', '**', '*.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 {
+      validModuleList = [];
+      throw new Error(`Module ${moduleName} does not exist. We have not triggered the execution for this module`);
+    }
+  });
+  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;