@zohodesk/testinglibrary 0.0.3 → 0.0.4-n21-experimental

package/build/core/dataGenerator/DataGeneratorError.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GeneratorError = exports.DataGeneratorError = exports.DataGeneratorConfigurationError = void 0;
+class DataGeneratorError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'DataGeneratorError';
+
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, DataGeneratorError);
+    }
+  }
+
+  /**
+   * Get formatted error message with error type and message
+   * @returns {string} Formatted error message
+   */
+  getMessage() {
+    return `\n\n ${this.name} :::  \n\n Error Message: ${this.message} \n\n `;
+  }
+}
+
+// Specific error for Data Generator configuration issues
+exports.DataGeneratorError = DataGeneratorError;
+class DataGeneratorConfigurationError extends DataGeneratorError {
+  constructor(message) {
+    super(message);
+    this.name = 'DataGeneratorConfigurationError';
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, DataGeneratorConfigurationError);
+    }
+  }
+}
+
+// Specific error for Generator related issues
+exports.DataGeneratorConfigurationError = DataGeneratorConfigurationError;
+class GeneratorError extends DataGeneratorError {
+  constructor(message) {
+    super(message);
+    this.name = 'GeneratorError';
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, GeneratorError);
+    }
+  }
+}
+exports.GeneratorError = GeneratorError;

package/build/core/dataGenerator/DataGeneratorHelper.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getGeneratorFilePath = getGeneratorFilePath;
+exports.makeRequest = makeRequest;
+exports.processGenerator = processGenerator;
+//Create payload for the generators
+async function processGenerator(generators, dataTable) {
+  if (!dataTable) {
+    return generators;
+  }
+  return generators.map(generator => {
+    dataTable.forEach(row => {
+      const generatorName = row.DG_API_NAME;
+      if (generatorName === generator.name) {
+        generator.params = generator.params ? generator.params : {};
+
+        // The API name row is only used for matching the template
+        // Filter out DG_API_NAME and collect other values
+        Object.entries(row).filter(([key]) => key !== 'DG_API_NAME').forEach(([key, value]) => {
+          if (value !== '') {
+            generator.params[key] = value;
+          }
+        });
+      }
+    });
+    return generator;
+  });
+}
+async function makeRequest(url, payload) {
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(`HTTP error! status: ${response.status}, body: ${errorBody}`);
+  }
+  return response.json();
+}
+async function getGeneratorFilePath(featureFile) {
+  let generatorPath = featureFile.replace(".features-gen/", "");
+  return generatorPath;
+}

package/{src → build}/core/jest/preprocessor/jsPreprocessor.js

@@ -1,9 +1,7 @@
-const babelJest = require('babel-jest');
+"use strict";
 
+const babelJest = require('babel-jest');
 module.exports = babelJest.createTransformer({
-  presets: [
-    require.resolve('@babel/preset-env'),
-    require.resolve('@babel/preset-react')
-  ],
+  presets: [require.resolve('@babel/preset-env'), require.resolve('@babel/preset-react')],
   plugins: [require.resolve('babel-plugin-transform-dynamic-import')]
-});
+});

package/{src → build}/core/jest/runner/jest-runner.js

@@ -1,7 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createJestRunner;
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
+var _rootPath = require("../../../utils/rootPath");
+/* eslint-disable no-unused-vars */
 // import { run } from 'jest';
 
 // function createJestRunner() {
-//   let config = require('../configs/jest.config');
+//   let config  from '../configs/jest.config');
 
 //   let argv = process.argv.slice(2);
 
@@ -9,25 +20,19 @@
 //   run(argv);
 // }
 
-
 // export default createJestRunner;
 
-const { spawn } = require('child_process');
-const path = require('path');
-const { getExecutableBinaryPath } = require('../../../utils/rootPath');
-
-const jestPath = path.resolve(getExecutableBinaryPath('jest'));
+const jestPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('jest'));
 
 // Command and arguments for npx playwright test
 const command = jestPath;
 const args = ['--config', require.resolve('../../../../jest.config.js')];
-
-
 function createJestRunner() {
   // Spawn the child process
 
-  const childProcess = spawn(command, args, { stdio: 'inherit' });
-
+  const childProcess = (0, _child_process.spawn)(command, args, {
+    stdio: 'inherit'
+  });
 
   // Handling the 'exit' event of the child process
   // childProcess.on('exit', (code, signal) => {
@@ -38,7 +43,4 @@ function createJestRunner() {
   // childProcess.on('error', (err) => {
   //   console.error(`Error while spawning child process: ${err.message}`);
   // });
-}
-
-
-module.exports = createJestRunner;
+}

