@zohodesk/testinglibrary 0.0.44-n20-experimental → 0.0.46-n20-experimental

package/AUTO_CLEANUP_PLAN.md

@@ -0,0 +1,332 @@
+# Data Generator System — Design & Constraints
+
+## Data Generator Overview
+
+### How It Works
+- BDD step: `Given generate a "{Type}" entity "{name}" with generator "{GeneratorName}"`
+- Framework resolves generator template from `data-generators/*.json` files
+- Walks up directory tree from feature file to find `data-generators/` folder
+- Scans ALL `.json` files within (not hardcoded to `generators.json`)
+- Generator names must be **unique across the entire UAT suite**
+- `ZDTestingFramework validate` checks for duplicate generator names before test run
+
+### Generator JSON Structure
+```json
+{
+    "generators": {
+        "GeneratorName": [
+            {
+                "type": "dynamic",
+                "name": "stepName",
+                "generatorOperationId": "support.Module.operationName",
+                "dataPath": "$.response.body:$",
+                "params": { "key": "$previousStep.value" },
+                "cleanup": { ... }
+            }
+        ]
+    }
+}
+```
+
+### Constraints
+| Constraint | Detail |
+|---|---|
+| **Unique generator names** | Generator names must be unique across all `data-generators/*.json` files in the UAT suite. Walk-up discovery returns the first match. |
+| **Walk-up discovery** | Framework walks from feature file directory toward filesystem root, scanning each level for `data-generators/` folder. |
+| **Multiple JSON files** | Any `.json` file in a `data-generators/` folder is scanned (e.g., `ticket.json`, `account.json`, `contact.json`). |
+| **Parent serves children** | A `data-generators/` folder at a parent module level serves all sub-modules via walk-up (reduces duplication). |
+| **DG_API_NAME matching** | In Gherkin data tables, `DG_API_NAME` column matches generator step's `name` field to inject params. |
+| **Chained steps** | Multi-step generators use `$previousStep.value` syntax to pass output from one step to the next. |
+| **dataPath extraction** | `dataPath` uses JSONPath to extract specific fields from DG service response (server-side). |
+| **Cached response** | Generated data is cached via `cacheLayer.set(entityName, response.data)` for use in subsequent steps. |
+| **Validation** | `ZDTestingFramework validate` scans all `data-generators/` directories and fails if duplicate generator names are found. |
+
+### File Discovery Pattern
+```
+feature-files/MyTest.feature  ← test starts here
+    ↑ walks up
+data-generators/ticket.json   ← found at same level or parent
+data-generators/account.json  ← multiple files supported
+    ↑ keeps walking up
+../data-generators/shared.json ← parent level generators serve all children
+```
+
+---
+
+# Auto-Cleanup Generated Test Data After Scenario
+
+## Context
+
+The framework generates test data (contacts, tickets, accounts, etc.) via the DG service but never cleans it up. Generated data accumulates in test portals. We need auto-cleanup that deletes all generated entities after each scenario ends.
+
+**Approach:** Auto-cleanup all generated entities after each scenario via fixture teardown. No explicit step needed in feature files. Cleanup config is defined in the generator JSON via a `cleanup` property on each generator step.
+
+---
+
+## Three Cleanup Types
+
+### Type 1: `oas` — DG service delete (OAS supported)
+```json
+"cleanup": {
+    "type": "oas",
+    "operationId": "support.Contact.deleteContact",
+    "idPath": "$.id"
+}
+```
+
+### Type 2: `api` — Direct REST API (OAS not supported, DELETE)
+```json
+"cleanup": {
+    "type": "api",
+    "method": "DELETE",
+    "apiPath": "/api/v1/contracts/{id}",
+    "idPath": "$.id"
+}
+```
+
+### Type 3: `api` — Disable instead of delete (PATCH)
+```json
+"cleanup": {
+    "type": "api",
+    "method": "PATCH",
+    "apiPath": "/api/v1/webhooks/{id}",
+    "idPath": "$.id",
+    "body": { "isActive": false }
+}
+```
+
+### No cleanup — read-only operations
+Steps without `cleanup` property are skipped (e.g., `getDepartments`).
+
+---
+
+## Full Generator JSON Examples
+
+### Contact (OAS supported)
+```json
+{
+    "generators": {
+        "CreateContactRecord": [
+            {
+                "type": "dynamic",
+                "name": "CreateContact",
+                "generatorOperationId": "support.Contact.createContact",
+                "dataPath": "$.response.body:$",
+                "cleanup": {
+                    "type": "oas",
+                    "operationId": "support.Contact.deleteContact",
+                    "idPath": "$.id"
+                }
+            }
+        ]
+    }
+}
+```
+
+### Ticket with dependencies (OAS supported, multi-step)
+```json
+{
+    "generators": {
+        "TicketWithDepartment": [
+            {
+                "type": "dynamic",
+                "name": "departments",
+                "generatorOperationId": "support.Department.getDepartments",
+                "dataPath": "$.response.body:$.data[0].id"
+            },
+            {
+                "type": "dynamic",
+                "name": "products",
+                "generatorOperationId": "support.Product.createProduct",
+                "dataPath": "$.response.body:$.id",
+                "cleanup": {
+                    "type": "oas",
+                    "operationId": "support.Product.deleteProduct",
+                    "idPath": "$.id"
+                }
+            },
+            {
+                "type": "dynamic",
+                "name": "CreateTicket",
+                "generatorOperationId": "support.Ticket.createTicket",
+                "dataPath": "$.response.body:$",
+                "cleanup": {
+                    "type": "oas",
+                    "operationId": "support.Ticket.deleteTicket",
+                    "idPath": "$.id"
+                }
+            }
+        ]
+    }
+}
+```
+
+### Webhook (OAS not supported — disable via REST API)
+```json
+{
+    "generators": {
+        "CreateWebhookRecord": [
+            {
+                "type": "dynamic",
+                "name": "CreateWebhook",
+                "generatorOperationId": "support.Webhook.createWebhook",
+                "dataPath": "$.response.body:$",
+                "cleanup": {
+                    "type": "api",
+                    "method": "PATCH",
+                    "apiPath": "/api/v1/webhooks/{id}",
+                    "idPath": "$.id",
+                    "body": { "isActive": false }
+                }
+            }
+        ]
+    }
+}
+```
+
+### Contract (OAS not supported — delete via REST API)
+```json
+{
+    "generators": {
+        "CreateContractRecord": [
+            {
+                "type": "dynamic",
+                "name": "CreateContract",
+                "generatorOperationId": "support.Contract.createContract",
+                "dataPath": "$.response.body:$",
+                "cleanup": {
+                    "type": "api",
+                    "method": "DELETE",
+                    "apiPath": "/api/v1/contracts/{id}",
+                    "idPath": "$.id"
+                }
+            }
+        ]
+    }
+}
+```
+
+---
+
+## How It Works
+
+### Cleanup flow
+```
+Scenario ends (pass OR fail)
+    ↓
+cleanupTracker fixture teardown fires (guaranteed by Playwright)
+    ↓
+For each tracked entity (reverse order):
+  - Read cleanup config from the generator step
+  - Skip if no cleanup property
+  - Extract entity ID using cleanup.idPath from cached response
+  - Based on cleanup.type:
+    - "oas" → POST to DG service with cleanup.operationId + entity ID
+    - "api" → Direct HTTP request (cleanup.method + cleanup.apiPath with {id} replaced)
+  - Log result (success or failure — never fail the test)
+    ↓
+Clear tracker for next scenario
+```
+
+### Cleanup on scenario failure
+
+Playwright fixtures guarantee that teardown code (everything after `await use()`) runs **regardless of whether the test passes or fails**. This means:
+
+- **Scenario passes** → cleanup runs
+- **Scenario fails** → cleanup still runs
+- **Individual cleanup step fails** → remaining cleanup steps still run (each step is wrapped in try/catch)
+
+This is a core Playwright design principle — fixtures always clean up after themselves.
+
+---
+
+## Files to Modify/Create
+
+### 1. New: `src/core/dataGenerator/CleanupTracker.js`
+
+Tracks generated entities for cleanup:
+
+```js
+class CleanupTracker {
+    #entries = [];
+
+    track({ entityName, generators, cachedData, actorInfo }) {
+        this.#entries.push({ entityName, generators, cachedData, actorInfo });
+    }
+
+    getEntries() { return [...this.#entries]; }
+    clear() { this.#entries = []; }
+}
+```
+
+### 2. New: `src/core/dataGenerator/DataCleanup.js`
+
+Performs the actual deletion with two strategies:
+
+```js
+class DataCleanup {
+    async cleanup(entries) {
+        for (const entry of entries.reverse()) {
+            for (const step of [...entry.generators].reverse()) {
+                if (!step.cleanup) continue;
+                try {
+                    const entityId = this.#extractId(entry.cachedData, step.cleanup.idPath);
+
+                    if (step.cleanup.type === 'oas') {
+                        await this.#cleanupViaOAS(step.cleanup.operationId, entityId, entry.actorInfo);
+                    } else if (step.cleanup.type === 'api') {
+                        await this.#cleanupViaAPI(step.cleanup, entityId, entry.actorInfo);
+                    }
+
+                    Logger.log(Logger.SUCCESS_TYPE, `Cleanup: ${step.cleanup.method || 'delete'} ${step.name} (${entityId})`);
+                } catch (err) {
+                    Logger.log(Logger.INFO_TYPE, `Cleanup warning for ${step.name}: ${err.message}`);
+                }
+            }
+        }
+    }
+
+    async #cleanupViaOAS(operationId, entityId, actorInfo) {
+        // POST to DG service with delete operationId + entity ID as param
+    }
+
+    async #cleanupViaAPI(cleanupConfig, entityId, actorInfo) {
+        // Direct HTTP call: cleanupConfig.method + cleanupConfig.apiPath.replace('{id}', entityId)
+        // If cleanupConfig.body exists, send as request body (for PATCH/disable)
+    }
+}
+```
+
+Key behaviors:
+- Delete in **reverse order** (dependent entities first)
+- `type: "oas"` → POST to DG service (same auth/env as generation)
+- `type: "api"` → Direct REST call (supports DELETE, PATCH, any HTTP method)
+- `body` field for PATCH operations (e.g., `{ "isActive": false }`)
+- `{id}` placeholder in `apiPath` replaced with extracted entity ID
+- **Never fail the test** — log warnings only
+
+### 3. Modify: `src/core/playwright/builtInFixtures/cacheLayer.js`
+
+Add `cleanupTracker` fixture. Code after `await use()` runs after scenario ends:
+
+### 4. Modify: `src/core/dataGenerator/DataGenerator.js`
+
+Return generator steps alongside response: `return { response, generators }`
+
+### 5. Modify: `src/common/data-generator/steps/DataGeneratorStepsHelper.js`
+
+Track each generated entity with its generators and actorInfo for cleanup.
+
+### 6. Modify: `src/common/data-generator/steps/DataGenerator.spec.js`
+
+Pass `cleanupTracker` fixture to all 4 step definitions.
+
+---
+
+## Verification
+
+1. `npm run build` to confirm compilation
+2. Add `cleanup` config to generator JSONs (contact, ticket, webhook)
+3. Run a scenario → verify cleanup logs show correct operation after scenario ends
+4. Verify PATCH operations send the body (webhook disable)
+5. Verify reverse order (ticket deleted before product)

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

