@zohodesk/testinglibrary 0.0.3-n20-experimental → 0.0.4-n20-experimental

package/.babelrc

@@ -18,6 +18,7 @@
   ],
   // Ignored as these are setup files needed during init script. Files inside that folder are copied not transformed
   "ignore": [
-    "./src/setup-folder-structure/samples"
+    "./src/setup-folder-structure/samples",
+    "./src/common/**"
   ]
 }

package/.gitlab-ci.yml

@@ -160,4 +160,16 @@ uat-smoketest:
     paths:
       - examples/uat/playwright-report
 
-      
+uat-multiactor:
+  stage: uat
+  script:
+    - cd examples
+    - npm install $(npm pack ../../testing-framework | tail -1)
+    - output=$(npm run uat-multiactor)
+    - echo "$output"
+    - node ../ValidateUATReport.js examples
+
+  artifacts:
+    when: always
+    paths:
+      - examples/uat/playwright-report

package/README.md

@@ -12,12 +12,84 @@
   ### Run TestCase
 
     - npm run test
+
   ### Generate Report
 
      - npm run report
 
 ## Version History
 
+### v3.2.8 - 18-09-2025
+
+### Bug fix
+
+  - Default profile switching handled in Multi actor – Improved handling of default profile switching to ensure smoother execution flow.
+
+  - QC Report tags issue fixed – Resolved an issue where QC Report tags were not displaying correctly in reports.
+
+### v3.2.7 - 10-09-2025
+
+### Bug fix
+  - Fixed a bug where the default profile page was not being handled properly in `this`.
+
+### v3.2.6 - 05-09-2025
+
+#### Feature
+
+  - Multi-actor execution support – now possible to switch between multiple profile agents within scenarios using the predefined step: - `access the {string} profile page`
+
+### Bug fix
+  - Fixed the issue where localapp and hcapp UAT were not running properly.
+
+### v3.2.5 - 28-08-2025
+
+#### Enhancement
+
+  - Removed the searchFake dependency from the project level and adopted it inside the framework, reducing project-side maintenance. use this predefined step: - `Given (a search entity)`
+
+### v3.2.4 - 29-07-2025
+
+#### Feature
+  - Data Generator steps are now supported directly via the framework.
+
+### Bug fix
+  - Feature File Root Directory not found issue fixed
+
+### v3.2.3 - 29-07-2025
+
+#### Feature
+  - Added support for running Smoke Tests in the UAT stage.
+
+### v3.2.0 - 22-06-2025
+
+#### Feature
+  - Default required spec files are now auto-imported from the library into the project.
+
+### v3.1.13 - 02-07-2025
+
+#### Enhancement
+  - Below package versions are updated in this release.
+    - @cucumber/Cucumber - 11.3.0
+    - Playwright/test - 1.53.2
+    - Playwright - 1.53.2
+    - Playwright-bdd - 8.3.1
+  - QC custom reporter changes have been adopted into the framework.
+
+### v3.1.5 - 22-05-2025
+
+#### Feature
+  - Added support for Module Based Execution UAT stage.
+
+### v3.1.4 - 12-05-2025
+
+#### Enhancement
+  - Playwright version 1.52.0 adopted in testing framework
+
+### v3.1.3 - 25-04-2025
+
+#### Enhancement
+  - Playwright version 1.51.0 adopted in testing framework
+
 ### v0.2.8 - 26-09-2024
 
 #### Feature
@@ -27,8 +99,6 @@
   - Updated the custom-reported to include the errors in tests during the executions. It will help us avoid the stage passed without the actual test execution. 
 
 
-## Version History
-
 ### v3.0.8 - 25-12-2024
 
 #### Enhancement

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

@@ -0,0 +1,19 @@
+import { createBdd , test } from '@zohodesk/testinglibrary';
+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 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, 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, executionContext}, module, entityName, operationId, profile, dataTable) => {
+    await generateAndCacheTestData(executionContext, "API", operationId, dataTable, cacheLayer, entityName, profile);
+});

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

