@zohodesk/testinglibrary 0.0.58-n20-experimental → 0.0.60-n20-experimental

package/README.md

@@ -17,14 +17,6 @@
 
      - npm run report
 
-### v0.0.44-n20-experimental - 23-03-2026
-
-#### Enhancement
-- DataGenerator now walks up the directory tree to discover data-generators folders
-- Supports multiple JSON files in data-generators directory (no longer hardcoded to generators.json)
-- Removed hardcoded folder name dependencies for flexible generator file placement
-- Added duplicate generator name validation to `ZDTestingFramework validate` command
-
 ### v4.1.1/v3.3.0 - 28-01-2026
 
 #### Features

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

@@ -1,5 +1,5 @@
 import { createBdd , test } from '@zohodesk/testinglibrary';
-import { generateAndCacheTestData } from './DataGeneratorStepsHelper';
+import { generateAndCacheTestData } from './DataGeneratorStepsHelper';  
 
 const { Given } = createBdd();
 

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

@@ -1,6 +1,6 @@
 import { test } from '@zohodesk/testinglibrary';
 import DataGenerator from '@zohodesk/testinglibrary/DataGenerator';
-import {getUserForSelectedEditionAndProfile, getListOfActors} from '@zohodesk/testinglibrary/helpers'
+ import {getUserForSelectedEditionAndProfile} from '@zohodesk/testinglibrary/helpers'
 
 const dataGenerator = new DataGenerator();
 
@@ -10,27 +10,12 @@ export async function generateAndCacheTestData(executionContext, type, identifie
     const scenarioName = testInfo.title.split('/').pop() || 'Unknown Scenario';
 
     if (profile) {
-        // Explicit profile requested — resolve that profile's credentials
         const { edition, orgName: portal, beta } = executionContext.actorInfo;
         actorInfo = await getUserForSelectedEditionAndProfile(edition, profile, beta, portal);
     } else {
-        // Default — use current actor, fall back to org-level data-generator if profile has none
         actorInfo = executionContext.actorInfo;
-        if (!actorInfo['data-generator']) {
-            const { edition, orgName: portal, beta } = actorInfo;
-            const actorsData = getListOfActors(beta);
-            const portalData = actorsData.editions[edition]?.find(e => e.orgName === portal);
-            if (portalData?.['data-generator']) {
-                actorInfo = { ...actorInfo, 'data-generator': portalData['data-generator'] };
-            }
-        }
-    }
-
-    const { response, generators } = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : [], cacheLayer);
-    if (cacheLayer._trackForCleanup) {
-        cacheLayer._trackForCleanup(entityName, response.data, generators, actorInfo, response.logs, identifier);
-    } else {
-        cacheLayer.set(entityName, response.data);
-        cacheLayer.set(`${entityName}_logs`, response.logs);
     }
+    
+    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

@@ -8,140 +8,61 @@ exports.default = void 0;
 var _path = _interopRequireDefault(require("path"));
 var _fs = _interopRequireDefault(require("fs"));
 var _logger = require("../../utils/logger");
-var _timeFormat = require("../../utils/timeFormat");
 var _DataGeneratorHelper = require("./DataGeneratorHelper");
-var _datePlaceholders = require("../../utils/datePlaceholders");
+var _helpers = require("@zohodesk/testinglibrary/helpers");
 var _DataGeneratorError = require("./DataGeneratorError");
