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

package/AUTO_CLEANUP_PLAN.md

@@ -1,14 +1,19 @@
-# Data Generator System — Design & Constraints
+# Data Generator System — Design & Current State
 
 ## 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`)
+- Framework builds a **global generator index** at first use — scans all `*.generators.json` files under `modules/`
 - Generator names must be **unique across the entire UAT suite**
 - `ZDTestingFramework validate` checks for duplicate generator names before test run
+- Data generated using **org-level OAuth credentials** (org-oauth) by default
+- When scenario runs under a non-admin profile (`@profile_agent`), data generation still uses org-level `data-generator` — falls back automatically if profile has no own credentials
+
+### Generator File Convention
+- **Pattern:** `*.generators.json` (configurable via `generatorFilePattern` in `uat.config.js`)
+- **Location:** anywhere under `modules/` — discovered globally via recursive scan
+- **Examples:** `ticket.generators.json`, `account.generators.json`, `webhook.generators.json`
 
 ### Generator JSON Structure
 ```json
@@ -20,52 +25,73 @@
                 "name": "stepName",
                 "generatorOperationId": "support.Module.operationName",
                 "dataPath": "$.response.body:$",
-                "params": { "key": "$previousStep.value" },
-                "cleanup": { ... }
+                "params": { "key": "$previousStep.value" }
             }
         ]
     }
 }
 ```
 
+### Discovery Mechanism
+- **Index-based** — built once, O(1) lookups
+- `#getModulesRoot()` uses `configConstants.TEST_SLICE_FOLDER + stage + 'modules'` (deterministic)
+- Scans recursively for files matching `generatorFilePattern` (default: `*.generators.json`)
+- First generator name match wins (no duplicates enforced by validator)
+
+### Profile Resolution for Data Generation
+- **Default (no `using` profile):** Uses org-level `data-generator` from edition JSON. If scenario profile (e.g., `@profile_agent`) has no `data-generator`, falls back to org-level via `getListOfActors()`.
+- **Explicit profile (`using "agent" profile`):** Resolves that profile's credentials via `getUserForSelectedEditionAndProfile()`.
+
 ### 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