@@ -3,17 +3,17 @@ import { generateAndCacheTestData } from './DataGeneratorStepsHelper';
 
 const { Given } = createBdd();
 
-Given('generate a {string} entity {string} with generator {string}', async ({ page, context, i18N, cacheLayer, executionContext}, module, entityName, generatorName, dataTable) => {
-    await generateAndCacheTestData(executionContext, "template", generatorName, dataTable, cacheLayer, entityName);
+Given('generate a {string} entity {string} with generator {string}', async ({ page, context, i18N, cacheLayer, cleanupTracker, executionContext}, module, entityName, generatorName, dataTable) => {
+    await generateAndCacheTestData(executionContext, "template", generatorName, dataTable, cacheLayer, entityName, null, cleanupTracker);
 });
 
-Given('generate a {string} entity {string} with API {string}', async ({ page, context, i18N, cacheLayer, executionContext}, module, entityName, operationId, dataTable) => {
-    await generateAndCacheTestData(executionContext, "API", operationId, dataTable, cacheLayer, entityName);
+Given('generate a {string} entity {string} with API {string}', async ({ page, context, i18N, cacheLayer, cleanupTracker, executionContext}, module, entityName, operationId, dataTable) => {
+    await generateAndCacheTestData(executionContext, "API", operationId, dataTable, cacheLayer, entityName, null, cleanupTracker);
 });
-Given('generate a {string} entity {string} with generator {string} using {string} profile', async ({ page, context, i18N, cacheLayer, executionContext}, module, entityName, generatorName, profile, dataTable) => {
-    await generateAndCacheTestData(executionContext, "template", generatorName, dataTable, cacheLayer, entityName, profile);
+Given('generate a {string} entity {string} with generator {string} using {string} profile', async ({ page, context, i18N, cacheLayer, cleanupTracker, executionContext}, module, entityName, generatorName, profile, dataTable) => {
+    await generateAndCacheTestData(executionContext, "template", generatorName, dataTable, cacheLayer, entityName, profile, cleanupTracker);
 });
 
-Given('generate a {string} entity {string} with API {string} using {string} profile', async ({ page, context, i18N, cacheLayer, executionContext}, module, entityName, operationId, profile, dataTable) => {
-    await generateAndCacheTestData(executionContext, "API", operationId, dataTable, cacheLayer, entityName, profile);
+Given('generate a {string} entity {string} with API {string} using {string} profile', async ({ page, context, i18N, cacheLayer, cleanupTracker, executionContext}, module, entityName, operationId, profile, dataTable) => {
+    await generateAndCacheTestData(executionContext, "API", operationId, dataTable, cacheLayer, entityName, profile, cleanupTracker);
 });

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

@@ -4,7 +4,7 @@ import DataGenerator from '@zohodesk/testinglibrary/DataGenerator';
 
 const dataGenerator = new DataGenerator();
 
-export async function generateAndCacheTestData(executionContext, type, identifier, dataTable, cacheLayer, entityName, profile = null) {
+export async function generateAndCacheTestData(executionContext, type, identifier, dataTable, cacheLayer, entityName, profile = null, cleanupTracker = null) {
     let actorInfo;
     const testInfo = test.info();
     const scenarioName = testInfo.title.split('/').pop() || 'Unknown Scenario';
@@ -16,6 +16,15 @@ export async function generateAndCacheTestData(executionContext, type, identifie
         actorInfo = executionContext.actorInfo;
     }
     
-    const generatedData = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : []);
-    await cacheLayer.set(entityName, generatedData.data);
+    const { response, generators } = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : []);
+    await cacheLayer.set(entityName, response.data);
+
+    if (cleanupTracker) {
+        cleanupTracker.track({
+            entityName,
+            generators,
+            cachedData: response.data,
+            actorInfo
+        });
+    }
 }

package/build/core/dataGenerator/CleanupTracker.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class CleanupTracker {
+  #entries = [];
+  track({
+    entityName,
+    generators,
+    cachedData,
+    actorInfo
+  }) {
+    this.#entries.push({
+      entityName,
+      generators,
+      cachedData,
+      actorInfo
+    });
+  }
+  getEntries() {
+    return [...this.#entries];
+  }
+  clear() {
+    this.#entries = [];
+  }
+}
+var _default = exports.default = CleanupTracker;

package/build/core/dataGenerator/DataCleanup.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _jsonpath = _interopRequireDefault(require("jsonpath"));
+var _logger = require("../../utils/logger");
+var _DataGeneratorHelper = require("./DataGeneratorHelper");
+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 _DataCleanup_brand = /*#__PURE__*/new WeakSet();
+class DataCleanup {
+  constructor() {
+    _classPrivateMethodInitSpec(this, _DataCleanup_brand);
+  }
+  async cleanup(entries) {
+    for (const entry of [...entries].reverse()) {
+      for (const step of [...entry.generators].reverse()) {
+        if (!step.cleanup) continue;
+        try {
+          const entityId = _assertClassBrand(_DataCleanup_brand, this, _extractId).call(this, entry.cachedData, step.cleanup.idPath);
+          if (step.cleanup.type === 'oas') {
+            await _assertClassBrand(_DataCleanup_brand, this, _cleanupViaOAS).call(this, step.cleanup, entityId, entry.actorInfo);
+          } else if (step.cleanup.type === 'api') {
+            await _assertClassBrand(_DataCleanup_brand, this, _cleanupViaAPI).call(this, step.cleanup, entityId, entry.actorInfo);
+          }
+          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `Cleanup: ${step.cleanup.method || 'delete'} ${step.name} (ID: ${entityId})`);
+        } catch (err) {
+          _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup warning for ${step.name}: ${err.message}`);
+        }
+      }
+    }
+  }
+}
+function _extractId(cachedData, idPath) {
+  if (!cachedData || !idPath) {
+    throw new Error('Missing cached data or idPath for cleanup');
+  }
+  const result = _jsonpath.default.query(cachedData, idPath);
+  if (result.length === 0) {
+    throw new Error(`Could not extract ID using path "${idPath}" from cached data`);
+  }
+  return result[0];
+}
+async function _cleanupViaOAS(cleanupConfig, entityId, actorInfo) {
+  const dataGeneratorObj = actorInfo['data-generator'];
+  if (!dataGeneratorObj) {
+    throw new Error(`Data Generator configuration is missing for cleanup`);
+  }
+  const deleteGenerator = [{
+    type: 'dynamic',
+    generatorOperationId: cleanupConfig.operationId,
+    dataPath: '$.response.body:$',
+    name: cleanupConfig.operationId,
+    params: {
+      id: String(entityId)
+    }
+  }];
+  const apiPayload = {
+    scenario_name: 'cleanup',
+    data_generation_templates: deleteGenerator,
+    ...dataGeneratorObj
+  };
+  const account = apiPayload.account;
+  if (account) {
+    account.email = actorInfo.email;
+    account.password = actorInfo.password;
+  }
+  const environmentDetails = apiPayload.environmentDetails || {};
+  environmentDetails.iam_url = process.env.DG_IAM_DOMAIN;
+  const domainUrl = new URL(process.env.domain);
+  environmentDetails.host = domainUrl.origin;
+  apiPayload.environmentDetails = environmentDetails;
+  await (0, _DataGeneratorHelper.makeRequest)(process.env.DG_SERVICE_DOMAIN + process.env.DG_SERVICE_API_PATH, apiPayload);
+}
+async function _cleanupViaAPI(cleanupConfig, entityId, actorInfo) {
+  const domainUrl = new URL(process.env.domain);
+  const apiPath = cleanupConfig.apiPath.replace('{id}', entityId);
+  const url = `${domainUrl.origin}${apiPath}`;
+  const fetchOptions = {
+    method: cleanupConfig.method,
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  };
+  if (cleanupConfig.body) {
+    fetchOptions.body = JSON.stringify(cleanupConfig.body);
+  }
+  const response = await fetch(url, fetchOptions);
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(`API cleanup failed: ${cleanupConfig.method} ${apiPath} - status: ${response.status}, body: ${errorBody}`);
+  }
+}
+var _default = exports.default = DataCleanup;

package/build/core/dataGenerator/DataGenerator.js

@@ -11,13 +11,19 @@ var _logger = require("../../utils/logger");
 var _DataGeneratorHelper = require("./DataGeneratorHelper");
 var _helpers = require("@zohodesk/testinglibrary/helpers");
 var _DataGeneratorError = require("./DataGeneratorError");
+var _readConfigFile = require("../playwright/readConfigFile");
 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) {
     try {
@@ -31,7 +37,10 @@ class DataGenerator {
       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;
+      return {
+        response,
+        generators
+      };
     } catch (error) {
       if (error instanceof _DataGeneratorError.DataGeneratorError) {
         console.error(error.getMessage());
@@ -48,26 +57,64 @@ class DataGenerator {
     }
   }
 }
-async function _getGenerator(testInfo, generatorName) {
-  let featureFilePath = await (0, _DataGeneratorHelper.getGeneratorFilePath)(testInfo.file);
-  let searchDir = _path.default.dirname(featureFilePath);
-  const rootDir = _path.default.parse(searchDir).root;
-  while (searchDir !== rootDir) {
-    const dataGeneratorsDir = _path.default.join(searchDir, "data-generators");
-    if (_fs.default.existsSync(dataGeneratorsDir)) {
-      const jsonFiles = _fs.default.readdirSync(dataGeneratorsDir).filter(file => file.endsWith('.json'));
-      for (const file of jsonFiles) {
-        const filePath = _path.default.join(dataGeneratorsDir, file);
-        const data = _fs.default.readFileSync(filePath, 'utf8');
-        const generatorObj = JSON.parse(data);
-        if (generatorObj.generators && generatorObj.generators[generatorName]) {
-          return generatorObj.generators[generatorName];
+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}`);
       }
     }
-    searchDir = _path.default.dirname(searchDir);
   }
-  throw new _DataGeneratorError.GeneratorError(`Generator "${generatorName}" could not be found in any data-generators directory from "${_path.default.dirname(featureFilePath)}"`);
+}
+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(featureFilePath) {
+  let dir = _path.default.dirname(featureFilePath);
+  while (dir !== _path.default.parse(dir).root) {
+    if (_path.default.basename(dir) === 'modules') return dir;
+    dir = _path.default.dirname(dir);
+  }
+  return null;
+}
+async function _getGenerator(testInfo, generatorName) {
+  if (!_classPrivateFieldGet(_generatorIndex, this)) {
+    const featureFilePath = await (0, _DataGeneratorHelper.getGeneratorFilePath)(testInfo.file);
+    const modulesRoot = _assertClassBrand(_DataGenerator_brand, this, _getModulesRoot).call(this, featureFilePath);
+    const {
+      generatorFilePattern: pattern = '*.generators.json'
+    } = (0, _readConfigFile.generateConfigFromFile)();
+    if (modulesRoot) {
+      _classPrivateFieldSet(_generatorIndex, this, _assertClassBrand(_DataGenerator_brand, this, _buildIndex).call(this, modulesRoot, pattern));
+    }
+  }
+  if (_classPrivateFieldGet(_generatorIndex, this) && _classPrivateFieldGet(_generatorIndex, this).has(generatorName)) {
+    return _classPrivateFieldGet(_generatorIndex, this).get(generatorName);
+  }
+  throw new _DataGeneratorError.GeneratorError(`Generator "${generatorName}" could not be found in any generator file`);
 }
 async function _generateAPIGenerator(operationId) {
   return [{

package/build/core/dataGenerator/validateGenerators.js

@@ -8,18 +8,21 @@ exports.validateGenerators = validateGenerators;
 var _path = _interopRequireDefault(require("path"));
 var _fs = _interopRequireDefault(require("fs"));
 var _logger = require("../../utils/logger");
-function findDataGeneratorDirs(dir, results = []) {
+var _readConfigFile = require("../playwright/readConfigFile");
+function matchesPattern(filename, pattern) {
+  const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+  return regex.test(filename);
+}
+function findGeneratorFiles(dir, pattern, results = []) {
   const entries = _fs.default.readdirSync(dir, {
     withFileTypes: true
   });
   for (const entry of entries) {
+    const fullPath = _path.default.join(dir, entry.name);
     if (entry.isDirectory()) {
-      const fullPath = _path.default.join(dir, entry.name);
-      if (entry.name === 'data-generators') {
-        results.push(fullPath);
-      } else {
-        findDataGeneratorDirs(fullPath, results);
-      }
+      findGeneratorFiles(fullPath, pattern, results);
+    } else if (matchesPattern(entry.name, pattern)) {
+      results.push(fullPath);
     }
   }
   return results;
@@ -32,26 +35,25 @@ function validateGenerators(modulesRoot) {
       duplicates: []
     };
   }
+  const {
+    generatorFilePattern: pattern = '*.generators.json'
+  } = (0, _readConfigFile.generateConfigFromFile)();
   const generatorMap = {};
-  const dataGenDirs = findDataGeneratorDirs(modulesRoot);
-  for (const dataGenDir of dataGenDirs) {
-    const jsonFiles = _fs.default.readdirSync(dataGenDir).filter(file => file.endsWith('.json'));
-    for (const file of jsonFiles) {
-      const filePath = _path.default.join(dataGenDir, file);
-      try {
-        const data = _fs.default.readFileSync(filePath, 'utf8');
-        const generatorObj = JSON.parse(data);
-        if (generatorObj.generators) {
-          for (const name of Object.keys(generatorObj.generators)) {
-            if (!generatorMap[name]) {
-              generatorMap[name] = [];
-            }
-            generatorMap[name].push(filePath);
+  const generatorFiles = findGeneratorFiles(modulesRoot, pattern);
+  for (const filePath of generatorFiles) {
+    try {
+      const data = _fs.default.readFileSync(filePath, 'utf8');
+      const generatorObj = JSON.parse(data);
+      if (generatorObj.generators) {
+        for (const name of Object.keys(generatorObj.generators)) {
+          if (!generatorMap[name]) {
+            generatorMap[name] = [];
           }
+          generatorMap[name].push(filePath);
         }
-      } catch (err) {
-        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to parse generator file: ${filePath} - ${err.message}`);
       }
+    } catch (err) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to parse generator file: ${filePath} - ${err.message}`);
     }
   }
   const duplicates = Object.entries(generatorMap).filter(([, files]) => files.length > 1).map(([name, files]) => ({
@@ -72,7 +74,7 @@ function validateGenerators(modulesRoot) {
     };
   }
   const generatorCount = Object.keys(generatorMap).length;
-  _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `Generator validation passed. ${generatorCount} unique generators found across ${dataGenDirs.length} data-generators directories.`);
+  _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `Generator validation passed. ${generatorCount} unique generators found across ${generatorFiles.length} generator files.`);
   return {
     valid: true,
     duplicates: []

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

@@ -1,13 +1,27 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _CleanupTracker = _interopRequireDefault(require("../../dataGenerator/CleanupTracker"));
+var _DataCleanup = _interopRequireDefault(require("../../dataGenerator/DataCleanup"));
 const cacheMap = new Map();
 var _default = exports.default = {
   // eslint-disable-next-line no-empty-pattern
   cacheLayer: async ({}, use) => {
     await use(cacheMap);
+  },
+  // eslint-disable-next-line no-empty-pattern
+  cleanupTracker: async ({}, use) => {
+    const tracker = new _CleanupTracker.default();
+    await use(tracker);
+    const entries = tracker.getEntries();
+    if (entries.length > 0) {
+      const cleanup = new _DataCleanup.default();
+      await cleanup.cleanup(entries);
+    }
+    tracker.clear();
   }
 };

package/build/core/playwright/readConfigFile.js

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

package/npm-shrinkwrap.json

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

package/package.json

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