@zohodesk/testinglibrary 0.0.5 → 0.0.6-n20-experimental

package/build/core/dataGenerator/DataGenerator.js

@@ -0,0 +1,108 @@
+"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 _fs = _interopRequireDefault(require("fs"));
+var _logger = require("../../utils/logger");
+var _DataGeneratorHelper = require("./DataGeneratorHelper");
+var _helpers = require("@zohodesk/testinglibrary/helpers");
+var _DataGeneratorError = require("./DataGeneratorError");
+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 _DataGenerator_brand = /*#__PURE__*/new WeakSet();
+class DataGenerator {
+  constructor() {
+    _classPrivateMethodInitSpec(this, _DataGenerator_brand);
+  }
+  async generate(testInfo, actorInfo, generatorType, generatorName, scenarioName, dataTable) {
+    try {
+      let generators;
+      if (generatorType === 'API') {
+        generators = await _assertClassBrand(_DataGenerator_brand, this, _generateAPIGenerator).call(this, generatorName);
+      } else {
+        generators = await _assertClassBrand(_DataGenerator_brand, this, _getGenerator).call(this, testInfo, generatorName);
+      }
+      const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
+      const apiPayload = await _assertClassBrand(_DataGenerator_brand, this, _constructApiPayload).call(this, scenarioName, processedGenerators, actorInfo);
+      const response = await (0, _DataGeneratorHelper.makeRequest)(process.env.DG_SERVICE_DOMAIN + process.env.DG_SERVICE_API_PATH, apiPayload);
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Generated response for the generator: ${generatorName} for scenario: ${scenarioName}, Response: ${JSON.stringify(response)}`);
+      return response;
+    } catch (error) {
+      if (error instanceof _DataGeneratorError.DataGeneratorError) {
+        console.error(error.getMessage());
+        console.error("Stack trace:", error.stack);
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error.getMessage());
+      } else {
+        console.error("Error Type:", error.constructor.name);
+        console.error("Error Message:", error.message);
+        console.error("Stack trace:", error.stack);
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `${error.constructor.name} - Message: ${error.message}`);
+      }
+      console.error('Data Generation failed for the generator: ', generatorName, "\n\nError response :", error);
+      throw error;
+    }
+  }
+  async getDataGenUserExecutionContext(edition, profile) {
+    try {
+      const dataGenUserDetails = await (0, _helpers.getUserForSelectedEditionAndProfile)(edition, profile);
+      return dataGenUserDetails;
+    } catch (error) {
+      console.error('Error occurred while fetching data generation user details: ', error);
+      throw error;
+    }
+  }
+}
+async function _getGenerator(testInfo, generatorName) {
+  let generator = null;
+  let generatorFilePath = await (0, _DataGeneratorHelper.getGeneratorFilePath)(testInfo.file);
+  generatorFilePath = _path.default.join(generatorFilePath, "../../data-generators/generators.json");
+  if (_fs.default.existsSync(generatorFilePath)) {
+    const data = _fs.default.readFileSync(generatorFilePath, 'utf8');
+    const generatorObj = JSON.parse(data);
+    if (generatorName || generatorObj.generators) {
+      generator = generatorObj.generators[generatorName] || null;
+    }
+  }
+  if (!generator) {
+    throw new _DataGeneratorError.GeneratorError(`Generator "${generatorName}" could not be found in the path located at "${generatorFilePath}"`);
+  }
+  return generator;
+}
+async function _generateAPIGenerator(operationId) {
+  return [{
+    type: "dynamic",
+    generatorOperationId: operationId,
+    dataPath: "$.response.body:$",
+    name: operationId
+  }];
+}
+async function _constructApiPayload(scenarioName, processedGenerators, actorInfo) {
+  const dataGeneratorObj = actorInfo['data-generator'];
+  if (!dataGeneratorObj) {
+    throw new _DataGeneratorError.DataGeneratorConfigurationError(`Data Generator configuration is missing for the profile: ${actorInfo['profile']}`);
+  }
+  const apiPayload = {
+    scenario_name: scenarioName,
+    data_generation_templates: processedGenerators,
+    ...dataGeneratorObj
+  };
+  const account = apiPayload.account;
+  if (account) {
+    account.email = actorInfo.email;
+    account.password = actorInfo.password;
+  }
+  const environmentDetails = apiPayload.environmentDetails || {};
+  if (environmentDetails) {
+    environmentDetails.iam_url = process.env.DG_IAM_DOMAIN;
+    const domainUrl = new URL(process.env.domain);
+    environmentDetails.host = domainUrl.origin;
+  }
+  apiPayload.environmentDetails = environmentDetails;
+  return apiPayload;
+}
+var _default = exports.default = DataGenerator;

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');
-
-module.exports = babelJest.createTransformer({
-  presets: [
-    require.resolve('@babel/preset-env'),
-    require.resolve('@babel/preset-react')
-  ],
-  plugins: [require.resolve('babel-plugin-transform-dynamic-import')]
-});
+"use strict";
+
+const babelJest = require('babel-jest');
+module.exports = babelJest.createTransformer({
+  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,44 +1,46 @@
-// import { run } from 'jest';
-
-// function createJestRunner() {
-//   let config = require('../configs/jest.config');
-
-//   let argv = process.argv.slice(2);
-
-//   argv.push('--config', JSON.stringify(config(folder)), '--no-cache');
-//   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'));
-
-// 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' });
-
-
-  // Handling the 'exit' event of the child process
-  // childProcess.on('exit', (code, signal) => {
-  //   console.log(`Child process exited with code ${code} and signal ${signal}`);
-  // });
-
-  // // Handling any error that occurs while spawning the child process
-  // childProcess.on('error', (err) => {
-  //   console.error(`Error while spawning child process: ${err.message}`);
-  // });
-}
-
-
-module.exports = createJestRunner;
+"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  from '../configs/jest.config');
+
+//   let argv = process.argv.slice(2);
+
+//   argv.push('--config', JSON.stringify(config(folder)), '--no-cache');
+//   run(argv);
+// }
+
+// export default createJestRunner;
+
+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 = (0, _child_process.spawn)(command, args, {
+    stdio: 'inherit'
+  });
+
+  // Handling the 'exit' event of the child process
+  // childProcess.on('exit', (code, signal) => {
+  //   console.log(`Child process exited with code ${code} and signal ${signal}`);
+  // });
+
+  // // Handling any error that occurs while spawning the child process
+  // childProcess.on('error', (err) => {
+  //   console.error(`Error while spawning child process: ${err.message}`);
+  // });
+}

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

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

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();
+  }
+};