@@ -0,0 +1,19 @@
+import { test } from '@zohodesk/testinglibrary';
+import DataGenerator from '@zohodesk/testinglibrary/DataGenerator';
+
+const dataGenerator = new DataGenerator();
+
+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) {
+        actorInfo = await dataGenerator.getDataGenUserExecutionContext(executionContext.actorInfo.edition, profile);
+    } else {
+        actorInfo = executionContext.actorInfo;
+    }
+    
+    const generatedData = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : []);
+    await cacheLayer.set(entityName, generatedData.data);
+}

package/build/common/multi-actor/steps/multiActorHandling.spec.js

@@ -0,0 +1,26 @@
+import { createBdd } from '@zohodesk/testinglibrary';
+const { BeforeScenario, Given } = createBdd();
+
+BeforeScenario(async function({ page, context, browser, cacheLayer, executionContext, actorContext }) {
+    // This will run before each scenario and set all the fixtures into this context
+    this.page = page;
+    this.context = context;
+    this.browser = browser;
+    this.cacheLayer = cacheLayer;
+    this.executionContext = executionContext;
+    this.setActor = async (role) => {
+        const userPage = actorContext.actorsObj[role];
+        if (userPage) {
+            this.page = userPage.page;
+            this.context = userPage.context;
+            this.browser = userPage.browser;
+            this.executionContext = userPage.executionContext;
+        } else {
+            throw new Error(`Actor "${role}" not found in user pages.`);
+        }
+    }
+});
+
+Given("access the {string} profile page", async function({ page }, userRole) {
+    await this.setActor(userRole);
+});

package/build/common/searchFake/helpers/rpcRequestHelper.js

@@ -0,0 +1,41 @@
+import { expect } from '@zohodesk/testinglibrary';
+
+async function executeRpcRequest(page, payload) {
+
+    const url = new URL(page.url());
+    const baseUrl = `${url.protocol}//${url.host}`;
+    const invokeURL = `${baseUrl}/api/testing/acceptanceTest/rpc/invoke`;
+    
+    try {
+        const response = await page.request.post(invokeURL, {
+            headers: {'Content-Type': 'application/json'},
+            data: payload
+        });
+
+        if (!response.ok()) {
+            throw new Error(`HTTP ${response.status()}: ${response.statusText()}`);
+        }
+
+        const responseData = await response.json();
+        expect(responseData.data).toHaveProperty('status', 'success');
+
+    } catch (error) {
+        throw error;
+    }
+}
+
+
+async function entityIdReConstructor(payload) {
+    
+    if (typeof payload !== 'object' || payload === null) {
+        throw new Error('Invalid payload. It must be a non-null object.');
+    }
+    if (!payload.arguments || typeof payload.arguments.entityId !== 'string') {
+        throw new Error('Invalid payload.arguments.entityId. It must be a non-empty string.');
+    }
+
+    payload.arguments.entityId = payload.arguments.entityId.split(',').map(id => id.trim());
+    return payload;
+}
+
+module.exports = { executeRpcRequest, entityIdReConstructor };

package/build/common/searchFake/steps/searchFake.spec.js

@@ -0,0 +1,26 @@
+import {createBdd } from '@zohodesk/testinglibrary';
+import { executeRpcRequest , entityIdReConstructor } from '../helpers/rpcRequestHelper';
+
+const { Given } = createBdd();
+
+Given('a search entity', async ({page}, dataTable)=>{
+    const data = dataTable.hashes();
+    
+    for (const row of data) {
+        
+        const { moduleName, entityId, searchString } = row;
+        const payload = {
+            className: 'applicationDriver.rpc.desk.integrations.search.SearchFakeDataPopulator',
+            methodName: 'populateSearchData',
+            arguments: {
+                module: moduleName,
+                searchString: searchString, 
+                entityId: entityId
+            }
+        };
+        await entityIdReConstructor(payload);
+
+        await executeRpcRequest(page, payload);
+    }
+    
+});

