@zohodesk/testinglibrary 0.0.48-n20-experimental → 0.0.50-n20-experimental

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

@@ -28,7 +28,7 @@ export async function generateAndCacheTestData(executionContext, type, identifie
 
     const { response, generators } = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : []);
     if (cacheLayer._trackForCleanup) {
-        cacheLayer._trackForCleanup(entityName, response.data, generators, actorInfo);
+        cacheLayer._trackForCleanup(entityName, response.data, generators, actorInfo, response.logs, identifier);
     } else {
         cacheLayer.set(entityName, response.data);
     }

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

@@ -10,17 +10,22 @@ var _fs = _interopRequireDefault(require("fs"));
 var _logger = require("../../../utils/logger");
 var _DataGeneratorHelper = require("../../dataGenerator/DataGeneratorHelper");
 var _readConfigFile = require("../readConfigFile");
-var _configConstants = _interopRequireDefault(require("../constants/configConstants"));
-var _ConfigurationHelper = require("../configuration/ConfigurationHelper");
 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 stage = (0, _ConfigurationHelper.getRunStage)();
-  const modulesRoot = _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'modules');
+  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} rules from ${modulesRoot}`);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup registry built: ${Object.keys(registry).length} generator chains from ${modulesRoot}`);
   return registry;
 }
 function scanDir(dir, registry) {
@@ -31,27 +36,37 @@ function scanDir(dir, registry) {
     const fullPath = _path.default.join(dir, entry.name);
     if (entry.isDirectory()) {
       scanDir(fullPath, registry);
-    } else if (entry.name.endsWith('.cleanup.json')) {
+    } else if (entry.name.endsWith('.cleanup.js')) {
       try {
-        const data = JSON.parse(_fs.default.readFileSync(fullPath, 'utf8'));
-        for (const [operationId, config] of Object.entries(data)) {
-          if (!registry[operationId]) {
-            registry[operationId] = config;
+        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) {
-        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to parse cleanup file: ${fullPath} - ${err.message}`);
+        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(cachedData, idPath) {
-  const result = _jsonpath.default.query(cachedData, idPath);
+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) {
@@ -102,13 +117,15 @@ var _default = exports.default = {
   cacheLayer: async ({}, use) => {
     const cache = new Map();
     const cleanupEntries = [];
-    cache._trackForCleanup = (entityName, data, generators, actorInfo) => {
+    cache._trackForCleanup = (entityName, data, generators, actorInfo, logs, generatorName) => {
       cache.set(entityName, data);
       cleanupEntries.push({
         entityName,
         data,
         generators,
-        actorInfo
+        actorInfo,
+        logs: logs || [],
+        generatorName
       });
     };
     await use(cache);
@@ -129,32 +146,36 @@ var _default = exports.default = {
     let skipped = 0;
     let failed = 0;
     for (const entry of [...cleanupEntries].reverse()) {
-      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup entity: "${entry.entityName}" (${entry.generators.length} steps)`);
-      for (const step of [...entry.generators].reverse()) {
-        const operationId = step.generatorOperationId;
-        const cleanupConfig = cleanupRegistry[operationId];
-        if (!cleanupConfig) {
-          skipped++;
-          continue;
-        }
+      const cleanupChain = cleanupRegistry[entry.generatorName];
+      if (!cleanupChain) {
+        _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup: no chain for generator "${entry.generatorName}" — skipping`);
+        skipped++;
+        continue;
+      }
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup entity: "${entry.entityName}" generator: "${entry.generatorName}" (${cleanupChain.length} steps)`);
+      for (const cleanupStep of cleanupChain) {
         try {
-          const entityId = extractId(entry.data, cleanupConfig.idPath);
-          const actionDesc = cleanupConfig.operationId || `${cleanupConfig.method} ${cleanupConfig.apiPath}`;
-          _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup [${cleanupConfig.type}] ${step.name}: ${actionDesc} (id: ${entityId})`);
-          if (cleanupConfig.type === 'oas') {
-            await cleanupViaOAS(cleanupConfig, entityId, entry.actorInfo);
-          } else if (cleanupConfig.type === 'api') {
-            await cleanupViaAPI(cleanupConfig, entityId);
+          // 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);
+          const actionDesc = cleanupStep.operationId || `${cleanupStep.method} ${cleanupStep.apiPath}`;
+          _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup [${cleanupStep.type}] ${actionDesc} (id: ${entityId})`);
+          if (cleanupStep.type === 'oas') {
+            await cleanupViaOAS(cleanupStep, entityId, entry.actorInfo);
+          } else if (cleanupStep.type === 'api') {
+            await cleanupViaAPI(cleanupStep, entityId);
           }
           cleaned++;
-          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `Cleanup success: ${step.name} (id: ${entityId})`);
+          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `Cleanup success: ${actionDesc} (id: ${entityId})`);
         } catch (err) {
           failed++;
-          _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Cleanup failed: ${step.name} — ${err.message}`);
+          const actionDesc = cleanupStep.operationId || `${cleanupStep.method} ${cleanupStep.apiPath}`;
+          _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Cleanup failed: ${actionDesc} — ${err.message}`);
         }
       }
     }
-    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup completed: ${cleaned} cleaned, ${skipped} skipped (no cleanup rule), ${failed} failed`);
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup completed: ${cleaned} cleaned, ${skipped} skipped (no chain), ${failed} failed`);
     cleanupEntries.length = 0;
     cache.clear();
   }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@zohodesk/testinglibrary",
-  "version": "0.0.48-n20-experimental",
+  "version": "0.0.50-n20-experimental",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@zohodesk/testinglibrary",
-      "version": "0.0.48-n20-experimental",
+      "version": "0.0.50-n20-experimental",
       "hasInstallScript": true,
       "license": "ISC",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/testinglibrary",
-  "version": "0.0.48-n20-experimental",
+  "version": "0.0.50-n20-experimental",
   "main": "./build/index.js",
   "scripts": {
     "postinstall": "node bin/postinstall.js",