-```
+| **Unique generator names** | Generator names must be unique across all `*.generators.json` files |
+| **Global discovery** | Framework scans entire `modules/` tree — generators in any module are accessible from any feature file |
+| **File pattern** | Configurable via `generatorFilePattern` in `uat.config.js` (default: `*.generators.json`) |
+| **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 between steps |
+| **dataPath extraction** | `dataPath` uses JSONPath to extract specific fields from DG service response |
+| **Cached response** | Generated data is cached via `cacheLayer.set(entityName, response.data)` for use in subsequent steps |
+| **Org-level auth fallback** | If profile has no `data-generator`, org-level config from edition JSON is used automatically |
 
 ---
 
-# Auto-Cleanup Generated Test Data After Scenario
+## Current Generators
+
+| Generator | File | Steps | Used By |
+|---|---|---|---|
+| `TicketWithDepartment` | `Ticket/data-generators/ticket.generators.json` | getDepartments → createProduct → createTicket | 452+ scenarios |
+| `TicketBasic` | `Ticket/data-generators/ticket.generators.json` | getDepartments → createTicket (no product) | Express/Free editions |
+| `CreateAccountRecord` | `Account/data-generators/account.generators.json` | createAccount | 37 scenarios |
+| `CreateContactRecord` | `Contact/data-generators/contact.generators.json` | createContact | 42 scenarios |
+| `CreateContractRecord` | `Contract/DV/Subtabs/*/data-generators/contract.generators.json` | getDepartments → createAccount → createContract | 4 scenarios |
+| `CreateWebhookRecord` | `Webhooks/List/data-generators/webhook.generators.json` | createWebhook (with default subscriptions) | Webhook scenarios |
+| `ProductWithDepartment` | `Search/products/data-generators/products.generators.json` | getDepartments → createProduct | Product/Search scenarios |
 
-## 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.
+## Auto-Cleanup — Design (Not Yet Implemented)
 
-**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.
+### Status
+- **V1 implemented then removed** in `0.0.47` — CleanupTracker + DataCleanup were too tightly coupled
+- **V2 planned** — proper redesign needed
 
----
+### Why Cleanup Was Removed
+1. `cleanupTracker` fixture added complexity to all step definitions (extra parameter)
+2. Cleanup ran inside fixture teardown — failures were hard to debug
+3. REST API cleanup needed auth that wasn't available in the cleanup context
+4. No way to control cleanup order for cross-entity dependencies
+
+### V2 Design Principles
+1. **Cleanup config stays in generator JSON** — `cleanup` property on each step (same as V1)
+2. **Separate cleanup phase** — not in fixture teardown, but as explicit post-scenario hook
+3. **Auth-aware** — cleanup uses the same `actorInfo` that created the data
+4. **Configurable** — cleanup can be disabled per scenario or globally
+5. **Non-blocking** — cleanup failures never fail the test
 
-## Three Cleanup Types
+### Cleanup Types (unchanged from V1 design)
 
-### Type 1: `oas` — DG service delete (OAS supported)
+#### Type 1: `oas` — DG service delete
 ```json
 "cleanup": {
     "type": "oas",
@@ -74,7 +100,7 @@ The framework generates test data (contacts, tickets, accounts, etc.) via the DG
 }
 ```
 
-### Type 2: `api` — Direct REST API (OAS not supported, DELETE)
+#### Type 2: `api` — Direct REST API DELETE
 ```json
 "cleanup": {
     "type": "api",
@@ -84,7 +110,7 @@ The framework generates test data (contacts, tickets, accounts, etc.) via the DG
 }
 ```
 
-### Type 3: `api` — Disable instead of delete (PATCH)
+#### Type 3: `api` — Disable via PATCH
 ```json
 "cleanup": {
     "type": "api",
@@ -95,238 +121,51 @@ The framework generates test data (contacts, tickets, accounts, etc.) via the DG
 }
 ```
 
-### No cleanup — read-only operations
+#### No cleanup — read-only operations
 Steps without `cleanup` property are skipped (e.g., `getDepartments`).
 
----
+### V2 Implementation Plan
 
-## Full Generator JSON Examples
+1. **CleanupManager** (replaces CleanupTracker + DataCleanup)
+   - Single class managing both tracking and execution
+   - Runs after scenario via `testSetup` hook (not fixture teardown)
+   - Uses `actorInfo` from the generation step for auth
 
-### 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"
-                }
-            }
-        ]
-    }
-}
-```
+2. **Config flag** in `uat.config.js`:
+   ```javascript
+   autoCleanup: true,  // default: true
+   cleanupTimeout: 30000  // per-entity timeout
+   ```
 
-### 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 }
-                }
-            }
-        ]
-    }
-}
-```
+3. **Per-scenario opt-out** via tag:
+   ```gherkin
+   @skip_cleanup
+   Scenario: Test that needs data to persist
+   ```
 
-### 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"
-                }
-            }
-        ]
-    }
-}
-```
+4. **Cleanup order**: reverse of creation (dependent entities first)
 
 ---
 
-## 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:
+## Seed Data System — Design (Planned)
 
-- **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)
+See `SEED_DATA_PLAN.md` in the consumer repo for the full design.
 
-This is a core Playwright design principle — fixtures always clean up after themselves.
+### Summary
+- **Edition-scoped** — data maps to edition tiers, not portal names
+- **Profile-based** — support creating data as specific profiles (agent login)
+- **OAS + REST** — both API types supported
+- **Runs before scenarios** — in `page.js` fixture after login
+- **Idempotent** — skips existing data, creates only missing
 
 ---
 
-## 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.
-
----
+## Multi-DC Portability — Design (Planned)
 
-## Verification
+See `MULTI_DC_STRATEGY.md` in the consumer repo for the full design.
 
-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)
+### Summary
+- **`capability` field** on each portal for DC-agnostic resolution
+- **Department aliases** in portal config for cross-DC mapping
+- **Framework resolves** by `capability` first, `orgName` fallback
+- **Same feature files** work across all DCs

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

@@ -1,19 +1,19 @@
 import { createBdd , test } from '@zohodesk/testinglibrary';
-import { generateAndCacheTestData } from './DataGeneratorStepsHelper';  
+import { generateAndCacheTestData } from './DataGeneratorStepsHelper';
 
 const { Given } = createBdd();
 
-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 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 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 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 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 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 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);
+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);
 });

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

@@ -1,30 +1,35 @@
 import { test } from '@zohodesk/testinglibrary';
 import DataGenerator from '@zohodesk/testinglibrary/DataGenerator';
- import {getUserForSelectedEditionAndProfile} from '@zohodesk/testinglibrary/helpers'
+import {getUserForSelectedEditionAndProfile, getListOfActors} from '@zohodesk/testinglibrary/helpers'
 
 const dataGenerator = new DataGenerator();
 
-export async function generateAndCacheTestData(executionContext, type, identifier, dataTable, cacheLayer, entityName, profile = null, cleanupTracker = null) {
+export async function generateAndCacheTestData(executionContext, type, identifier, dataTable, cacheLayer, entityName, profile = null) {
     let actorInfo;
     const testInfo = test.info();
     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() : []);
-    await cacheLayer.set(entityName, response.data);
 
-    if (cleanupTracker) {
-        cleanupTracker.track({
-            entityName,
-            generators,
-            cachedData: response.data,
-            actorInfo
-        });
+    const { response, generators } = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : []);
+    if (cacheLayer._trackForCleanup) {
+        cacheLayer._trackForCleanup(entityName, response.data, generators, actorInfo);
+    } else {
+        cacheLayer.set(entityName, response.data);
     }
 }

package/build/core/dataGenerator/DataGenerator.js

@@ -9,9 +9,10 @@ var _path = _interopRequireDefault(require("path"));
 var _fs = _interopRequireDefault(require("fs"));
 var _logger = require("../../utils/logger");
 var _DataGeneratorHelper = require("./DataGeneratorHelper");
-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"); }
@@ -31,7 +32,7 @@ class DataGenerator {
       if (generatorType === 'API') {
         generators = await _assertClassBrand(_DataGenerator_brand, this, _generateAPIGenerator).call(this, generatorName);
       } else {
-        generators = await _assertClassBrand(_DataGenerator_brand, this, _getGenerator).call(this, testInfo, generatorName);
+        generators = await _assertClassBrand(_DataGenerator_brand, this, _getGenerator).call(this, generatorName);
       }
       const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
       const apiPayload = await _assertClassBrand(_DataGenerator_brand, this, _constructApiPayload).call(this, scenarioName, processedGenerators, actorInfo);
@@ -92,18 +93,13 @@ function _buildIndex(modulesRoot, 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;
+function _getModulesRoot() {
+  const stage = (0, _ConfigurationHelper.getRunStage)();
+  return _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'modules');
 }
-async function _getGenerator(testInfo, generatorName) {
+async function _getGenerator(generatorName) {
   if (!_classPrivateFieldGet(_generatorIndex, this)) {
-    const featureFilePath = await (0, _DataGeneratorHelper.getGeneratorFilePath)(testInfo.file);
-    const modulesRoot = _assertClassBrand(_DataGenerator_brand, this, _getModulesRoot).call(this, featureFilePath);
+    const modulesRoot = _assertClassBrand(_DataGenerator_brand, this, _getModulesRoot).call(this);
     const {
       generatorFilePattern: pattern = '*.generators.json'
     } = (0, _readConfigFile.generateConfigFromFile)();

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

@@ -5,23 +5,157 @@ 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 _path = _interopRequireDefault(require("path"));
+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 buildCleanupRegistry() {
+  const stage = (0, _ConfigurationHelper.getRunStage)();
+  const modulesRoot = _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'modules');
+  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}`);
+  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.json')) {
+      try {
+        const data = JSON.parse(_fs.default.readFileSync(fullPath, 'utf8'));
+        for (const [operationId, config] of Object.entries(data)) {
+          if (!registry[operationId]) {
+            registry[operationId] = config;
+          }
+        }
+      } catch (err) {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to parse cleanup file: ${fullPath} - ${err.message}`);
+      }
+    }
+  }
+}
+function extractId(cachedData, idPath) {
+  const result = _jsonpath.default.query(cachedData, idPath);
+  if (result.length === 0) {
+    throw new Error(`Could not extract ID using path "${idPath}"`);
+  }
+  return result[0];
+}
+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: {
+        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;
+  await (0, _DataGeneratorHelper.makeRequest)(process.env.DG_SERVICE_DOMAIN + process.env.DG_SERVICE_API_PATH, payload);
+}
+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);
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(`${config.method} ${config.apiPath} - status: ${response.status}, body: ${errorBody}`);
+  }
+}
 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);
+    const cache = new Map();
+    const cleanupEntries = [];
+    cache._trackForCleanup = (entityName, data, generators, actorInfo) => {
+      cache.set(entityName, data);
+      cleanupEntries.push({
+        entityName,
+        data,
+        generators,
+        actorInfo
+      });
+    };
+    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();
+    }
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup started: ${cleanupEntries.length} entities to process`);
+    let cleaned = 0;
+    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;
+        }
+        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);
+          }
+          cleaned++;
+          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `Cleanup success: ${step.name} (id: ${entityId})`);
+        } catch (err) {
+          failed++;
+          _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Cleanup failed: ${step.name} — ${err.message}`);
+        }
+      }
     }
-    tracker.clear();
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Cleanup completed: ${cleaned} cleaned, ${skipped} skipped (no cleanup rule), ${failed} failed`);
+    cleanupEntries.length = 0;
+    cache.clear();
   }
 };

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

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

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

package/npm-shrinkwrap.json

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

package/package.json

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

package/build/core/dataGenerator/CleanupTracker.js

@@ -1,29 +0,0 @@
-"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

@@ -1,98 +0,0 @@
-"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;