package/build/core/dataGenerator/DataGenerator.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+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");
+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 _DataGenerator_brand = /*#__PURE__*/new WeakSet();
+class DataGenerator {
+  constructor() {
+    _classPrivateMethodInitSpec(this, _DataGenerator_brand);
+  }
+  async generate(testInfo, actorInfo, generatorType, generatorName, scenarioName, dataTable) {
+    try {
+      let generators;
+      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);
+      }
+      const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
+      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;
+    } catch (error) {
+      console.error('Data Generation failed for the generator: ', generatorName, "\n\nError response :", error);
+      throw error;
+    }
+  }
+  async getDataGenUserExecutionContext(edition, profile) {
+    try {
+      const dataGenUserDetails = await (0, _helpers.getUserForSelectedEditionAndProfile)(edition, profile);
+      return dataGenUserDetails;
+    } catch (error) {
+      console.error('Error occurred while fetching data generation user details: ', error);
+      throw error;
+    }
+  }
+}
+async function _getGenerator(testInfo, generatorName) {
+  let generator = null;
+  let generatorFilePath = await (0, _DataGeneratorHelper.getGeneratorFilePath)(testInfo.file);
+  generatorFilePath = _path.default.join(generatorFilePath, "../../data-generators/generators.json");
+  if (_fs.default.existsSync(generatorFilePath)) {
+    const data = _fs.default.readFileSync(generatorFilePath, 'utf8');
+    const generatorObj = JSON.parse(data);
+    if (generatorName || generatorObj.generators) {
+      generator = generatorObj.generators[generatorName] || null;
+    }
+  }
+  if (!generator) {
+    throw new Error(`Generator "${generatorName}" could not be found in the path located at "${generatorFilePath}"`);
+  }
+  return generator;
+}
+async function _generateAPIGenerator(operationId) {
+  return [{
+    type: "dynamic",
+    generatorOperationId: operationId,
+    dataPath: "$.response.body:$",
+    name: operationId
+  }];
+}
+async function _constructApiPayload(scenarioName, processedGenerators, actorInfo) {
+  const dataGeneratorConfig = actorInfo['data-generator'] || {};
+  const apiPayload = {
+    scenario_name: scenarioName,
+    data_generation_templates: processedGenerators,
+    ...dataGeneratorConfig
+  };
+  const account = apiPayload.account;
+  if (account) {
+    account.email = actorInfo.email;
+    account.password = actorInfo.password;
+  }
+  const environmentDetails = apiPayload.environmentDetails || {};
+  if (environmentDetails) {
+    environmentDetails.iam_url = process.env.DG_IAM_DOMAIN;
+    const domainUrl = new URL(process.env.domain);
+    environmentDetails.host = domainUrl.origin;
+  }
+  apiPayload.environmentDetails = environmentDetails;
+  return apiPayload;
+}
+var _default = exports.default = DataGenerator;