-var _readConfigFile = require("../playwright/readConfigFile");
-var _configConstants = _interopRequireDefault(require("../playwright/constants/configConstants"));
-var _ConfigurationHelper = require("../playwright/configuration/ConfigurationHelper");
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
-function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
-function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
-function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
 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 _generatorIndex = /*#__PURE__*/new WeakMap();
 var _DataGenerator_brand = /*#__PURE__*/new WeakSet();
 class DataGenerator {
   constructor() {
     _classPrivateMethodInitSpec(this, _DataGenerator_brand);
-    _classPrivateFieldInitSpec(this, _generatorIndex, null);
   }
-  async generate(testInfo, actorInfo, generatorType, generatorName, scenarioName, dataTable, cacheLayer) {
-    const startMs = Date.now();
-    const startLabel = (0, _timeFormat.formatTimestamp)(startMs);
-    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Data generation started   | generator="${generatorName}" | scenario="${scenarioName}" | startTime=${startLabel}`);
+  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, generatorName);
+        generators = await _assertClassBrand(_DataGenerator_brand, this, _getGenerator).call(this, testInfo, generatorName);
       }
-
-      // Clone to prevent cross-test mutation of the cached generator index.
-      const generatorsCopy = generators.map(g => ({
-        ...g,
-        params: g.params ? {
-          ...g.params
-        } : undefined
-      }));
-      (0, _datePlaceholders.resolveDatePlaceholdersInGenerators)(generatorsCopy);
-      const dateResolvedTable = (0, _datePlaceholders.resolveDatePlaceholders)(dataTable);
-      const resolvedDataTable = await (0, _DataGeneratorHelper.resolveCacheReferences)(dateResolvedTable, cacheLayer);
-      const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generatorsCopy, resolvedDataTable);
+      const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
       const apiPayload = await _assertClassBrand(_DataGenerator_brand, this, _constructApiPayload).call(this, scenarioName, processedGenerators, actorInfo);
-      const featureFlags = process.env.featureflags ? process.env.featureflags : '';
-      const headers = {
-        'Content-Type': 'application/json',
-        'featureflags': featureFlags
-      };
-      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Making request headers:', headers);
-      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Payload:  ${JSON.stringify(apiPayload, null, 4)}`);
-      const response = await (0, _DataGeneratorHelper.makeRequest)(process.env.DG_SERVICE_DOMAIN + process.env.DG_SERVICE_API_PATH, apiPayload, headers);
-      const endMs = Date.now();
-      const endLabel = (0, _timeFormat.formatTimestamp)(endMs);
-      const totalLabel = (0, _timeFormat.formatDuration)(endMs - startMs);
-      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Generated response for the generator: ${generatorName} for scenario: ${scenarioName}, Response: ${JSON.stringify(response, null, 4)}`);
-      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Data generation completed | generator="${generatorName}" | scenario="${scenarioName}" | startTime=${startLabel} | endTime=${endLabel} | totalTime=${totalLabel}`);
-      return {
-        response,
-        generators
-      };
+      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) {
-      const endMs = Date.now();
-      const endLabel = (0, _timeFormat.formatTimestamp)(endMs);
-      const totalLabel = (0, _timeFormat.formatDuration)(endMs - startMs);
-      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Data generation failed    | generator="${generatorName}" | scenario="${scenarioName}" | startTime=${startLabel} | endTime=${endLabel} | totalTime=${totalLabel}`);
       if (error instanceof _DataGeneratorError.DataGeneratorError) {
-        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error.getMessage());
-        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, "Stack trace:", error.stack);
+        console.error(error.getMessage());
+        console.error("Stack trace:", error.stack);
         _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error.getMessage());
       } else {
-        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, "Error Type:", error.constructor.name);
-        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, "Error Message:", error.message);
-        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, "Stack trace:", error.stack);
+        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}`);
       }
