@zohodesk/testinglibrary 4.1.4 → 4.1.5

package/README.md

@@ -17,6 +17,14 @@
 
      - npm run report
 
+
+### v4.1.5/v3.3.3 - 19-06-2026
+
+#### Refactor
+- Authenticator module refactored to use static imports instead of dynamic imports
+- Removed unnecessary `extends Authenticator` from concrete authenticator classes (`JWTauthenticator`, `OAuthAuthenticator`, `OrgOAuthAuthenticator`, `CookieAuthenticator`) to eliminate circular dependency
+- Unit test cases updated to align with actual source behavior
+
 ### v4.1.4/v3.3.3 - 18-06-2026
 
 #### Bugfix

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

@@ -4,16 +4,16 @@ 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);
+    await generateAndCacheTestData({ executionContext, type: "template", identifier: generatorName, dataTable, cacheLayer, entityName, page });
 });
 
 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);
+    await generateAndCacheTestData({ executionContext, type: "API", identifier: operationId, dataTable, cacheLayer, entityName, page });
 });
 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);
+    await generateAndCacheTestData({ executionContext, type: "template", identifier: generatorName, dataTable, cacheLayer, entityName, profile, page });
 });
 
 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);
-});
+    await generateAndCacheTestData({ executionContext, type: "API", identifier: operationId, dataTable, cacheLayer, entityName, profile, page });
+});

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, page = null }) {
     let actorInfo;
     const testInfo = test.info();
     const scenarioName = testInfo.title.split('/').pop() || 'Unknown Scenario';
@@ -16,6 +16,6 @@ export async function generateAndCacheTestData(executionContext, type, identifie
         actorInfo = executionContext.actorInfo;
     }
     
-    const generatedData = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : []);
+    const generatedData = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : [], page);
     await cacheLayer.set(entityName, generatedData.data);
 }

package/build/core/dataGenerator/DataGenerator.js

@@ -9,6 +9,7 @@ var _path = _interopRequireDefault(require("path"));
 var _fs = _interopRequireDefault(require("fs"));
 var _logger = require("../../utils/logger");
 var _DataGeneratorHelper = require("./DataGeneratorHelper");