package/build/core/dataGenerator/DataGeneratorHelper.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getGeneratorFilePath = getGeneratorFilePath;
+exports.makeRequest = makeRequest;
+exports.processGenerator = processGenerator;
+//Create payload for the generators
+async function processGenerator(generators, dataTable) {
+  if (!dataTable) {
+    return generators;
+  }
+  return generators.map(generator => {
+    dataTable.forEach(row => {
+      const generatorName = row.DG_API_NAME;
+      if (generatorName === generator.name) {
+        generator.params = generator.params ? generator.params : [];
+
+        // The API name row is only used for matching the template
+        // Filter out DG_API_NAME and collect other values
+        Object.entries(row).filter(([key]) => key !== 'DG_API_NAME').forEach(([key, value]) => {
+          if (value !== '') {
+            generator.params[key] = value;
+          }
+        });
+      }
+    });
+    return generator;
+  });
+}
+async function makeRequest(url, payload) {
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(`HTTP error! status: ${response.status}, body: ${errorBody}`);
+  }
+  return response.json();
+}
+async function getGeneratorFilePath(featureFile) {
+  let generatorPath = featureFile.replace(".features-gen/", "");
+  return generatorPath;
+}

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

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _logger = require("../../../utils/logger");
+var _additionalProfiles = require("../helpers/additionalProfiles");
+var _loginDefaultStepsHelper = require("../helpers/auth/loginDefaultStepsHelper");
+class ActorContext {
+  constructor() {
+    this.actorsObj = {};
+  }
+  async setup(browser, $tags, testInfo, context, page, executionContext) {
+    try {
+      const {
+        profile
+      } = executionContext.actorInfo;
+      this.actorsObj[profile] = {
+        role: profile,
+        browser,
+        context,
+        page,
+        executionContext
+      };
+      const additionalActors = (0, _additionalProfiles.additionProfiles)($tags);
+      await Promise.all(Object.entries(additionalActors).map(async ([role, actorInfo]) => {
+        let context = await browser.newContext();
+        let page = await context.newPage();
+        let ctxTestDetails = {
+          page,
+          $tags,
+          context,
+          ...actorInfo
+        };
+        await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(context, testInfo, ctxTestDetails, actorInfo);
+        this.actorsObj[role] = {
+          role,
+          browser,
+          context,
+          page,
+          executionContext: {
+            actorInfo
+          }
+        };
+      }));
+    } catch (error) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to setup additional actors:`, error);
+      throw error;
+    }
+  }
+  async cleanup() {
+    for (const actor of Object.values(this.actorsObj)) {
+      try {
+        await actor.context.close();
+      } catch (error) {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to close context for actor ${actor.role}:`, error);
+      }
+    }
+  }
+}
+var _default = exports.default = {
+  actorContext: async ({
+    page,
+    context,
+    executionContext,
+    $tags,
+    browser
+  }, use, testInfo) => {
+    const ctxObject = new ActorContext();
+    await ctxObject.setup(browser, $tags, testInfo, context, page, executionContext);
+    await use(ctxObject);
+    await ctxObject.cleanup();
+  }
+};

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

@@ -4,14 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _page = require("./page");
+var _customFixturesHelper = require("../helpers/customFixturesHelper");
 var _default = exports.default = {
   executionContext: async ({
     $tags
   }, use) => {
-    let testPortalActorDetails = {
-      actorInfo: (0, _page.getCustomAccountDetails)($tags)
-    };
-    await use(testPortalActorDetails);
+    const actorInfo = (0, _customFixturesHelper.getCustomAccountDetails)($tags);
+    await use({
+      actorInfo
+    });
   }
 };

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

@@ -12,12 +12,14 @@ var _addTags = _interopRequireDefault(require("./addTags"));
 var _i18N = _interopRequireDefault(require("./i18N"));
 var _unauthenticatedPage = _interopRequireDefault(require("./unauthenticatedPage"));
 var _executionContext = _interopRequireDefault(require("./executionContext"));
