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

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

@@ -1,13 +1,208 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-const cacheMap = new Map();
+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
+  };
+}
 var _default = exports.default = {
   // eslint-disable-next-line no-empty-pattern
   cacheLayer: async ({}, use) => {
-    await use(cacheMap);
+    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();
   }
 };

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

@@ -11,6 +11,5 @@ 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.orgName === testDataPortal);
+    testingPortal = userdata[edition].find(editionData => editionData.capability === testDataPortal || editionData.orgName === testDataPortal);
     if (!testingPortal) {
-      throw new Error(`There is no "${testDataPortal}" portal configured in "${edition}" edition.`);
+      throw new Error(`There is no "${testDataPortal}" portal (by capability or orgName) configured in "${edition}" edition.`);
     }
   } else {
     testingPortal = userdata[edition] ? userdata[edition][0] : {};

package/build/core/playwright/readConfigFile.js

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

package/build/core/playwright/report-generator.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateReport;
+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");
+async function generateReport() {
+  // await preProcessReport()
+  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();
+  });
+}

package/build/core/playwright/validateFeature.js

@@ -5,11 +5,15 @@ 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)();
@@ -17,6 +21,13 @@ 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(() => {

package/build/lib/cli.js

@@ -2,9 +2,7 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _testRunner = _interopRequireDefault(require("../core/playwright/test-runner"));
-var _unitTestingFramework = require("@zohodesk/unit-testing-framework");
-var _PlaywrightReporter = _interopRequireDefault(require("../core/playwright/reporter/PlaywrightReporter"));
-var _UnitReporter = _interopRequireDefault(require("../core/playwright/reporter/UnitReporter"));
+var _reportGenerator = _interopRequireDefault(require("../core/playwright/report-generator"));
 var _codegen = _interopRequireDefault(require("../core/playwright/codegen"));
 var _logger = require("../utils/logger");
 var _setupProject = _interopRequireDefault(require("../setup-folder-structure/setupProject"));
@@ -13,25 +11,15 @@ var _clearCaches = _interopRequireDefault(require("../core/playwright/clear-cach
 var _helper = _interopRequireDefault(require("../setup-folder-structure/helper"));
 var _parseUserArgs = _interopRequireDefault(require("../core/playwright/helpers/parseUserArgs"));
 var _validateFeature = _interopRequireDefault(require("../core/playwright/validateFeature"));
-var _commonUtils = require("../utils/commonUtils");
+// import createJestRunner from '../core/jest/runner/jest-runner';
+
 const [,, option, ...otherOptions] = process.argv;
 switch (option) {
   case 'test':
     {
       _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Running Tests..');
       (0, _testRunner.default)();
-      break;
-    }
-  case 'unit-test':
-    {
-      const testFile = process.argv[3];
-      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Running Unit Tests..');
-      const options = {};
-      if (testFile) {
-        _logger.Logger.log(_logger.Logger.INFO_TYPE, `Filtering tests with pattern: ${testFile}`);
-        options.testPathPattern = testFile;
-      }
-      (0, _unitTestingFramework.createJestRunner)(options);
+      //createJestRunner();
       break;
     }
   case 'validate':
@@ -52,14 +40,9 @@ switch (option) {
     }
   case 'report':
     {
-      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Generating UAT Reports...');
-      _PlaywrightReporter.default.generate();
-      break;
-    }
-  case 'ut-report':
-    {
-      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Generating Unit Test Reports...');
-      _UnitReporter.default.generate();
+      // console.log('\x1b[36mGenerating Reports...\x1b[0m');
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Generating Reports...');
+      (0, _reportGenerator.default)();
       break;
     }
   case 'codegen':
@@ -86,12 +69,6 @@ switch (option) {
       (0, _clearCaches.default)();
       break;
     }
-  case 'stepsGenerator':
-    {
-      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Created agents and prompts md files under .github folder...');
-      (0, _commonUtils.copyGithubFolder)();
-      break;
-    }
   case 'help':
   default:
     {

package/build/utils/commonUtils.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.copyCommonSpecs = copyCommonSpecs;
-exports.copyGithubFolder = copyGithubFolder;
 var _fileUtils = require("./fileUtils");
 var _path = _interopRequireDefault(require("path"));
 var _configConstants = _interopRequireDefault(require("../core/playwright/constants/configConstants"));
@@ -18,12 +17,4 @@ function copyCommonSpecs() {
   const destDirectory = _path.default.resolve(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'modules', '.testingLib-common');
   (0, _fileUtils.deleteFolder)(destDirectory);
   (0, _fileUtils.copyDirectory)(commonSpecPath, destDirectory);
-}
-function copyGithubFolder() {
-  const libraryPath = require.resolve("@zohodesk/testinglibrary");
-  // libraryPath will be build/index.js, go two levels up to reach the package root where .github lives
-  const githubSrcPath = _path.default.resolve(libraryPath, '../../', '.github');
-  const destDirectory = _path.default.resolve(process.cwd(), '../../', '.github');
-  (0, _fileUtils.deleteFolder)(destDirectory);
-  (0, _fileUtils.copyDirectory)(githubSrcPath, destDirectory);
 }

package/build/utils/datePlaceholders.js

@@ -0,0 +1,170 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveDatePlaceholders = resolveDatePlaceholders;
+exports.resolveDatePlaceholdersInGenerators = resolveDatePlaceholdersInGenerators;
+exports.resolveDatePlaceholdersInValue = resolveDatePlaceholdersInValue;
+// Matches a full-cell date placeholder: ${TOKEN} or ${TOKEN:N}
+// Uppercase-only token names never clash with TitleCase cache refs.
+const DATE_PLACEHOLDER = /^\$\{([A-Z][A-Z_]*)(?::(\d+))?\}$/;
+function _pad(n, width = 2) {
+  return String(n).padStart(width, '0');
+}
+
+// UTC day arithmetic — avoids DST boundary issues.
+function _shiftDays(baseDate, days) {
+  const d = new Date(baseDate.getTime());
+  d.setUTCDate(d.getUTCDate() + days);
+  return d;
+}
+function _toISODate(d) {
+  return `${d.getUTCFullYear()}-${_pad(d.getUTCMonth() + 1)}-${_pad(d.getUTCDate())}`;
+}
+function _toISODateTime(d) {
+  return d.toISOString();
+}
+function _toEpochMs(d) {
+  return String(d.getTime());
+}
+function _toUIDate(d) {
+  return `${_pad(d.getUTCDate())}/${_pad(d.getUTCMonth() + 1)}/${d.getUTCFullYear()}`;
+}
+const TOKEN_HANDLERS = {
+  CURRENT_DATE: {
+    requiresN: false,
+    resolve: d => _toISODate(d)
+  },
+  PAST_DATE: {
+    requiresN: true,
+    resolve: (d, n) => _toISODate(_shiftDays(d, -n))
+  },
+  FUTURE_DATE: {
+    requiresN: true,
+    resolve: (d, n) => _toISODate(_shiftDays(d, n))
+  },
+  CURRENT_DATETIME: {
+    requiresN: false,
+    resolve: d => _toISODateTime(d)
+  },
+  PAST_DATETIME: {
+    requiresN: true,
+    resolve: (d, n) => _toISODateTime(_shiftDays(d, -n))
+  },
+  FUTURE_DATETIME: {
+    requiresN: true,
+    resolve: (d, n) => _toISODateTime(_shiftDays(d, n))
+  },
+  CURRENT_TIMESTAMP: {
+    requiresN: false,
+    resolve: d => _toEpochMs(d)
+  },
+  PAST_TIMESTAMP: {
+    requiresN: true,
+    resolve: (d, n) => _toEpochMs(_shiftDays(d, -n))
+  },
+  FUTURE_TIMESTAMP: {
+    requiresN: true,
+    resolve: (d, n) => _toEpochMs(_shiftDays(d, n))
+  },
+  CURRENT_DATE_UI: {
+    requiresN: false,
+    resolve: d => _toUIDate(d)
+  },
+  PAST_DATE_UI: {
+    requiresN: true,
+    resolve: (d, n) => _toUIDate(_shiftDays(d, -n))
+  },
+  FUTURE_DATE_UI: {
+    requiresN: true,
+    resolve: (d, n) => _toUIDate(_shiftDays(d, n))
+  }
+};
+const VALID_TOKENS = Object.keys(TOKEN_HANDLERS).join(', ');
+
+/**
+ * Resolve a single dataTable cell value.
+ * Non-strings and strings without "${" are returned as-is.
+ * @param {*} value
+ * @param {Date} [now]
+ * @returns {*}
+ */
+function resolveDatePlaceholdersInValue(value, now = new Date()) {
+  if (typeof value !== 'string' || !value.includes('${')) {
+    return value;
+  }
+  const match = value.match(DATE_PLACEHOLDER);
+  if (!match) {
+    return value;
+  }
+  const [, token, rawN] = match;
+  const handler = TOKEN_HANDLERS[token];
+  if (!handler) {
+    throw new Error(`DataGenerator: Unknown date placeholder token "\${${token}}". Valid tokens are: ${VALID_TOKENS}.`);
+  }
+  if (handler.requiresN) {
+    if (rawN === undefined) {
+      throw new Error(`DataGenerator: Placeholder "\${${token}}" requires a day offset N, e.g. "\${${token}:7}".`);
+    }
+    const n = parseInt(rawN, 10);
+    if (!Number.isFinite(n) || n < 1) {
+      throw new Error(`DataGenerator: Placeholder "\${${token}:${rawN}}" — N must be a positive integer ≥ 1.`);
+    }
+    return handler.resolve(now, n);
+  } else {
+    if (rawN !== undefined) {
+      const suggestionToken = token.replace('CURRENT_', 'FUTURE_');
+      throw new Error(`DataGenerator: Placeholder "\${${token}}" does not accept an offset. Did you mean "\${${suggestionToken}:${rawN}}"?`);
+    }
+    return handler.resolve(now);
+  }
+}
+
+/**
+ * Resolve date placeholders in all cells of a dataTable rows array.
+ * @param {Object[]} rows
+ * @param {Date} [now]
+ * @returns {Object[]}
+ */
+function resolveDatePlaceholders(rows, now = new Date()) {
+  if (!rows || !rows.length) {
+    return rows || [];
+  }
+  return rows.map(row => {
+    const resolved = {};
+    for (const [key, value] of Object.entries(row)) {
+      resolved[key] = resolveDatePlaceholdersInValue(value, now);
+    }
+    return resolved;
+  });
+}
+function _resolveObjectValues(obj, now) {
+  for (const key of Object.keys(obj)) {
+    const val = obj[key];
+    if (typeof val === 'string') {
+      obj[key] = resolveDatePlaceholdersInValue(val, now);
+    } else if (val !== null && typeof val === 'object') {
+      _resolveObjectValues(val, now);
+    }
+  }
+}
+
+/**
+ * Resolve date placeholders in static params of a loaded generators array.
+ * Mutates in place — call only on a cloned copy of the generator index entry.
+ * @param {Object[]} generators
+ * @param {Date} [now]
+ * @returns {Object[]}
+ */
+function resolveDatePlaceholdersInGenerators(generators, now = new Date()) {
+  if (!generators || !generators.length) {
+    return generators || [];
+  }
+  for (const gen of generators) {
+    if (gen.params && typeof gen.params === 'object') {
+      _resolveObjectValues(gen.params, now);
+    }
+  }
+  return generators;
+}

package/build/utils/logger.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Logger = void 0;
+var _util = require("util");
 class LoggerImpl {
   constructor() {
     this.SUCCESS_TYPE = 'success';
@@ -20,8 +21,9 @@ class LoggerImpl {
     this.consoleLogger.error(err);
   }
   info() {}
-  log(type, message) {
+  log(type, ...messageParts) {
     const color = this.colors[type];
+    const message = (0, _util.format)(...messageParts);
     this.consoleLogger.log(`${color[0]}${message}${color[1]}\n`);
   }
 }

package/build/utils/timeFormat.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatDuration = formatDuration;
+exports.formatTimestamp = formatTimestamp;
+/**
+ * Format a Date (or epoch ms) as a human-readable local timestamp in 12-hour format.
+ * Example: "2026-04-10 11:35:23.123 AM"
+ */
+function formatTimestamp(input) {
+  const d = input instanceof Date ? input : new Date(input);
+  const pad = (n, w = 2) => String(n).padStart(w, '0');
+  const hours24 = d.getHours();
+  const period = hours24 >= 12 ? 'PM' : 'AM';
+  const hours12 = hours24 % 12 || 12;
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` + `${pad(hours12)}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)} ${period}`;
+}
+
+/**
+ * Format a duration in milliseconds as a human-readable string.
+ * Examples: "850ms", "4.32s", "1m 23.45s", "1h 02m 03.45s"
+ */
+function formatDuration(ms) {
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  const totalSeconds = ms / 1000;
+  if (totalSeconds < 60) {
+    return `${totalSeconds.toFixed(2)}s`;
+  }
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  const pad = n => String(n).padStart(2, '0');
+  if (hours > 0) {
+    return `${hours}h ${pad(minutes)}m ${seconds.toFixed(2)}s`;
+  }
+  return `${minutes}m ${seconds.toFixed(2)}s`;
+}

package/changelog.md

@@ -1,6 +1,33 @@
 # Testing Framework
 
 ## Framework that abstracts the configuration for playwright and Jest
+
+# 0.0.48-n20-experimental
+
+## Data Generator — Global Index Discovery
+- **Global generator index**: Replaced walk-up directory search with index-based global discovery. Generators in any module are now accessible from any feature file.
+- **Deterministic modules root**: Uses `configConstants.TEST_SLICE_FOLDER + stage + 'modules'` instead of unreliable directory walk-up.
+- **Configurable file pattern**: `generatorFilePattern` in `uat.config.js` (default: `*.generators.json`).
+- **TicketBasic generator**: New generator without product step for Express/Free editions.
+
+## Data Generator — Profile & Auth Improvements
+- **Org-level DG fallback**: When scenario profile has no `data-generator` config, falls back to org-level from edition JSON.
+
+## Auto-Cleanup V2
+- **Co-located `*.cleanup.json` registry**: Each module defines cleanup rules alongside generators. Scanned globally.
+- **Fixture teardown cleanup**: Runs after each scenario (pass or fail). Supports OAS, REST DELETE, REST PATCH.
+- **`autoCleanup` config**: Enable/disable via `uat.config.js` (default: `true`).
+- **Detailed logging**: Cleanup started/completed/success/failed with entity names and IDs.
+
+## Portal Resolution — Capability Support
+- **`capability` field**: Portals can define a `capability` field for DC-agnostic resolution.
+- **Dual resolution**: `@portal_` tags resolve by `capability` first, then `orgName` fallback.
+- **Backward compatible**: Existing `orgName`-based tags still work.
+
+## Bug Fixes
+- Fixed `#getModulesRoot` hitting nested `modules/` directories.
+- Removed cleanup V1 — replaced by V2.
+
 # 0.2.4
 - Issue fixes on custom fixtures
   - Page Fixture