+var _Authenticator = _interopRequireDefault(require("./authenticator/Authenticator.js"));
 var _helpers = require("@zohodesk/testinglibrary/helpers");
 var _DataGeneratorError = require("./DataGeneratorError");
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
@@ -19,7 +20,7 @@ class DataGenerator {
   constructor() {
     _classPrivateMethodInitSpec(this, _DataGenerator_brand);
   }
-  async generate(testInfo, actorInfo, generatorType, generatorName, scenarioName, dataTable) {
+  async generate(testInfo, actorInfo, generatorType, generatorName, scenarioName, dataTable, page = null) {
     try {
       let generators;
       if (generatorType === 'API') {
@@ -28,7 +29,7 @@ class DataGenerator {
         generators = await _assertClassBrand(_DataGenerator_brand, this, _getGenerator).call(this, testInfo, generatorName);
       }
       const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
-      const apiPayload = await _assertClassBrand(_DataGenerator_brand, this, _constructApiPayload).call(this, scenarioName, processedGenerators, actorInfo);
+      const apiPayload = await _assertClassBrand(_DataGenerator_brand, this, _constructApiPayload).call(this, scenarioName, processedGenerators, actorInfo, page);
       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;
@@ -72,12 +73,12 @@ async function _generateAPIGenerator(operationId) {
     name: operationId
   }];
 }
-async function _constructApiPayload(scenarioName, processedGenerators, actorInfo) {
+async function _constructApiPayload(scenarioName, processedGenerators, actorInfo, page = null) {
   const dataGeneratorObj = actorInfo['data-generator'];
   if (!dataGeneratorObj) {
     throw new _DataGeneratorError.DataGeneratorConfigurationError(`Data Generator configuration is missing for the profile: ${actorInfo['profile']}`);
   }
-  const apiPayload = {
+  let apiPayload = {
     scenario_name: scenarioName,
     data_generation_templates: processedGenerators,
     ...dataGeneratorObj
@@ -94,6 +95,10 @@ async function _constructApiPayload(scenarioName, processedGenerators, actorInfo
     environmentDetails.host = domainUrl.origin;
   }
   apiPayload.environmentDetails = environmentDetails;
+
+  // Only perform auth augmentation via Authenticator
+  apiPayload = await new _Authenticator.default().constructPayload(apiPayload, actorInfo, page);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Final API Payload after authentication augmentation: ${JSON.stringify(apiPayload)}`);
   return apiPayload;
 }
 var _default = exports.default = DataGenerator;

package/build/core/dataGenerator/DataGeneratorError.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.GeneratorError = exports.DataGeneratorError = exports.DataGeneratorConfigurationError = void 0;
+exports.GeneratorError = exports.DataGeneratorError = exports.DataGeneratorConfigurationError = exports.AuthenticationError = void 0;
 class DataGeneratorError extends Error {
   constructor(message) {
     super(message);
@@ -47,4 +47,14 @@ class GeneratorError extends DataGeneratorError {
     }
   }
 }
-exports.GeneratorError = GeneratorError;
+exports.GeneratorError = GeneratorError;
+class AuthenticationError extends DataGeneratorError {
+  constructor(message) {
+    super(message);
+    this.name = 'AuthenticationError';
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, AuthenticationError);
+    }
+  }
+}
+exports.AuthenticationError = AuthenticationError;

package/build/core/dataGenerator/authenticator/Authenticator.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+var _JWTauthenticator = _interopRequireDefault(require("./JWTauthenticator.js"));
+var _OAuthAuthenticator = _interopRequireDefault(require("./OAuthAuthenticator.js"));
+var _OrgOAuthAuthenticator = _interopRequireDefault(require("./OrgOAuthAuthenticator.js"));
+var _CookieAuthenticator = _interopRequireDefault(require("./CookieAuthenticator.js"));
+class Authenticator {
+  // Only route authentication augmentations; do not modify environment or base payload here.
+  async constructPayload(apiPayload, actorInfo, page = null) {
+    var _actorInfo$dataGener;
+    const authenticationLoaders = {
+      'jwt-auth': () => new _JWTauthenticator.default(),
+      'oauth2': () => new _OAuthAuthenticator.default(),
+      'org-oauth': () => new _OrgOAuthAuthenticator.default(),
+      'cookie-auth': () => new _CookieAuthenticator.default()
+    };
+    const authentications = (actorInfo === null || actorInfo === void 0 || (_actorInfo$dataGener = actorInfo['data-generator']) === null || _actorInfo$dataGener === void 0 || (_actorInfo$dataGener = _actorInfo$dataGener.account) === null || _actorInfo$dataGener === void 0 ? void 0 : _actorInfo$dataGener.authentications) || [];
+    const authenticationTypes = authentications.map(auth => String(auth).toLowerCase()).filter(Boolean);
+    for (const authenticationType of authenticationTypes) {
+      const authenticatorLoader = authenticationLoaders[authenticationType];
+      if (!authenticatorLoader) {
+        throw new _DataGeneratorError.AuthenticationError(`Unknown authentication type: "${authenticationType}". Supported types are: ${Object.keys(authenticationLoaders).join(', ')}`);
+      }
+      const authenticatorInstance = await authenticatorLoader();
+      apiPayload = await authenticatorInstance.constructPayload(apiPayload, actorInfo, page);
+      break;
+    }
+    return apiPayload;
+  }
+}
+exports.default = Authenticator;

package/build/core/dataGenerator/authenticator/CookieAuthenticator.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cookieAuthConfig = require("./cookieAuthConfig.js");
+var _DataGeneratorError = require("../DataGeneratorError.js");
+/**
+ * CookieAuthenticator prepares the payload for cookie-based authentication.
+ * It extracts cookies from the browser page context and attaches them
+ * as cookieAuthHeaders in the account block for the data generator service.
+ */
+class CookieAuthenticator {
+  async constructPayload(apiPayload, actorInfo, page = null) {
+    if (!page) {
+      throw new _DataGeneratorError.AuthenticationError('Cookie authentication failed: "page" is required but was not provided');
+    }
+    const {
+      csrfHeaderName
+    } = _cookieAuthConfig.COOKIE_AUTH_CONFIG;
+    const {
+      csrfToken,
+      cookieString
+    } = await _getCookies.call(CookieAuthenticator, page);
+    apiPayload.account.authHeaders = {
+      Cookie: cookieString,
+      [csrfHeaderName]: csrfToken
+    };
+    return apiPayload;
+  }
+}
+async function _getCookies(page) {
+  const {
+    csrfCookieName,
+    csrfParamName
+  } = _cookieAuthConfig.COOKIE_AUTH_CONFIG;
+  const context = page.context();
+  const pageUrl = new URL(page.url());
+  const currentDomain = pageUrl.hostname;
+  const cookies = await context.cookies([page.url()]);
+  const csrfCookies = cookies.filter(cookie => cookie.domain.includes(currentDomain) && cookie.name === csrfCookieName);
+  return {
+    csrfToken: csrfCookies.map(c => `${csrfParamName}=${c.value}`).join('; '),
+    cookieString: cookies.map(c => `${c.name}=${c.value}`).join('; ')
+  };
+}
+var _default = exports.default = CookieAuthenticator;

package/build/core/dataGenerator/authenticator/JWTauthenticator.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+/**
+ * JWTauthenticator constructs payload by fetching a JWT access token
+ * from the authenticator app and attaching it to the account.jwt config.
+ */
+class JWTauthenticator {
+  async constructPayload(apiPayload, actorInfo) {
+    const account = actorInfo['data-generator'].account;
+    if (!account) {
+      throw new _DataGeneratorError.AuthenticationError('JWT authentication failed: "account" is missing in actor configuration');
+    }
+    const jwtConf = account['jwt-oauth'];
+    if (!jwtConf) {
+      throw new _DataGeneratorError.AuthenticationError('JWT authentication failed: "jwt-oauth" is missing in actor configuration');
+    }
+
+    // Build payload for authenticator service
+    const userToken = encodeURIComponent((actorInfo === null || actorInfo === void 0 ? void 0 : actorInfo.email) || '');
+    const jwtAuthUrl = process.env.DG_JWT_AUTH_URL;
+    const responseType = jwtConf.response_type;
+    const clientId = jwtConf.client_id;
+    const tokenUrl = jwtConf.token_url;
+    const domainUrl = process.env.DG_DOMAIN_URL;
+    const authPayload = {
+      user_token: userToken,
+      jwt_secret: jwtConf.jwt_secret,
+      jwt_auth_url: jwtAuthUrl,
+      response_type: responseType,
+      client_id: clientId,
+      token_url: tokenUrl,
+      domain_url: domainUrl
+    };
+    const authenticatorApi = process.env.DG_JWT_AUTHENTICATOR_API;
+    const resp = await fetch(authenticatorApi, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(authPayload)
+    });
+    if (!resp.ok) {
+      const errorBody = await resp.text();
+      throw new Error(`JWT authenticator error! status: ${resp.status}, body: ${errorBody}`);
+    }
+    const json = await resp.json();
+    const accessToken = json === null || json === void 0 ? void 0 : json.access_token;
+    if (!accessToken) {
+      throw new Error('JWT authenticator did not return access_token');
+    }
+
+    // Attach access token to authHeaders so downstream API calls can use it directly
+    apiPayload.account = apiPayload.account || {};
+    apiPayload.account.authHeaders = apiPayload.account.authHeaders || {};
+    apiPayload.account.authHeaders.Authorization = `Zoho-oauthtoken ${accessToken}`;
+    return apiPayload;
+  }
+}
+var _default = exports.default = JWTauthenticator;

package/build/core/dataGenerator/authenticator/OAuthAuthenticator.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+/**
+ * OAuthAuthenticator prepares the payload for OAuth2-based authentication.
+ * It ensures oauth2 config is present in the account block so the
+ * data generator service can use it.
+ */
+class OAuthAuthenticator {
+  async constructPayload(apiPayload, actorInfo) {
+    const account = actorInfo['data-generator'].account;
+    if (!account) {
+      throw new _DataGeneratorError.AuthenticationError('OAuth2 authentication failed: "account" is missing in actor configuration');
+    }
+    if (!account.oauth2) {
+      throw new _DataGeneratorError.AuthenticationError('OAuth2 authentication failed: "oauth2" is missing in actor configuration');
+    }
+    apiPayload.account.oauth2 = account.oauth2;
+    return apiPayload;
+  }
+}
+var _default = exports.default = OAuthAuthenticator;

package/build/core/dataGenerator/authenticator/OrgOAuthAuthenticator.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+/**
+ * OrgOAuthAuthenticator prepares the payload for org_oauth authentication.
+ * It ensures org_oauth config is present in the account block so the
+ * data generator service can use it.
+ */
+class OrgOAuthAuthenticator {
+  async constructPayload(apiPayload, actorInfo) {
+    const account = actorInfo['data-generator'].account;
+    if (!account) {
+      throw new _DataGeneratorError.AuthenticationError('OrgOAuth authentication failed: "account" is missing in actor configuration');
+    }
+    if (!account.org_oauth) {
+      throw new _DataGeneratorError.AuthenticationError('OrgOAuth authentication failed: "org_oauth" is missing in actor configuration');
+    }
+    apiPayload.account.org_oauth = account.org_oauth;
+    return apiPayload;
+  }
+}
+var _default = exports.default = OrgOAuthAuthenticator;

package/build/core/dataGenerator/authenticator/cookieAuthConfig.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.COOKIE_AUTH_CONFIG = void 0;
+const COOKIE_AUTH_CONFIG = exports.COOKIE_AUTH_CONFIG = {
+  csrfHeaderName: 'X-ZCSRF-TOKEN',
+  csrfCookieName: 'crmcsr',
+  csrfParamName: 'crmcsrfparam'
+};

package/build/test/core/dataGenerator/authenticator/__tests__/Authenticator.test.js

@@ -0,0 +1,88 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _Authenticator = _interopRequireDefault(require("../../../../../../src/core/dataGenerator/authenticator/Authenticator"));
+describe('Authenticator', () => {
+  it('should throw an error when an unknown authentication type is present', async () => {
+    const authenticator = new _Authenticator.default();
+    const apiPayload = {
+      account: {
+        name: 'sample'
+      }
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          authentications: ['apikey', 'basic']
+        }
+      }
+    };
+    await expect(authenticator.constructPayload(apiPayload, actorInfo)).rejects.toThrow('Unknown authentication type: "apikey"');
+  });
+  it('should route oauth2 authentication and merge oauth2 config into payload', async () => {
+    const authenticator = new _Authenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          authentications: ['oauth2'],
+          oauth2: {
+            client_id: 'client_1',
+            client_secret: 'secret_1'
+          }
+        }
+      }
+    };
+    const result = await authenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.oauth2).toEqual({
+      client_id: 'client_1',
+      client_secret: 'secret_1'
+    });
+  });
+  it('should treat authentication values case-insensitively and deduplicate them', async () => {
+    const authenticator = new _Authenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          authentications: ['OAUTH2', 'oauth2', 'OAuth2'],
+          oauth2: {
+            scope: 'read'
+          }
+        }
+      }
+    };
+    const result = await authenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.oauth2).toEqual({
+      scope: 'read'
+    });
+  });
+  it('should apply only the first supported authentication type', async () => {
+    const authenticator = new _Authenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          authentications: ['oauth2', 'org-oauth'],
+          oauth2: {
+            client_id: 'oauth-client'
+          },
+          org_oauth: {
+            org_id: 'org-101'
+          }
+        }
+      }
+    };
+    const result = await authenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.oauth2).toEqual({
+      client_id: 'oauth-client'
+    });
+    expect(result.account.org_oauth).toBeUndefined();
+  });
+});

package/build/test/core/dataGenerator/authenticator/__tests__/JWTauthenticator.test.js

@@ -0,0 +1,129 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _JWTauthenticator = _interopRequireDefault(require("../../../../../../src/core/dataGenerator/authenticator/JWTauthenticator"));
+describe('JWTauthenticator', () => {
+  let fetchMock;
+  beforeEach(() => {
+    fetchMock = jest.fn();
+    global.fetch = fetchMock;
+    process.env.DG_JWT_AUTH_URL = 'https://jwt-auth.example.com';
+    process.env.DG_DOMAIN_URL = 'https://domain.example.com';
+    process.env.DG_JWT_AUTHENTICATOR_API = 'https://authenticator.example.com/jwtToken';
+  });
+  afterEach(() => {
+    delete global.fetch;
+    delete process.env.DG_JWT_AUTH_URL;
+    delete process.env.DG_DOMAIN_URL;
+    delete process.env.DG_JWT_AUTHENTICATOR_API;
+  });
+  it('should throw when jwt-oauth config is missing', async () => {
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user@example.com',
+      'data-generator': {
+        account: {}
+      }
+    };
+    await expect(jwtAuthenticator.constructPayload(apiPayload, actorInfo)).rejects.toThrow('JWT authentication failed: "jwt-oauth" is missing in actor configuration');
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+  it('should fetch jwt access token and set it in authHeaders', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        access_token: 'access-token-123'
+      })
+    });
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user.one@example.com',
+      'data-generator': {
+        account: {
+          'jwt-oauth': {
+            jwt_secret: 'jwt-secret',
+            response_type: 'token',
+            client_id: '12345.client-id',
+            token_url: 'https://token.example.com/12345/oauth'
+          }
+        }
+      }
+    };
+    const result = await jwtAuthenticator.constructPayload(apiPayload, actorInfo);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith('https://authenticator.example.com/jwtToken', expect.objectContaining({
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }));
+    const requestBody = JSON.parse(fetchMock.mock.calls[0][1].body);
+    expect(requestBody).toEqual(expect.objectContaining({
+      user_token: encodeURIComponent('user.one@example.com'),
+      jwt_secret: 'jwt-secret',
+      jwt_auth_url: 'https://jwt-auth.example.com',
+      response_type: 'token',
+      client_id: '12345.client-id',
+      token_url: 'https://token.example.com/12345/oauth',
+      domain_url: 'https://domain.example.com'
+    }));
+    expect(result.account.authHeaders.Authorization).toBe('Zoho-oauthtoken access-token-123');
+  });
+  it('should throw a descriptive error when authenticator API returns non-ok response', async () => {
+    fetchMock.mockResolvedValue({
+      ok: false,
+      status: 500,
+      text: async () => 'internal error'
+    });
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user@example.com',
+      'data-generator': {
+        account: {
+          'jwt-oauth': {
+            jwt_secret: 'jwt-secret',
+            response_type: 'token',
+            client_id: '12345.client-id',
+            token_url: 'https://token.example.com/12345/oauth'
+          }
+        }
+      }
+    };
+    await expect(jwtAuthenticator.constructPayload(apiPayload, actorInfo)).rejects.toThrow('JWT authenticator error! status: 500, body: internal error');
+  });
+  it('should throw when authenticator response has no access_token', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        token_type: 'Bearer'
+      })
+    });
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user@example.com',
+      'data-generator': {
+        account: {
+          'jwt-oauth': {
+            jwt_secret: 'jwt-secret',
+            response_type: 'token',
+            client_id: '12345.client-id',
+            token_url: 'https://token.example.com/12345/oauth'
+          }
+        }
+      }
+    };
+    await expect(jwtAuthenticator.constructPayload(apiPayload, actorInfo)).rejects.toThrow('JWT authenticator did not return access_token');
+  });
+});

package/build/test/core/dataGenerator/authenticator/__tests__/OAuthAuthenticator.test.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _OAuthAuthenticator = _interopRequireDefault(require("../../../../../../src/core/dataGenerator/authenticator/OAuthAuthenticator"));
+describe('OAuthAuthenticator', () => {
+  it('should assign oauth2 from actor info into payload account', async () => {
+    const oauthAuthenticator = new _OAuthAuthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          oauth2: {
+            client_id: 'new-client',
+            scope: 'tickets.read'
+          }
+        }
+      }
+    };
+    const result = await oauthAuthenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.oauth2).toEqual({
+      client_id: 'new-client',
+      scope: 'tickets.read'
+    });
+  });
+  it('should throw when oauth2 is absent in actor configuration', async () => {
+    const oauthAuthenticator = new _OAuthAuthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {}
+      }
+    };
+    await expect(oauthAuthenticator.constructPayload(apiPayload, actorInfo)).rejects.toThrow('OAuth2 authentication failed: "oauth2" is missing in actor configuration');
+  });
+});

package/build/test/core/dataGenerator/authenticator/__tests__/OrgOAuthAuthenticator.test.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _OrgOAuthAuthenticator = _interopRequireDefault(require("../../../../../../src/core/dataGenerator/authenticator/OrgOAuthAuthenticator"));
+describe('OrgOAuthAuthenticator', () => {
+  it('should assign org_oauth from actor info into payload account', async () => {
+    const orgOAuthAuthenticator = new _OrgOAuthAuthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          org_oauth: {
+            org_id: 'org-1001',
+            region: 'us'
+          }
+        }
+      }
+    };
+    const result = await orgOAuthAuthenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.org_oauth).toEqual({
+      org_id: 'org-1001',
+      region: 'us'
+    });
+  });
+  it('should throw when org_oauth is absent in actor configuration', async () => {
+    const orgOAuthAuthenticator = new _OrgOAuthAuthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {}
+      }
+    };
+    await expect(orgOAuthAuthenticator.constructPayload(apiPayload, actorInfo)).rejects.toThrow('OrgOAuth authentication failed: "org_oauth" is missing in actor configuration');
+  });
+});

package/build/test/core/playwright/__tests__/validateFeature.test.js

@@ -13,7 +13,10 @@ jest.mock('../../../../core/playwright/helpers/parseUserArgs', () => ({
 }));
 jest.mock('../../../../core/playwright/readConfigFile');
 jest.mock('../../../../core/playwright/tagProcessor');
-jest.mock('../../../../core/playwright/test-runner');
+jest.mock('../../../../core/playwright/test-runner', () => ({
+  __esModule: true,
+  runPreprocessing: jest.fn()
+}));
 jest.mock('../../../../utils/logger', () => ({
   __esModule: true,
   Logger: {

package/build/test/core/playwright/runner/__tests__/RunnerHelper.test.js

@@ -3,6 +3,9 @@
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _RunnerHelper = _interopRequireDefault(require("../../../../../core/playwright/runner/RunnerHelper"));
 var _SpawnRunner = _interopRequireDefault(require("../../../../../core/playwright/runner/SpawnRunner"));
+jest.mock('../../../../../core/playwright/setup/config-utils', () => ({
+  getBrowsersList: jest.fn().mockReturnValue([])
+}));
 describe('RunnerHelper', () => {
   describe('createRunner', () => {
     it('should throw error on invalid runner type', () => {

package/build/test/core/playwright/runner/__tests__/SpawnRunner.test.js

@@ -6,6 +6,9 @@ var _Runner = _interopRequireDefault(require("../../../../../core/playwright/run
 var _Configuration = _interopRequireDefault(require("../../../../../core/playwright/configuration/Configuration"));
 jest.mock('child_process');
 jest.mock('../../../../../utils/logger');
+jest.mock('../../../../../core/playwright/setup/config-utils', () => ({
+  getBrowsersList: jest.fn().mockReturnValue([])
+}));
 describe('SpawnRunner', () => {
   let spawnRunner;
   const runnerObj = new _Runner.default();

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@zohodesk/testinglibrary",
-  "version": "4.1.4",
+  "version": "4.1.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@zohodesk/testinglibrary",
-      "version": "4.1.4",
+      "version": "4.1.5",
       "hasInstallScript": true,
       "license": "ISC",
       "dependencies": {
@@ -4265,12 +4265,12 @@
       "peer": true
     },
     "node_modules/@types/node": {
-      "version": "25.9.3",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.9.3.tgz",
-      "integrity": "sha512-603BddQMv3pUcr4U2dhujk83N2tTDVr/34wII2B6bJy6g+8WD6yUb11jszNs0gdi4PesVWl7ABt8nYMVpnLUcg==",
+      "version": "26.0.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-26.0.0.tgz",
+      "integrity": "sha512-vf2YFi1iY9lHGwNJMs01biZFbKJkrZR1T6/MlzjhJLPdntOHLhTrDSnSVcdtvjihi4VQNlrFRIxLsDBlQpAipA==",
       "license": "MIT",
       "dependencies": {
-        "undici-types": ">=7.24.0 <7.24.7"
+        "undici-types": "~8.3.0"
       }
     },
     "node_modules/@types/prop-types": {
@@ -6996,9 +6996,9 @@
       }
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.375",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.375.tgz",
-      "integrity": "sha512-ZWP5eB4BVPW/ZYo9252hQZHZ5XavtsTgpbhcmMmRwymavC5AsLWQWBPaKMeNd2LW0KGby5HPXvj7+sr4ta5j/Q==",
+      "version": "1.5.376",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.376.tgz",
+      "integrity": "sha512-cUVA7/RvbFTEuw/i3obUwDTRIXojaxkResf+ibByPFxjc6XK3VNtcQXV0NSbAlJ0FMjcJGgftVVB4Qo184EXvA==",
       "license": "ISC"
     },
     "node_modules/emittery": {
@@ -14537,9 +14537,9 @@
       "license": "MIT"
     },
     "node_modules/undici-types": {
-      "version": "7.24.6",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.24.6.tgz",
-      "integrity": "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==",
+      "version": "8.3.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.3.0.tgz",
+      "integrity": "sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ==",
       "license": "MIT"
     },
     "node_modules/unicode-canonical-property-names-ecmascript": {
@@ -15021,9 +15021,9 @@
       "license": "ISC"
     },
     "node_modules/yargs": {
-      "version": "17.7.2",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
-      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "version": "17.7.3",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.3.tgz",
+      "integrity": "sha512-GZtjxm/J/4TSxuL3FNYjCmLktBTnIw/rVmKSIyKeYAZpmJB2ig9VauCC5xsa82GNKVKDAqpOn3KVzNt0zmrU0g==",
       "license": "MIT",
       "dependencies": {
         "cliui": "^8.0.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/testinglibrary",
-  "version": "4.1.4",
+  "version": "4.1.5",
   "main": "./build/index.js",
   "scripts": {
     "postinstall": "node bin/postinstall.js",