@zohodesk/testinglibrary 0.0.53-n20-experimental → 0.0.57-n20-experimental

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

@@ -26,10 +26,11 @@ export async function generateAndCacheTestData(executionContext, type, identifie
         }
     }
 
-    const { response, generators } = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : []);
+    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);
     }
 }

package/build/core/dataGenerator/DataGenerator.js

@@ -27,7 +27,7 @@ class DataGenerator {
     _classPrivateMethodInitSpec(this, _DataGenerator_brand);
     _classPrivateFieldInitSpec(this, _generatorIndex, null);
   }
-  async generate(testInfo, actorInfo, generatorType, generatorName, scenarioName, dataTable) {
+  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}`);
@@ -38,13 +38,21 @@ class DataGenerator {
       } else {
         generators = await _assertClassBrand(_DataGenerator_brand, this, _getGenerator).call(this, generatorName);
       }
-      const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
+      const resolvedDataTable = await (0, _DataGeneratorHelper.resolveCacheReferences)(dataTable, cacheLayer);
+      const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generators, resolvedDataTable);
       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);
+      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)}`);
+      _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,
@@ -56,16 +64,16 @@ class DataGenerator {
       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) {
-        console.error(error.getMessage());
-        console.error("Stack trace:", error.stack);
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error.getMessage());
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, "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 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);
         _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);
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Data Generation failed for the generator: ${generatorName}\n\nError response: ${error}`);
       throw error;
     }
   }

package/build/core/dataGenerator/DataGeneratorHelper.js

@@ -6,6 +6,54 @@ 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) {
@@ -29,12 +77,12 @@ async function processGenerator(generators, dataTable) {
     return generator;
   });
 }
-async function makeRequest(url, payload) {
+async function makeRequest(url, payload, headers = {
+  'Content-Type': 'application/json'
+}) {
   const response = await fetch(url, {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json'
-    },
+    headers: headers,
     body: JSON.stringify(payload)
   });
   if (!response.ok) {

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

@@ -125,6 +125,7 @@ var _default = exports.default = {
     const cleanupEntries = [];
     cache._trackForCleanup = (entityName, data, generators, actorInfo, logs, generatorName) => {
       cache.set(entityName, data);
+      cache.set(`${entityName}_logs`, logs);
       cleanupEntries.push({
         entityName,
         data,
@@ -183,7 +184,7 @@ var _default = exports.default = {
           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)} | startTime=${stepStartLabel} | endTime=${stepEndLabel} | totalTime=${stepTotalLabel}`);
+          _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();

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`);
   }
 }