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

package/build/common/data-generator/steps/DataGenerator.spec.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _testinglibrary = require("@zohodesk/testinglibrary");
+var _DataGenerator = _interopRequireDefault(require("@zohodesk/testinglibrary/DataGenerator"));
+var _DataGeneratorStepsHelper = require("./DataGeneratorStepsHelper");
+const {
+  Given
+} = (0, _testinglibrary.createBdd)();
+const dataGenerator = new _DataGenerator.default();
+Given('generate a {string} entity {string} with generator {string}', async ({
+  page,
+  context,
+  i18N,
+  cacheLayer,
+  executionContext
+}, module, entityName, generatorName, dataTable) => {
+  await (0, _DataGeneratorStepsHelper.generateAndCacheTestData)(executionContext, "template", generatorName, dataTable, cacheLayer, entityName);
+});
+Given('generate a {string} entity {string} with API {string}', async ({
+  page,
+  context,
+  i18N,
+  cacheLayer,
+  executionContext
+}, module, entityName, operationId, dataTable) => {
+  await (0, _DataGeneratorStepsHelper.generateAndCacheTestData)(executionContext, "API", operationId, dataTable, cacheLayer, entityName);
+});
+Given('generate a {string} entity {string} with generator {string} using {string} profile', async ({
+  page,
+  context,
+  i18N,
+  cacheLayer,
+  executionContext
+}, module, entityName, generatorName, profile, dataTable) => {
+  await (0, _DataGeneratorStepsHelper.generateAndCacheTestData)(executionContext, "template", generatorName, dataTable, cacheLayer, entityName, profile);
+});
+Given('generate a {string} entity {string} with API {string} using {string} profile', async ({
+  page,
+  context,
+  i18N,
+  cacheLayer,
+  executionContext
+}, module, entityName, operationId, profile, dataTable) => {
+  await (0, _DataGeneratorStepsHelper.generateAndCacheTestData)(executionContext, "API", operationId, dataTable, cacheLayer, entityName, profile);
+});

package/build/common/data-generator/steps/DataGeneratorStepsHelper.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateAndCacheTestData = generateAndCacheTestData;
+var _testinglibrary = require("@zohodesk/testinglibrary");
+var _DataGenerator = _interopRequireDefault(require("@zohodesk/testinglibrary/DataGenerator"));
+const dataGenerator = new _DataGenerator.default();
+async function generateAndCacheTestData(executionContext, type, identifier, dataTable, cacheLayer, entityName, profile = null) {
+  let actorInfo;
+  const testInfo = _testinglibrary.test.info();
+  const scenarioName = testInfo.title.split('/').pop() || 'Unknown Scenario';
+  if (profile) {
+    actorInfo = await dataGenerator.getDataGenUserExecutionContext(executionContext.actorInfo.edition, profile);
+  } else {
+    actorInfo = executionContext.actorInfo;
+  }
+  const generatedData = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : []);
+  await cacheLayer.set(entityName, generatedData.data);
+}

package/build/core/dataGenerator/DataGenerator.js

@@ -0,0 +1,94 @@
+"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");
+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) {
+      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 Error(`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 dataGeneratorConfig = actorInfo['data-generator'] || {};
+  const apiPayload = {
+    scenario_name: scenarioName,
+    data_generation_templates: processedGenerators,
+    ...dataGeneratorConfig
+  };
+  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/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/build/core/playwright/runner/SpawnRunner.js

@@ -8,6 +8,7 @@ var _logger = require("../../../utils/logger");
 var _child_process = require("child_process");
 var _RunnerHelper = _interopRequireDefault(require("./RunnerHelper"));
 var _Runner = _interopRequireDefault(require("./Runner"));
+var _commonUtils = require("../../../utils/commonUtils");
 class SpawnRunner extends _Runner.default {
   constructor(runnerObj) {
     super(runnerObj);
@@ -30,6 +31,8 @@ class SpawnRunner extends _Runner.default {
     });
   }
   runPreprocessing() {
+    //This below functoin is called to copy the data generator spec files to the current project
+    (0, _commonUtils.copyCommonSpecs)();
     const {
       tagArgs
     } = this.runnerObj;

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

@@ -44,12 +44,6 @@ const testDir = (0, _configUtils.getTestDir)(bddMode, {
   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,
   video,
@@ -77,14 +71,23 @@ function getPlaywrightConfig() {
     storageState: isAuthMode ? (0, _readConfigFile.getAuthFilePath)(_path.default.resolve(process.cwd(), authFilePath)) : {}
   };
   const dependencies = isAuthMode ? ['setup'] : [];
-  const smokeTestProject = {
-    name: 'smokeTest',
-    testDir: smokeTestDir,
-    use: {
-      ...commonConfig
-    },
-    dependencies: dependencies
-  };
+  const smokeTestProject = isSmokeTest ? smokeTestConfig() : [];
+  function smokeTestConfig() {
+    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', 'smokeTest')
+    });
+    return [{
+      name: 'smokeTest',
+      testDir: smokeTestDir,
+      use: {
+        ...commonConfig
+      },
+      dependencies: dependencies
+    }];
+  }
   const playwrightConfig = {
     testDir,
     globalTimeout: globalTimeout || 3600000,
@@ -101,11 +104,11 @@ function getPlaywrightConfig() {
       testMatch: /.*\.setup\.js/,
       testDir: _path.default.join(process.cwd(), 'uat'),
       teardown: 'cleanup'
-    }, ...(isSmokeTest ? [smokeTestProject] : []), {
+    }, ...smokeTestProject, {
       name: 'cleanup',
       testMatch: /.*\.teardown\.js/,
       testDir: _path.default.join(process.cwd(), 'uat')
-    }, ...projects] : [...projects, ...(isSmokeTest ? [smokeTestProject] : [])],
+    }, ...projects] : [...projects, ...smokeTestProject],
     ...uatConfig
   };
   return playwrightConfig;

package/build/utils/commonUtils.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.copyCommonSpecs = copyCommonSpecs;
+var _fileUtils = require("./fileUtils");
+var _path = _interopRequireDefault(require("path"));
+function copyCommonSpecs() {
+  const libraryPath = require.resolve("@zohodesk/testinglibrary");
+  // libraryPath will be build/index.js to go to the common specs we need to go one level up
+  const commonSpecPath = _path.default.resolve(libraryPath, '../', 'common');
+  const destDirectory = _path.default.resolve(process.cwd(), 'uat', 'modules', '.testingLib-common');
+  (0, _fileUtils.deleteFolder)(destDirectory);
+  (0, _fileUtils.copyDirectory)(commonSpecPath, destDirectory);
+}

package/build/utils/fileUtils.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.checkIfFileExists = checkIfFileExists;
 exports.checkIfFolderExistsWithPattern = checkIfFolderExistsWithPattern;
+exports.copyDirectory = copyDirectory;
 exports.deleteFile = deleteFile;
 exports.deleteFolder = deleteFolder;
 exports.readFileContents = readFileContents;
@@ -86,4 +87,23 @@ function checkIfFolderExistsWithPattern(folderPath) {
     _logger.Logger.error(err);
     return false;
   }
+}
+function copyDirectory(src, dest) {
+  if (!_fs.default.existsSync(dest)) {
+    _fs.default.mkdirSync(dest, {
+      recursive: true
+    });
+  }
+  const entries = _fs.default.readdirSync(src, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const srcPath = _path.default.join(src, entry.name);
+    const destPath = _path.default.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      _fs.default.copyFileSync(srcPath, destPath);
+    }
+  }
 }