package/build/core/jest/setup/index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+require("@testing-library/jest-dom/extend-expect");

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

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _logger = require("../../../utils/logger");
+var _additionalProfiles = require("../helpers/additionalProfiles");
+var _loginDefaultStepsHelper = require("../helpers/auth/loginDefaultStepsHelper");
+class ActorContext {
+  constructor() {
+    this.actorsObj = {};
+  }
+  async setup(browser, $tags, testInfo, context, page, executionContext) {
+    try {
+      const {
+        profile
+      } = executionContext.actorInfo;
+      this.actorsObj[profile] = {
+        role: profile,
+        browser,
+        context,
+        page,
+        executionContext
+      };
+      const additionalActors = (0, _additionalProfiles.additionProfiles)($tags);
+      await Promise.all(Object.entries(additionalActors).map(async ([role, actorInfo]) => {
+        let context = await browser.newContext();
+        let page = await context.newPage();
+        let ctxTestDetails = {
+          page,
+          $tags,
+          context,
+          ...actorInfo
+        };
+        await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(context, testInfo, ctxTestDetails, actorInfo);
+        this.actorsObj[role] = {
+          role,
+          browser,
+          context,
+          page,
+          executionContext: {
+            actorInfo
+          }
+        };
+      }));
+    } catch (error) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to setup additional actors:`, error);
+      throw error;
+    }
+  }
+  async cleanup() {
+    for (const actor of Object.values(this.actorsObj)) {
+      try {
+        await actor.context.close();
+      } catch (error) {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to close context for actor ${actor.role}:`, error);
+      }
+    }
+  }
+}
+var _default = exports.default = {
+  actorContext: async ({
+    page,
+    context,
+    executionContext,
+    $tags,
+    browser
+  }, use, testInfo) => {
+    const ctxObject = new ActorContext();
+    await ctxObject.setup(browser, $tags, testInfo, context, page, executionContext);
+    await use(ctxObject);
+    await ctxObject.cleanup();
+  }
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = exports.default = {
+  addTags: [async ({
+    $tags
+  }, use, testInfo) => {
+    testInfo.annotations.push({
+      type: 'tags',
+      description: $tags.join(', ')
+    });
+    await use();
+  }, {
+    auto: true
+  }]
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const cacheMap = new Map();
+var _default = exports.default = {
+  // eslint-disable-next-line no-empty-pattern
+  cacheLayer: async ({}, use) => {
+    await use(cacheMap);
+  }
+};

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

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _readConfigFile = require("../readConfigFile");
+const {
+  testSetup
+} = (0, _readConfigFile.generateConfigFromFile)();
+async function performDefaultContextSteps({
+  context
+}) {
+  if (testSetup.context && typeof testSetup.context === 'function') {
+    await testSetup.context({
+      context
+    });
+  }
+}
+var _default = exports.default = {
+  context: async ({
+    context
+  }, use) => {
+    await context.addInitScript(() =>
+    // eslint-disable-next-line no-undef
+    window.localStorage.setItem('isDnBannerHide', true));
+    await performDefaultContextSteps({
+      context
+    });
+    await use(context);
+  }
+};

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _customFixturesHelper = require("../helpers/customFixturesHelper");
+var _default = exports.default = {
+  executionContext: async ({
+    $tags
+  }, use) => {
+    const actorInfo = (0, _customFixturesHelper.getCustomAccountDetails)($tags);
+    await use({
+      actorInfo
+    });
+  }
+};

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

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/* eslint-disable no-undef */
+/* eslint-disable no-param-reassign */
+
+// Note: We are duplicating below method from @zohodesk/i18n. We are not importing it as react package not yet availble in test environment.
+function replaceI18NValuesWithRegex(i18nStr, values) {
+  if (typeof values !== 'undefined') {
+    if (Array.isArray(values)) {
+      for (let i = 0; i < values.length; i++) {
+        i18nStr = i18nStr.replace(new RegExp(`\\{${i}\\}`, 'g'), values[i]);
+      }
+    } else {
+      i18nStr = i18nStr.replace(new RegExp('\\{0\\}', 'g'), values);
+    }
+  }
+  return i18nStr;
+}
+async function isI18NKeyDefined(key) {
+  return new Promise(resolve => {
+    if (typeof window.i18n[key] !== 'undefined') {
+      resolve();
+    }
+  });
+}
+var _default = exports.default = {
+  i18N: async ({
+    page
+  }, use) => {
+    await use(async (key, values) => {
+      await page.waitForFunction(isI18NKeyDefined(key));
+      const i18nValue = await page.evaluate(i18nKey => window.i18n[i18nKey], key);
+      const i18nStr = replaceI18NValuesWithRegex(i18nValue, values);
+      return i18nStr;
+    });
+  }
+};

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

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _page = _interopRequireDefault(require("./page"));
+var _context = _interopRequireDefault(require("./context"));
+var _cacheLayer = _interopRequireDefault(require("./cacheLayer"));
+var _addTags = _interopRequireDefault(require("./addTags"));
+var _i18N = _interopRequireDefault(require("./i18N"));
+var _unauthenticatedPage = _interopRequireDefault(require("./unauthenticatedPage"));
+var _executionContext = _interopRequireDefault(require("./executionContext"));
+var _actorContext = _interopRequireDefault(require("./actorContext"));
+function extractTagsFromTitle(text) {
+  return text.match(/@\w+/g) || [];
+}
+function getBuiltInFixtures(bddMode) {
+  let builtInFixtures = {
+    ..._page.default,
+    ..._actorContext.default,
+    ..._context.default,
+    ..._cacheLayer.default,
+    ..._i18N.default,
+    ..._unauthenticatedPage.default,
+    ..._executionContext.default
+  };
+  if (bddMode) {
+    builtInFixtures = {
+      ...builtInFixtures,
+      ..._addTags.default
+    };
+  } else {
+    builtInFixtures = {
+      ...builtInFixtures,
+      $tags: async ({}, use, testInfo) => {
+        // Extract only the elements after the "@" symbol as tags
+        const tags = testInfo.title ? extractTagsFromTitle(testInfo.title) : [];
+        await use(tags);
+      }
+    };
+  }
+  return builtInFixtures;
+}
+var _default = exports.default = getBuiltInFixtures;

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

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _loginDefaultStepsHelper = require("../helpers/auth/loginDefaultStepsHelper");
+/* eslint-disable global-require */
+var _default = exports.default = {
+  page: async ({
+    context,
+    $tags,
+    page,
+    executionContext
+  }, use, testInfo) => {
+    let testPortalDetails = executionContext.actorInfo;
+    let testDetails = {
+      page,
+      $tags,
+      context,
+      ...testPortalDetails
+    };
+    try {
+      //This block is used to skip the login process if the @unauthenticated tag is added to the script
+      if ($tags.includes('@unauthenticated')) {
+        await context.clearCookies();
+        return;
+      }
+      await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(context, testInfo, testDetails, testPortalDetails);
+    } catch (e) {
+      console.error('Error during page', e);
+    } finally {
+      await (0, _loginDefaultStepsHelper.performDefaultPageSteps)(testDetails);
+      await use(page);
+      await context.close();
+    }
+  }
+};

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = exports.default = {
+  unauthenticatedPage: async ({
+    browser
+  }, use) => {
+    const context = await browser.newContext({
+      storageState: null
+    });
+    const unauthenticatedPage = await context.newPage();
+    await use(unauthenticatedPage);
+    await context.close();
+  }
+};

package/build/core/playwright/clear-caches.js

@@ -0,0 +1,49 @@
+"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 _fileUtils = require("../../utils/fileUtils");
+var _logger = require("../../utils/logger");
+var _readConfigFile = require("./readConfigFile");
+var _checkAuthDirectory = require("./helpers/checkAuthDirectory");
+function deleteAuthFiles(authFilePath) {
+  authFilePath = _path.default.resolve(process.cwd(), authFilePath);
+  const authFileFolder = _path.default.dirname(authFilePath);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting auth files present in ${authFileFolder}`);
+  (0, _fileUtils.deleteFolder)(authFileFolder);
+}
+function deletePlaywrightReport(reportPath) {
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting Playwright report ${reportPath}`);
+  (0, _fileUtils.deleteFolder)(reportPath);
+}
+function deleteGeneratedFeatures() {
+  const featuresGenPath = _path.default.resolve(process.cwd(), 'uat', '.features-gen');
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting generated features at ${featuresGenPath}`);
+  (0, _fileUtils.deleteFolder)(featuresGenPath);
+}
+function deleteLockFiles() {
+  const lockFilePath = (0, _checkAuthDirectory.getLockDirectoryPath)();
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting lock files at ${lockFilePath}`);
+  (0, _fileUtils.deleteFolder)(lockFilePath);
+}
+function clearCaches() {
+  try {
+    const {
+      authFilePath,
+      reportPath
+    } = (0, _readConfigFile.generateConfigFromFile)();
+    deleteAuthFiles(authFilePath);
+    deletePlaywrightReport(reportPath);
+    deleteGeneratedFeatures();
+    deleteLockFiles();
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Caches Cleared. Now you can try running npm run uat');
+  } catch (err) {
+    _logger.Logger.error(err);
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Error While clearing cookies. Try manually delete folder uat/playwright and uat/playwright-report');
+  }
+}
+var _default = exports.default = clearCaches;