-      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Data Generation failed for the generator: ${generatorName}\n\nError response: ${error}`);
+      console.error('Data Generation failed for the generator: ', generatorName, "\n\nError response :", error);
       throw error;
     }
   }
 }
-function _matchesPattern(filename, pattern) {
-  const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
-  return regex.test(filename);
-}
-function _scanDir(dir, index, pattern) {
-  const entries = _fs.default.readdirSync(dir, {
-    withFileTypes: true
-  });
-  for (const entry of entries) {
-    const fullPath = _path.default.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      _assertClassBrand(_DataGenerator_brand, this, _scanDir).call(this, fullPath, index, pattern);
-    } else if (_assertClassBrand(_DataGenerator_brand, this, _matchesPattern).call(this, entry.name, pattern)) {
-      try {
-        const data = _fs.default.readFileSync(fullPath, 'utf8');
-        const obj = JSON.parse(data);
-        if (obj.generators) {
-          for (const [name, config] of Object.entries(obj.generators)) {
-            if (!index.has(name)) {
-              index.set(name, config);
-            }
-          }
-        }
-      } catch (err) {
-        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to parse generator file: ${fullPath} - ${err.message}`);
-      }
-    }
-  }
-}
-function _buildIndex(modulesRoot, pattern) {
-  const index = new Map();
-  _assertClassBrand(_DataGenerator_brand, this, _scanDir).call(this, modulesRoot, index, pattern);
-  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Generator index built: ${index.size} generators found`);
-  return index;
-}
-function _getModulesRoot() {
-  const stage = (0, _ConfigurationHelper.getRunStage)();
-  return _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'modules');
-}
-async function _getGenerator(generatorName) {
-  if (!_classPrivateFieldGet(_generatorIndex, this)) {
-    const modulesRoot = _assertClassBrand(_DataGenerator_brand, this, _getModulesRoot).call(this);
-    const {
-      generatorFilePattern: pattern = '*.generators.json'
-    } = (0, _readConfigFile.generateConfigFromFile)();
-    if (modulesRoot) {
-      _classPrivateFieldSet(_generatorIndex, this, _assertClassBrand(_DataGenerator_brand, this, _buildIndex).call(this, modulesRoot, pattern));
+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 (_classPrivateFieldGet(_generatorIndex, this) && _classPrivateFieldGet(_generatorIndex, this).has(generatorName)) {
-    return _classPrivateFieldGet(_generatorIndex, this).get(generatorName);
+  if (!generator) {
+    throw new _DataGeneratorError.GeneratorError(`Generator "${generatorName}" could not be found in the path located at "${generatorFilePath}"`);
   }
-  throw new _DataGeneratorError.GeneratorError(`Generator "${generatorName}" could not be found in any generator file`);
+  return generator;
 }
 async function _generateAPIGenerator(operationId) {
   return [{

package/build/core/dataGenerator/DataGeneratorHelper.js

@@ -6,54 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.getGeneratorFilePath = getGeneratorFilePath;
 exports.makeRequest = makeRequest;
 exports.processGenerator = processGenerator;
-exports.resolveCacheReferences = resolveCacheReferences;
-// Matches a single ${EntityName} or ${EntityName.field.path} cell value.
-// Anchored — values like "foo ${E1.id} bar" are left as-is on purpose.
-const CACHE_REF = /^\$\{([A-Za-z_][\w-]*)(?:\.([A-Za-z_][\w.-]*))?\}$/;
-
-// Resolve ${EntityName} / ${EntityName.field.path} references in a dataTable
-// against the cacheLayer. Lets a later `generate ...` step reference an entity
-// that an earlier step cached (e.g. ${E1.id} for an event created in a prior
-// generator invocation).
-async function resolveCacheReferences(rows, cacheLayer) {
-  if (!rows || !rows.length || !cacheLayer || typeof cacheLayer.get !== 'function') {
-    return rows || [];
-  }
-  const out = [];
-  for (const row of rows) {
-    const resolved = {};
-    for (const [key, value] of Object.entries(row)) {
-      const match = typeof value === 'string' ? value.match(CACHE_REF) : null;
-      if (!match) {
-        resolved[key] = value;
-        continue;
-      }
-      const [, entityName, fieldPath] = match;
-      const entity = await cacheLayer.get(entityName);
-      if (entity === undefined || entity === null) {
-        throw new Error(`DataGenerator: ${value} references entity "${entityName}" which is not in the cache.`);
-      }
-      if (!fieldPath) {
-        resolved[key] = entity;
-        continue;
-      }
-      let acc = entity;
-      for (const part of fieldPath.split('.')) {
-        if (acc === undefined || acc === null) {
-          break;
-        }
-        acc = acc[part];
-      }
-      if (acc === undefined) {
-        throw new Error(`DataGenerator: ${value} resolved to undefined (entity "${entityName}" has no path "${fieldPath}").`);
-      }
-      resolved[key] = acc;
-    }
-    out.push(resolved);
-  }
-  return out;
-}
-
 //Create payload for the generators
 async function processGenerator(generators, dataTable) {
   if (!dataTable) {
@@ -77,12 +29,12 @@ async function processGenerator(generators, dataTable) {
     return generator;
   });
 }
-async function makeRequest(url, payload, headers = {
-  'Content-Type': 'application/json'
-}) {
+async function makeRequest(url, payload) {
   const response = await fetch(url, {
     method: 'POST',
-    headers: headers,
+    headers: {
+      'Content-Type': 'application/json'
+    },
     body: JSON.stringify(payload)
   });
   if (!response.ok) {

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

@@ -1,208 +1,13 @@
 "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 _timeFormat = require("../../../utils/timeFormat");
-var _DataGeneratorHelper = require("../../dataGenerator/DataGeneratorHelper");
-var _readConfigFile = require("../readConfigFile");
-var _jsonpath = _interopRequireDefault(require("jsonpath"));
-let cleanupRegistry = null;
-function getModulesRoot() {
-  const configConstants = require('../constants/configConstants');
-  const {
-    getRunStage
-  } = require('../configuration/ConfigurationHelper');
-  const stage = getRunStage();
-  return _path.default.join(process.cwd(), configConstants.TEST_SLICE_FOLDER, stage, 'modules');
-}
-function buildCleanupRegistry() {
-  const modulesRoot = getModulesRoot();
-  const registry = {};
-  if (!_fs.default.existsSync(modulesRoot)) return registry;
-  scanDir(modulesRoot, registry);
-  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup registry built: ${Object.keys(registry).length} generator chains from ${modulesRoot}`);
-  return registry;
-}
-function scanDir(dir, registry) {
-  const entries = _fs.default.readdirSync(dir, {
-    withFileTypes: true
-  });
-  for (const entry of entries) {
-    const fullPath = _path.default.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      scanDir(fullPath, registry);
-    } else if (entry.name.endsWith('.cleanup.js')) {
-      try {
-        const cleanupModule = require(fullPath);
-        for (const [generatorName, chain] of Object.entries(cleanupModule)) {
-          if (registry[generatorName]) {
-            throw new Error(`Duplicate cleanup chain for generator "${generatorName}" in ${fullPath}. ` + `Each generator must have exactly one cleanup chain.`);
-          }
-          registry[generatorName] = chain;
-        }
-      } catch (err) {
-        if (err.message.includes('Duplicate cleanup chain')) {
-          throw err;
-        }
-        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to load cleanup file: ${fullPath} - ${err.message}`);
-      }
-    }
-  }
-}
-function extractId(data, idPath) {
-  const result = _jsonpath.default.query(data, idPath);
-  if (result.length === 0) {
-    throw new Error(`Could not extract ID using path "${idPath}"`);
-  }
-  return result[0];
-}
-function parseLogBody(stepLog) {
-  var _stepLog$response;
-  if (!(stepLog !== null && stepLog !== void 0 && (_stepLog$response = stepLog.response) !== null && _stepLog$response !== void 0 && _stepLog$response.body)) return null;
-  const body = stepLog.response.body;
-  return typeof body === 'string' ? JSON.parse(body) : body;
-}
-async function cleanupViaOAS(config, entityId, actorInfo) {
-  const dataGeneratorObj = actorInfo['data-generator'];
-  if (!dataGeneratorObj) {
-    throw new Error('No data-generator config available for cleanup');
-  }
-  const payload = {
-    scenario_name: 'cleanup',
-    data_generation_templates: [{
-      type: 'dynamic',
-      generatorOperationId: config.operationId,
-      dataPath: '$.response.body:$',
-      name: config.operationId,
-      params: {
-        [config.paramName || 'id']: String(entityId)
-      }
-    }],
-    ...dataGeneratorObj
-  };
-  if (payload.account) {
-    payload.account.email = actorInfo.email;
-    payload.account.password = actorInfo.password;
-  }
-  const environmentDetails = payload.environmentDetails || {};
-  environmentDetails.iam_url = process.env.DG_IAM_DOMAIN;
-  environmentDetails.host = new URL(process.env.domain).origin;
-  payload.environmentDetails = environmentDetails;
-  const response = await (0, _DataGeneratorHelper.makeRequest)(process.env.DG_SERVICE_DOMAIN + process.env.DG_SERVICE_API_PATH, payload);
-  return response;
-}
-async function cleanupViaAPI(config, entityId) {
-  const url = `${new URL(process.env.domain).origin}${config.apiPath.replace('{id}', entityId)}`;
-  const options = {
-    method: config.method,
-    headers: {
-      'Content-Type': 'application/json'
-    }
-  };
-  if (config.body) {
-    options.body = JSON.stringify(config.body);
-  }
-  const response = await fetch(url, options);
-  const responseBody = await response.text();
-  if (!response.ok) {
-    throw new Error(`${config.method} ${config.apiPath} - status: ${response.status}, body: ${responseBody}`);
-  }
-  return {
-    status: response.status,
-    body: responseBody
-  };
-}
+const cacheMap = new Map();
 var _default = exports.default = {
   // eslint-disable-next-line no-empty-pattern
   cacheLayer: async ({}, use) => {
-    const cache = new Map();
-    const cleanupEntries = [];
-    cache._trackForCleanup = (entityName, data, generators, actorInfo, logs, generatorName) => {
-      cache.set(entityName, data);
-      cache.set(`${entityName}_logs`, logs);
-      cleanupEntries.push({
-        entityName,
-        data,
-        generators,
-        actorInfo,
-        logs: logs || [],
-        generatorName
-      });
-    };
-    await use(cache);
-
-    // TEARDOWN — runs after scenario ends (pass or fail)
-    const {
-      autoCleanup = true
-    } = (0, _readConfigFile.generateConfigFromFile)();
-    if (!autoCleanup || cleanupEntries.length === 0) {
-      cache.clear();
-      return;
-    }
-    if (!cleanupRegistry) {
-      cleanupRegistry = buildCleanupRegistry();
-    }
-    const cleanupStartMs = Date.now();
-    const cleanupStartLabel = (0, _timeFormat.formatTimestamp)(cleanupStartMs);
-    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup started   | entities=${cleanupEntries.length} | startTime=${cleanupStartLabel}`);
-    let cleaned = 0;
-    let skipped = 0;
-    let failed = 0;
-    for (const entry of [...cleanupEntries].reverse()) {
-      const cleanupChain = cleanupRegistry[entry.generatorName];
-      if (!cleanupChain) {
-        _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup: no chain for generator "${entry.generatorName}" — skipping`);
-        skipped++;
-        continue;
-      }
-      const entityStartMs = Date.now();
-      const entityStartLabel = (0, _timeFormat.formatTimestamp)(entityStartMs);
-      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup entity started   | entity="${entry.entityName}" | generator="${entry.generatorName}" | steps=${cleanupChain.length} | startTime=${entityStartLabel}`);
-      for (const cleanupStep of cleanupChain) {
-        const stepStartMs = Date.now();
-        const stepStartLabel = (0, _timeFormat.formatTimestamp)(stepStartMs);
-        const actionDesc = cleanupStep.operationId || `${cleanupStep.method} ${cleanupStep.apiPath}`;
-        try {
-          // Find the step's response from logs by matching operationId
-          const stepLog = entry.logs.find(log => log.generationOperationId === cleanupStep.operationId || log.name === cleanupStep.operationId);
-          const stepData = parseLogBody(stepLog) || entry.data;
-          const entityId = extractId(stepData, cleanupStep.idPath);
-          _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup step started     | [${cleanupStep.type}] ${actionDesc} (id: ${entityId}) | startTime=${stepStartLabel}`);
-          let cleanupResponse;
-          if (cleanupStep.type === 'oas') {
-            cleanupResponse = await cleanupViaOAS(cleanupStep, entityId, entry.actorInfo);
-          } else if (cleanupStep.type === 'api') {
-            cleanupResponse = await cleanupViaAPI(cleanupStep, entityId);
-          }
-          cleaned++;
-          const stepEndMs = Date.now();
-          const stepEndLabel = (0, _timeFormat.formatTimestamp)(stepEndMs);
-          const stepTotalLabel = (0, _timeFormat.formatDuration)(stepEndMs - stepStartMs);
-          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `Cleanup step success     | ${actionDesc} (id: ${entityId}) | response=${JSON.stringify(cleanupResponse, null, 4)} | startTime=${stepStartLabel} | endTime=${stepEndLabel} | totalTime=${stepTotalLabel}`);
-        } catch (err) {
-          failed++;
-          const stepEndMs = Date.now();
-          const stepEndLabel = (0, _timeFormat.formatTimestamp)(stepEndMs);
-          const stepTotalLabel = (0, _timeFormat.formatDuration)(stepEndMs - stepStartMs);
-          _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Cleanup step failed      | ${actionDesc} — ${err.message} | startTime=${stepStartLabel} | endTime=${stepEndLabel} | totalTime=${stepTotalLabel}`);
-        }
-      }
-      const entityEndMs = Date.now();
-      const entityEndLabel = (0, _timeFormat.formatTimestamp)(entityEndMs);
-      const entityTotalLabel = (0, _timeFormat.formatDuration)(entityEndMs - entityStartMs);
-      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup entity completed | entity="${entry.entityName}" | generator="${entry.generatorName}" | startTime=${entityStartLabel} | endTime=${entityEndLabel} | totalTime=${entityTotalLabel}`);
-    }
-    const cleanupEndMs = Date.now();
-    const cleanupEndLabel = (0, _timeFormat.formatTimestamp)(cleanupEndMs);
-    const cleanupTotalLabel = (0, _timeFormat.formatDuration)(cleanupEndMs - cleanupStartMs);
-    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup completed | cleaned=${cleaned} | skipped=${skipped} (no chain) | failed=${failed} | startTime=${cleanupStartLabel} | endTime=${cleanupEndLabel} | totalTime=${cleanupTotalLabel}`);
-    cleanupEntries.length = 0;
-    cache.clear();
+    await use(cacheMap);
   }
 };