+var _actorContext = _interopRequireDefault(require("./actorContext"));
 function extractTagsFromTitle(text) {
   return text.match(/@\w+/g) || [];
 }
 function getBuiltInFixtures(bddMode) {
   let builtInFixtures = {
     ..._page.default,
+    ..._actorContext.default,
     ..._context.default,
     ..._cacheLayer.default,
     ..._i18N.default,

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

@@ -4,58 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-exports.getCustomAccountDetails = getCustomAccountDetails;
-var _auth = require("../helpers/auth");
-var _readConfigFile = require("../readConfigFile");
+var _loginDefaultStepsHelper = require("../helpers/auth/loginDefaultStepsHelper");
 /* eslint-disable global-require */
-
-//import { additionProfiles } from '../helpers/additionalProfiles';
-
-function getTagInputFromSelectedTags(tags, inputString) {
-  const selectedTag = [...tags].reverse().find(tag => tag.startsWith(inputString));
-  let tagInput = null;
-  if (selectedTag) {
-    tagInput = selectedTag.split(`${inputString}_`).pop().toLowerCase();
-  }
-  return tagInput;
-}
-function getCustomAccountDetails(tags) {
-  const tagsTobeFiltered = ['@profile', '@edition', '@beta', '@portal', '@additional_profile'];
-  const filteredTags = tags.filter(tag => tagsTobeFiltered.some(prefix => tag.startsWith(prefix)));
-  if (filteredTags && filteredTags.length > 0) {
-    const portalInfo = getTagInputFromSelectedTags(filteredTags, '@portal');
-    const betaFeature = getTagInputFromSelectedTags(filteredTags, '@beta');
-    const profileInfo = getTagInputFromSelectedTags(filteredTags, '@profile');
-    const editionInfo = getTagInputFromSelectedTags(filteredTags, '@edition');
-    const user = (0, _auth.getUserForSelectedEditionAndProfile)(editionInfo, profileInfo, betaFeature, portalInfo);
-    return user;
-  }
-  return (0, _auth.getDefaultActor)();
-}
-const {
-  testSetup
-} = (0, _readConfigFile.generateConfigFromFile)();
-async function loginSteps(pageDetail) {
-  const {
-    page
-  } = pageDetail;
-  if (testSetup.loginSteps && typeof testSetup.loginSteps === 'function') {
-    return await testSetup.loginSteps(pageDetail);
-  } else {
-    await page.goto(process.env.domain);
-  }
-}
-async function performDefaultPageSteps(testInfo) {
-  if (testSetup.page && typeof testSetup.page === 'function') {
-    await testSetup.page(testInfo);
-  }
-}
-async function verifyPageIsLoaded(testInfo) {
-  if (testSetup.validateLogin && typeof testSetup.validateLogin === 'function') {
-    return await testSetup.validateLogin(testInfo);
-  }
-  return true;
-}
 var _default = exports.default = {
   page: async ({
     context,
@@ -76,24 +26,11 @@ var _default = exports.default = {
         await context.clearCookies();
         return;
       }
-      const {
-        isAuthMode
-      } = (0, _readConfigFile.generateConfigFromFile)();
-      if (!isAuthMode) {
-        return;
-      }
-      const projectName = testInfo.project.name;
-      if (testPortalDetails && projectName !== 'setup' && projectName !== 'cleanup') {
-        await context.clearCookies();
-        await (0, _auth.performLoginSteps)(testDetails, async testInfo => {
-          return await verifyPageIsLoaded(testInfo);
-        }, loginSteps);
-        process.env.actorInfo = JSON.stringify(testPortalDetails);
-      }
+      await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(context, testInfo, testDetails, testPortalDetails);
     } catch (e) {
       console.error('Error during page', e);
     } finally {
-      await performDefaultPageSteps(testDetails);
+      await (0, _loginDefaultStepsHelper.performDefaultPageSteps)(testDetails);
       await use(page);
       await context.close();
     }

package/build/core/playwright/helpers/additionalProfiles.js

@@ -5,13 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.additionProfiles = additionProfiles;
 var _getUsers = require("./auth/getUsers");
-function additionProfiles(tags, editionInfo, betaFeature, portalInfo) {
+var _customFixturesHelper = require("./customFixturesHelper");
+function additionProfiles(tags) {
+  const {
+    editionInfo,
+    betaFeature,
+    portalInfo
+  } = (0, _customFixturesHelper.extractTagInfo)(tags);
   const additionalProfileTags = tags.filter(tag => tag.startsWith('@additional_profile_'));
-  let additionalProfileActors = [];
-  if (additionalProfileTags.length > 0 && editionInfo) {
-    additionalProfileActors = additionalProfileTags.map(tag => {
+  let additionalProfileActors = {};
+  if (additionalProfileTags.length > 0) {
+    additionalProfileTags.forEach(tag => {
       const additionalProfile = tag.replace('@additional_profile_', '');
-      return (0, _getUsers.getUserForSelectedEditionAndProfile)(editionInfo, additionalProfile, betaFeature, portalInfo);
+      const actorDetails = (0, _getUsers.getUserForSelectedEditionAndProfile)(editionInfo, additionalProfile, betaFeature, portalInfo);
+      additionalProfileActors[additionalProfile] = actorDetails;
     });
   }
   return additionalProfileActors;