package/build/core/playwright/codegen.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateCodegen;
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../utils/logger");
+var _rootPath = require("../../utils/rootPath");
+function generateCodegen() {
+  const domainUrl = process.argv.slice(3);
+  const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
+  const command = playwrightPath;
+  const args = ['codegen'].concat(domainUrl);
+  const childProcess = (0, _child_process.spawn)(command, args, {
+    stdio: 'inherit'
+  });
+  childProcess.on('error', error => {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error);
+  });
+  childProcess.on('exit', (code, signal) => {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Child Process Exited with Code ${code} and Signal ${signal}`);
+    process.exit();
+  });
+  process.on('exit', () => {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Terminating Playwright Process...');
+    //childProcess.kill();
+    return;
+  });
+  process.on('SIGINT', () => {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Cleaning up...');
+    //childProcess.kill();
+    process.exit();
+  });
+}
+
+// Another way to record. Below way will load the url in autheticated state if present
+// function generateCodegen() {
+//   (async () => {
+//     // Make sure to run headed.
+//     const browser = await chromium.launch({ headless: false });
+
+//     // Setup context however you like.
+//     const context = await browser.newContext({ storageState: path.resolve(process.cwd(), 'uat', 'playwright/.auth/user.json') });
+//     await context.route('**/*', route => route.continue());
+
+//     // Pause the page, and start recording manually.
+//     const page = await context.newPage();
+//     console.log(userArgs.join(''));
+//     await page.goto(`https://${userArgs.join('')}`);
+//     await page.pause();
+//   })();
+// }

package/build/core/playwright/configuration/Configuration.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _ConfigurationHelper = require("./ConfigurationHelper");
+class Configuration {
+  properties = {};
+  constructor(props) {
+    this.properties = props;
+  }
+  add(key, value) {
+    this.properties[key] = value;
+  }
+  addAll(newConfig) {
+    this.properties = (0, _ConfigurationHelper.combineConfiguration)(this.properties, newConfig.getAll());
+  }
+  get(key) {
+    return this.properties[key];
+  }
+  getAll() {
+    return this.properties;
+  }
+  delete(key) {
+    delete this.properties[key];
+  }
+}
+module.exports = Configuration;

package/build/core/playwright/configuration/ConfigurationHelper.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.combineConfiguration = combineConfiguration;
+exports.getApplicationConfig = getApplicationConfig;
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../../utils/logger");
+var _configFileNameProvider = require("../helpers/configFileNameProvider");
+var _mergeObjects = require("../helpers/mergeObjects");
+var _fs = require("fs");
+const Configuration = require("./Configuration");
+function combineConfiguration(defaultConfig, userConfiguration) {
+  let configurationObj = {};
+  Object.keys(userConfiguration).forEach(configKey => {
+    let configValue = userConfiguration[configKey];
+    if (configValue !== null && configValue !== undefined) {
+      configurationObj[configKey] = configValue;
+    } else if (defaultConfig[configKey]) {
+      configurationObj[configKey] = defaultConfig[configKey];
+    } else {
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `key - ${configKey} is not yet supported in uat configuration. This will not be used while creating playwright configuration`);
+    }
+  });
+  return (0, _mergeObjects.mergeObjects)(defaultConfig, configurationObj);
+}
+function getApplicationConfig(mode) {
+  let filePath = "";
+  try {
+    filePath = _path.default.resolve(process.cwd(), (0, _configFileNameProvider.getUATFileName)(mode));
+    if (!(0, _fs.existsSync)(filePath)) {
+      throw new Error("Exception while getting the uat file from the application - " + filePath);
+    }
+    const config = require(filePath);
+    return config;
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Founded Path - ${filePath} Application config file not Exist ...`);
+    _logger.Logger.error(err);
+    return {};
+  }
+}

package/build/core/playwright/configuration/UserArgs.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _cliArgsToObject = require("../../../utils/cliArgsToObject");
+class UserArgs {
+  static parseToObject(config) {
+    return (0, _cliArgsToObject.cliArgsToObject)(config);
+  }
+  static parseToArgs(object) {
+    return (0, _cliArgsToObject.objectToCliArgs)(object);
+  }
+}
+module.exports = UserArgs;