package/build/core/playwright/constants/reporterConstants.js

@@ -11,5 +11,6 @@ const stage = (0, _ConfigurationHelper.getRunStage)();
 class ReporterConstants {
   static DEFAULT_REPORTER_PATH = `${_configConstants.default.TEST_SLICE_FOLDER}/${stage}/test-results/playwright-test-results.json`;
   static LAST_RUN_REPORTER_PATH = `${_configConstants.default.TEST_SLICE_FOLDER}/${stage}/test-results/.last-run.json`;
+  static DEFAULT_UNIT_TEST_REPORTER_PATH = `${_configConstants.default.TEST_SLICE_FOLDER}/unit-test/unit_reports/report.html`;
 }
 exports.default = ReporterConstants;

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

@@ -96,9 +96,9 @@ function getUserForSelectedEditionAndProfile(preferedEdition, preferredProfile,
     throw new Error(`There is no "${edition}" edition configured.`);
   }
   if (testDataPortal !== null) {
-    testingPortal = userdata[edition].find(editionData => editionData.capability === testDataPortal || editionData.orgName === testDataPortal);
+    testingPortal = userdata[edition].find(editionData => editionData.orgName === testDataPortal);
     if (!testingPortal) {
-      throw new Error(`There is no "${testDataPortal}" portal (by capability or orgName) configured in "${edition}" edition.`);
+      throw new Error(`There is no "${testDataPortal}" portal configured in "${edition}" edition.`);
     }
   } else {
     testingPortal = userdata[edition] ? userdata[edition][0] : {};

package/build/core/playwright/readConfigFile.js

@@ -55,9 +55,7 @@ function getDefaultConfig() {
     featureFilesFolder: 'feature-files',
     stepDefinitionsFolder: 'steps',
     testSetup: {},
-    editionOrder: ['Free', 'Express', 'Standard', 'Professional', 'Enterprise'],
-    generatorFilePattern: '*.generators.json',
-    autoCleanup: true
+    editionOrder: ['Free', 'Express', 'Standard', 'Professional', 'Enterprise']
   };
 }
 function combineDefaultConfigWithUserConfig(userConfiguration) {

package/build/core/playwright/reporter/PlaywrightReporter.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../../utils/logger");
+var _rootPath = require("../../../utils/rootPath");
+var _readConfigFile = require("../readConfigFile");
+class PlaywrightReporter {
+  static generate() {
+    const userArgs = process.argv.slice(3);
+    const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
+    const command = playwrightPath;
+    const {
+      reportPath: htmlPath
+    } = (0, _readConfigFile.generateConfigFromFile)();
+    const args = ['show-report', htmlPath].concat(userArgs);
+    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();
+    });
+  }
+}
+exports.default = PlaywrightReporter;

package/build/core/playwright/reporter/UnitReporter.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
+var _os = require("os");
+var _logger = require("../../../utils/logger");
+var _reporterConstants = _interopRequireDefault(require("../constants/reporterConstants"));
+class UnitReporter {
+  static generate() {
+    const reportPath = _path.default.resolve(process.cwd(), _reporterConstants.default.DEFAULT_UNIT_TEST_REPORTER_PATH);
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `Opening unit test report: ${reportPath}`);
+    const os = (0, _os.platform)();
+    const openCommand = os === 'darwin' ? 'open' : os === 'win32' ? 'start' : 'xdg-open';
+    (0, _child_process.execFile)(openCommand, [reportPath], error => {
+      if (error) {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to open report: ${error.message}`);
+      }
+      process.exit();
+    });
+  }
+}
+exports.default = UnitReporter;

package/build/core/playwright/validateFeature.js

@@ -5,15 +5,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _path = _interopRequireDefault(require("path"));
 var _parseUserArgs = _interopRequireDefault(require("./helpers/parseUserArgs"));
 var _readConfigFile = require("./readConfigFile");
 var _tagProcessor = _interopRequireDefault(require("./tagProcessor"));
 var _testRunner = require("./test-runner");
 var _logger = require("../../utils/logger");
-var _validateGenerators = require("../dataGenerator/validateGenerators");
-var _configConstants = _interopRequireDefault(require("./constants/configConstants"));
-var _ConfigurationHelper = require("./configuration/ConfigurationHelper");
 const validateFeatureFiles = () => {
   const userArgsObject = (0, _parseUserArgs.default)();
   const uatConfig = (0, _readConfigFile.generateConfigFromFile)();
@@ -21,13 +17,6 @@ const validateFeatureFiles = () => {
     editionOrder
   } = uatConfig;
   const configPath = (0, _readConfigFile.isUserConfigFileAvailable)() ? require.resolve('./setup/config-creator.js') : require.resolve('../../../playwright.config.js');
-  const stage = (0, _ConfigurationHelper.getRunStage)();
-  const modulesRoot = _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'modules');
-  const generatorResult = (0, _validateGenerators.validateGenerators)(modulesRoot);
-  if (!generatorResult.valid) {
-    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Generator validation failed. Fix duplicate generator names before running tests.');
-    process.exit(1);
-  }
   const tagProcessor = new _tagProcessor.default(editionOrder);
   const tagArgs = tagProcessor.processTags(userArgsObject);
   (0, _testRunner.runPreprocessing)(tagArgs, configPath).then(() => {