@zohodesk/testinglibrary 3.2.14 → 4.0.0

package/README.md

@@ -17,20 +17,29 @@
 
      - npm run report
 
+### v3.2.15 - 14-11-2025
+
+#### Enhancement
+
+- Aborted test results are now merged into the `.last-run.json` file.  
+  This ensures that any timed-out tests are included in the next retry cycle.
+
+### v3.2.13 - 30-10-2025
+ 
+#### Enhancement
+
+- A teardown option has been introduced in the configuration to manage and clean up login sessions stored in the NFS environment.
+
+### Issue fix
+
+- Custom teardown comment provided
+
 ### v3.2.11 - 13-10-2025
  
 ### Feature
  
 - New step a search entity using {string} provided for search indexing, This step will use run time data generation response as input for the indexing
  
-### Issue fix
-- Custom teardown comment provided
- 
-### v3.2.10 - 09-10-2025
- 
-#### Enhancement
-- A teardown option has been introduced in the configuration to manage and clean up login sessions stored in the NFS environment.
-
 
 ### v3.2.9 - 26-09-2025
 
@@ -60,6 +69,7 @@
   - 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

package/build/core/jest/setup/index.js

@@ -1,3 +1,3 @@
 "use strict";
 
-require("@testing-library/jest-dom/extend-expect");
+require("@testing-library/jest-dom");

package/build/core/playwright/configuration/ConfigurationHelper.js

@@ -1,17 +1,15 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.combineConfiguration = combineConfiguration;
 exports.getApplicationConfig = getApplicationConfig;
-var _path = _interopRequireDefault(require("path"));
+exports.getRunStage = getRunStage;
 var _logger = require("../../../utils/logger");
 var _configFileNameProvider = require("../helpers/configFileNameProvider");
 var _mergeObjects = require("../helpers/mergeObjects");
 var _fs = require("fs");
-const Configuration = require("./Configuration");
 function combineConfiguration(defaultConfig, userConfiguration) {
   let configurationObj = {};
   Object.keys(userConfiguration).forEach(configKey => {
@@ -26,10 +24,10 @@ function combineConfiguration(defaultConfig, userConfiguration) {
   });
   return (0, _mergeObjects.mergeObjects)(defaultConfig, configurationObj);
 }
-function getApplicationConfig(mode) {
+function getApplicationConfig(stage, mode) {
   let filePath = "";
   try {
-    filePath = _path.default.resolve(process.cwd(), (0, _configFileNameProvider.getUATFileName)(mode));
+    filePath = (0, _configFileNameProvider.getUATFileName)(stage, mode);
     if (!(0, _fs.existsSync)(filePath)) {
       throw new Error("Exception while getting the uat file from the application - " + filePath);
     }
@@ -40,4 +38,8 @@ function getApplicationConfig(mode) {
     _logger.Logger.error(err);
     return {};
   }
+}
+function getRunStage() {
+  const stage = process.env.stage;
+  return stage || 'uat';
 }

package/build/core/playwright/constants/configConstants.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class configConstants {
+  static DEFAULT_CONFIG_DIR = 'default';
+  static BETA_DIR = 'beta';
+  static ACTOR_DIR = 'actors';
+  static UAT_CONFIG_FILE = 'uat.config.js';
+  static INDEX_FILE = 'index.js';
+  static SETTINGS_FILE = 'settings.json';
+  static TEST_SUMMARY_FILE = 'test-summary.json';
+  static STAGE_CONFIG_MAP_FILE = 'uat/conf_path_map.properties';
+}
+exports.default = configConstants;

package/build/core/playwright/constants/reporterConstants.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class ReporterConstants {
+  static DEFAULT_REPORTER_PATH = 'uat/test-results/playwright-test-results.json';
+  static LAST_RUN_REPORTER_PATH = 'uat/test-results/.last-run.json';
+}
+exports.default = ReporterConstants;

package/build/core/playwright/custom-commands.js

@@ -4,4 +4,4 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.CUSTOM_COMMANDS = void 0;
-const CUSTOM_COMMANDS = exports.CUSTOM_COMMANDS = ['mode', 'tags', 'edition', 'browsers', 'filePath', 'headless', 'modules', 'isTearDown'];
+const CUSTOM_COMMANDS = exports.CUSTOM_COMMANDS = ['stage', 'mode', 'tags', 'edition', 'browsers', 'filePath', 'headless', 'modules', 'isTearDown'];

package/build/core/playwright/env-initializer.js

@@ -17,19 +17,20 @@ function setEnvironmentVariables(configJSON) {
 }
 function addHelperLogsForEnvInitialization() {
   _logger.Logger.log(_logger.Logger.INFO_TYPE, `Mode under which test cases should run has not been specified in args.`);
-  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Please specify --mode='dev/prod' while running ZDTestingFramework test`);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Please specify --mode='dev/ci/cd/devautomation' while running ZDTestingFramework test`);
   _logger.Logger.log(_logger.Logger.INFO_TYPE, `Going to use default mode as dev`);
 }
-function initializeEnvConfig(mode, isAuthMode) {
+function initializeEnvConfig(stage, mode, isAuthMode) {
+  if (!mode) {
+    addHelperLogsForEnvInitialization();
+    mode = 'dev';
+  }
+  const configFilePath = (0, _fs.readFileSync)(_path.default.resolve(process.cwd(), `./${(0, _configFileNameProvider.getEnvConfigFilePath)(stage, mode)}`));
   try {
-    if (!mode) {
-      addHelperLogsForEnvInitialization();
-      mode = 'dev';
-    }
-    const configFile = (0, _fs.readFileSync)(_path.default.resolve(process.cwd(), `./${(0, _configFileNameProvider.getEnvConfigFilePath)(mode)}`));
-    const configJSON = JSON.parse(configFile);
+    const configJSON = JSON.parse(configFilePath);
     setEnvironmentVariables({
       ...configJSON,
+      stage,
       mode
     });
     if (isAuthMode) {
@@ -38,6 +39,6 @@ function initializeEnvConfig(mode, isAuthMode) {
     }
   } catch (err) {
     _logger.Logger.error(err);
-    throw new Error(`Config File Not Exists. Please provide a config file ${(0, _configFileNameProvider.getEnvConfigFilePath)(mode)} to intiailize the environment variables `);
+    throw new Error(`Config File Not Exists. Please provide a ${configFilePath} to initialize the environment variables`);
   }
 }

package/build/core/playwright/helpers/auth/getUsers.js

@@ -13,7 +13,9 @@ exports.isCI = isCI;
 exports.isDevelopmentSetup = isDevelopmentSetup;
 var _path = _interopRequireDefault(require("path"));
 var _fs = require("fs");
-var _readConfigFile = require("../../readConfigFile");
+var _configPathResolver = require("../configPathResolver");
+var _ConfigurationHelper = require("./../../configuration/ConfigurationHelper");
+var _configConstants = _interopRequireDefault(require("../../constants/configConstants"));
 /* eslint-disable global-require */
 function getRunMode() {
   let {
@@ -30,19 +32,18 @@ function isDevelopmentSetup() {
   return mode === 'DEV' || mode === 'dev';
 }
 function getDefaultActorConf() {
-  const {
-    uatDirectory
-  } = (0, _readConfigFile.generateConfigFromFile)();
-  const modeSettingsFile = `conf/${getRunMode()}/settings.json`;
-  const filePath = _path.default.join(uatDirectory, modeSettingsFile);
+  const stage = (0, _ConfigurationHelper.getRunStage)();
+  const stagePath = (0, _configPathResolver.getConfigPath)(stage);
+  const modeSettingsFile = `${stagePath}/${getRunMode()}/${_configConstants.default.SETTINGS_FILE}`;
+  const filePath = _path.default.join(_path.default.resolve(process.cwd(), modeSettingsFile));
   try {
     if (!(0, _fs.existsSync)(filePath)) {
-      const defaultSettingsFile = _path.default.join(uatDirectory, `conf/default/settings.json`);
+      const defaultSettingsFile = _path.default.join(_path.default.resolve(process.cwd(), `${stagePath}/${_configConstants.default.DEFAULT_CONFIG_DIR}/${_configConstants.default.SETTINGS_FILE}`));
       return require(defaultSettingsFile);
     }
     return require(filePath);
   } catch (error) {
-    throw new Error(`${defaultSettingFile} ${filePath} both files are missing.`);
+    throw new Error(`${filePath} file missing.`);
   }
 }
 function getDefaultActor() {
@@ -53,18 +54,17 @@ function getDefaultActor() {
   return getUserForSelectedEditionAndProfile(edition, profile);
 }
 function getListOfActors(betaFeature) {
-  const {
-    uatDirectory
-  } = (0, _readConfigFile.generateConfigFromFile)();
   const mode = getRunMode();
-  let configFile = _path.default.join(uatDirectory, `conf/${mode}/actors/index.js`);
+  const stage = (0, _ConfigurationHelper.getRunStage)();
+  const stagePath = (0, _configPathResolver.getConfigPath)(stage);
+  let configFile = _path.default.join(_path.default.resolve(process.cwd(), `${stagePath}/${mode}/${_configConstants.default.ACTOR_DIR}/${_configConstants.default.INDEX_FILE}`));
   let betaReference = mode;
   if (!(0, _fs.existsSync)(configFile)) {
-    configFile = _path.default.join(uatDirectory, `conf/default/actors/index.js`);
+    configFile = _path.default.join(_path.default.resolve(process.cwd(), `${stagePath}/${_configConstants.default.DEFAULT_CONFIG_DIR}/${_configConstants.default.ACTOR_DIR}/${_configConstants.default.INDEX_FILE}`));
     betaReference = "default";
   }
   if (betaFeature) {
-    configFile = _path.default.join(uatDirectory, `conf/${betaReference}/actors/beta/${betaFeature}/index.js`);
+    configFile = _path.default.join(_path.default.resolve(process.cwd(), `${stagePath}/${betaReference}/${_configConstants.default.ACTOR_DIR}/${_configConstants.default.BETA_DIR}/${betaFeature}/${_configConstants.default.INDEX_FILE}`));
     if (!(0, _fs.existsSync)(configFile)) {
       throw new Error(`There is no beta feature configured with the name "${betaFeature}"`);
     }

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

@@ -10,22 +10,29 @@ exports.getUATFileName = getUATFileName;
 var _path = _interopRequireDefault(require("path"));
 var _fs = _interopRequireDefault(require("fs"));
 var _auth = require("./auth");
-function getUATFileName(mode) {
+var _ConfigurationHelper = require("./../configuration/ConfigurationHelper");
+var _configPathResolver = require("./configPathResolver");
+var _configConstants = _interopRequireDefault(require("../constants/configConstants"));
+function getUATFileName(stage, mode) {
+  stage = stage || (0, _ConfigurationHelper.getRunStage)();
   mode = mode || (0, _auth.getRunMode)();
-  const uatConfFilePath = _path.default.resolve(process.cwd(), `uat/conf/${mode}/uat.config.js`);
+  const stagePath = (0, _configPathResolver.getConfigPath)(stage);
+  const uatConfFilePath = _path.default.resolve(process.cwd(), `${stagePath}/${mode}/${_configConstants.default.UAT_CONFIG_FILE}`);
   if (_fs.default.existsSync(uatConfFilePath)) {
     return uatConfFilePath;
   }
-  return _path.default.resolve(process.cwd(), `uat/conf/default/uat.config.js`);
+  ;
+  return _path.default.resolve(process.cwd(), `${stagePath}/${_configConstants.default.DEFAULT_CONFIG_DIR}/${_configConstants.default.UAT_CONFIG_FILE}`);
 }
-function getEnvConfigFilePath(mode) {
-  const confFilePath = _path.default.resolve(process.cwd(), `uat/conf/${mode}/settings.json`);
+function getEnvConfigFilePath(stage, mode) {
+  const stagePath = (0, _configPathResolver.getConfigPath)(stage);
+  const confFilePath = `${stagePath}/${mode}/${_configConstants.default.SETTINGS_FILE}`;
   // TODO: Actors Mode as config
   if (_fs.default.existsSync(confFilePath)) {
-    return `uat/conf/${mode}/settings.json`;
+    return confFilePath;
   }
-  return `uat/conf/default/settings.json`;
+  return `${stagePath}/${_configConstants.default.DEFAULT_CONFIG_DIR}/${_configConstants.default.SETTINGS_FILE}`;
 }
 function getReportFileName() {
-  return `test-summary.json`;
+  return `${_configConstants.default.TEST_SUMMARY_FILE}`;
 }

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

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConfigPath = getConfigPath;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _propertiesReader = _interopRequireDefault(require("properties-reader"));
+var _logger = require("../../../utils/logger");
+var _configConstants = _interopRequireDefault(require("../constants/configConstants"));
+//This function reads a properties file and returns the entire properties
+
+function readPropertiesFile(relativeFilePath) {
+  const filePath = _path.default.resolve(process.cwd(), relativeFilePath);
+  let properties;
+  if (_fs.default.existsSync(filePath)) {
+    properties = (0, _propertiesReader.default)(filePath);
+  } else {
+    // we have to remove this logic after adding all the projects with proper config files
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Properties file ${filePath} not found. Using default configurations.`);
+    properties = (0, _propertiesReader.default)();
+    properties.set('uat', 'uat/conf');
+  }
+  return properties;
+}
+
+// This function return the value for the passed arguments key
+
+function getConfigPath(stage) {
+  const props = readPropertiesFile(_configConstants.default.STAGE_CONFIG_MAP_FILE);
+  const configPath = props.get(stage);
+  if (!configPath) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `No config mapping found for stage: "${stage}"`);
+  }
+  return configPath;
+}

package/build/core/playwright/readConfigFile.js

@@ -111,15 +111,16 @@ function combineDefaultConfigWithUserConfig(userConfiguration) {
  */
 
 function getConfigFilePath() {
-  return _path.default.resolve(process.cwd(), (0, _configFileNameProvider.getUATFileName)());
+  return (0, _configFileNameProvider.getUATFileName)();
 }
 function generateConfigFromFile() {
   if (cachedConfig === null) {
     // Getting the default config's from framework
     const uatConfig = new _Configuration.default(getDefaultConfig());
     // overriding the application config's from project
-    const appConfig = new _Configuration.default((0, _ConfigurationHelper.getApplicationConfig)());
     const userArgConfig = new _Configuration.default(_UserArgs.default.parseToObject(process.argv.slice(2)));
+    const stage = userArgConfig.get("stage");
+    const appConfig = new _Configuration.default((0, _ConfigurationHelper.getApplicationConfig)(stage));
     // overriding the user config's from CLI
     uatConfig.addAll(appConfig);
     uatConfig.addAll(userArgConfig);

package/build/core/playwright/reporter/helpers/mergeAbortedTests.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = mergeAbortedTestsIntoLastRun;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../../../utils/logger");
+var _fileUtils = require("../../../../utils/fileUtils");
+var _reporterConstants = _interopRequireDefault(require("../../constants/reporterConstants"));
+function mergeAbortedTestsIntoLastRun() {
+  let resultsFile = _path.default.resolve(process.cwd(), _reporterConstants.default.DEFAULT_REPORTER_PATH),
+    lastRunFile = _path.default.resolve(process.cwd(), _reporterConstants.default.LAST_RUN_REPORTER_PATH);
+  try {
+    let report;
+    try {
+      report = JSON.parse(_fs.default.readFileSync(resultsFile, 'utf-8'));
+    } catch (e) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to parse results file: ${resultsFile}`, e);
+      return;
+    }
+    const abortedTests = collectAbortedSpecIds(report);
+    let lastRunData = {
+      status: 'passed',
+      failedTests: []
+    };
+    if (_fs.default.existsSync(lastRunFile)) {
+      try {
+        const parsed = JSON.parse(_fs.default.readFileSync(lastRunFile, 'utf-8'));
+        lastRunData.status = parsed.status || lastRunData.status;
+        lastRunData.failedTests = Array.isArray(parsed.failedTests) ? parsed.failedTests : [];
+      } catch (e) {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to parse existing last-run file: ${lastRunFile}`, e);
+      }
+    }
+
+    // Merge existing failed tests + aborted tests
+    const failedSet = new Set(lastRunData.failedTests);
+    for (const id of abortedTests) {
+      failedSet.add(id);
+    }
+    lastRunData.failedTests = [...failedSet];
+    lastRunData.status = failedSet.size > 0 ? 'failed' : lastRunData.status;
+    (0, _fileUtils.writeFileContents)(lastRunFile, JSON.stringify(lastRunData, null, 2));
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Updated ${abortedTests.size} aborted tests in .last-run.json file \n`);
+    return lastRunData;
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Error updating .last-run.json: ${err.message}`);
+  }
+}
+function collectAbortedSpecIds(report) {
+  const aborted = new Set();
+  if (!Array.isArray(report.suites)) {
+    return aborted;
+  }
+  const isAbortedSpec = spec => {
+    var _spec$tests;
+    const tags = Array.isArray(spec.tags) ? spec.tags : [];
+    return (_spec$tests = spec.tests) === null || _spec$tests === void 0 ? void 0 : _spec$tests.some(t => !tags.includes('skip') && t.projectName === 'chromium' && t.status === 'skipped');
+  };
+  const testResultsObj = report.suites;
+  while (testResultsObj.length > 0) {
+    const suite = testResultsObj.pop();
+    if (Array.isArray(suite.specs)) {
+      for (const spec of suite.specs) {
+        if (spec && isAbortedSpec(spec)) {
+          aborted.add(spec.id);
+        }
+      }
+    }
+    if (Array.isArray(suite.suites)) {
+      for (const child of suite.suites) testResultsObj.push(child);
+    }
+  }
+  return aborted;
+}

package/build/core/playwright/setup/custom-reporter.js

@@ -11,6 +11,7 @@ var _fileUtils = require("../../../utils/fileUtils");
 var _readConfigFile = require("../readConfigFile");
 var _logger = require("../../../utils/logger");
 var _configFileNameProvider = require("../helpers/configFileNameProvider");
+var _mergeAbortedTests = _interopRequireDefault(require("../reporter/helpers/mergeAbortedTests"));
 class JSONSummaryReporter {
   constructor() {
     this.durationInMS = -1;
@@ -123,6 +124,8 @@ class JSONSummaryReporter {
     (0, _fileUtils.writeFileContents)(_path.default.join(reportPath, './', (0, _configFileNameProvider.getReportFileName)()), JSON.stringify(this, null, '  '));
   }
   onExit() {
+    // Update .last-run.json with aborted tests due to timing out or interruption
+    (0, _mergeAbortedTests.default)();
     const shouldClearLastLine = this._open !== 'always' || this._open !== 'on-failure';
     if (shouldClearLastLine) {
       /**Below code is to replace the playwright default report commond with abstraction tool command */

package/build/core/playwright/test-runner.js

@@ -86,7 +86,8 @@ function main() {
   // overriding the application config's from project
   const userArgConfig = new _Configuration.default(_UserArgs.default.parseToObject(process.argv.slice(2)));
   const mode = userArgConfig.get("mode");
-  uatConfig.addAll(new _Configuration.default((0, _ConfigurationHelper.getApplicationConfig)(mode)));
+  const stage = userArgConfig.get("stage");
+  uatConfig.addAll(new _Configuration.default((0, _ConfigurationHelper.getApplicationConfig)(stage, mode)));
   // overriding the user config's from CLI
   uatConfig.addAll(userArgConfig);
   const modules = uatConfig.get('modules');
@@ -95,6 +96,7 @@ function main() {
   //We need to change this process.env variable to pass the module name in future.
   process.env.modules = modules;
   process.env.tearDown = tearDown;
+  process.env.stage = stage;
   const {
     isAuthMode,
     editionOrder,
@@ -102,7 +104,7 @@ function main() {
     bddMode = false,
     headless = false
   } = uatConfig.getAll();
-  (0, _envInitializer.initializeEnvConfig)(mode, isAuthMode);
+  (0, _envInitializer.initializeEnvConfig)(stage, mode, isAuthMode);
 
   //This is only used for pass the user arguments to need places in legacy code. We need to rewamp that also.
   const userArgsObject = userArgConfig.getAll();

package/build/test/core/playwright/helpers/__tests__/configFileNameProvider.test.js

@@ -4,31 +4,72 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 var _fs = require("fs");
 var _path = _interopRequireDefault(require("path"));
 var _configFileNameProvider = require("../../../../../core/playwright/helpers/configFileNameProvider");
+var _configPathResolver = require("../../../../../core/playwright/helpers/configPathResolver");
 jest.mock('fs');
-jest.mock('path');
+jest.mock('path', () => ({
+  resolve: jest.fn()
+}));
+jest.mock("../../../../../core/playwright/helpers/configPathResolver", () => ({
+  getConfigPath: jest.fn()
+}));
 const mockCwd = '/mock/current/directory';
 _path.default.resolve = jest.fn();
 process.cwd = jest.fn(() => mockCwd);
 describe('getUATFileName', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    _path.default.resolve.mockImplementation((...segments) => segments.join('/'));
   });
-  test('return the pipeline matched config files for pipeline matched files exists', () => {
+  test('should return pipeline-matched config path when file exists', () => {
+    const stage = 'uat';
     const mode = 'cd';
-    const mockPath = `${mockCwd}/uat/conf/${mode}/uat.config.js`;
+    _configPathResolver.getConfigPath.mockReturnValue(`${stage}/conf`);
     _fs.existsSync.mockReturnValue(true);
-    _path.default.resolve.mockImplementation((...args) => args.join('/'));
-    const result = (0, _configFileNameProvider.getUATFileName)(mode);
-    expect(_fs.existsSync).toHaveBeenCalledWith(mockPath);
-    expect(result).toBe(mockPath);
+    const expected = `${process.cwd()}/${stage}/conf/${mode}/uat.config.js`;
+    const result = (0, _configFileNameProvider.getUATFileName)(stage, mode);
+    expect(_configPathResolver.getConfigPath).toHaveBeenCalledWith(stage);
+    expect(_fs.existsSync).toHaveBeenCalledWith(expected);
+    expect(result).toBe(expected);
   });
-  test('return the default config files for pipeline matched files not exists', () => {
-    const mode = 'ci';
-    const defaultPath = `${mockCwd}/uat/conf/default/uat.config.js`;
-    _fs.existsSync.mockReturnValue(false);
-    _path.default.resolve.mockImplementation((...args) => args.join('/'));
+  test('should use default stage and mode when not provided', () => {
+    const mode = 'dev';
+    const stageConfigPath = 'uat/conf';
+    const expectedPath = `${mockCwd}/${stageConfigPath}/${mode}/uat.config.js`;
+    _fs.existsSync.mockReturnValue(true);
     const result = (0, _configFileNameProvider.getUATFileName)(mode);
     expect(_fs.existsSync).toHaveBeenCalledWith(`${mockCwd}/uat/conf/${mode}/uat.config.js`);
-    expect(result).toBe(defaultPath);
+    expect(result).toBe(expectedPath);
+  });
+  test('should return the default config files for pipeline matched files not exists', () => {
+    const mockStage = 'uat';
+    const mockMode = 'ci';
+    const stageConfigPath = 'uat/conf';
+    const nonExistingPath = `${mockCwd}/${stageConfigPath}/${mockMode}/uat.config.js`;
+    const expectedDefaultPath = `${mockCwd}/${mockStage}/conf/default/uat.config.js`;
+    _configPathResolver.getConfigPath.mockReturnValue(stageConfigPath);
+    _fs.existsSync.mockReturnValue(false);
+    const result = (0, _configFileNameProvider.getUATFileName)(mockStage, mockMode);
+    expect(_fs.existsSync).toHaveBeenCalledWith(nonExistingPath);
+    expect(result).toBe(expectedDefaultPath);
+  });
+});
+describe('getEnvConfigFilePath', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    _path.default.resolve.mockImplementation((...segments) => segments.join('/'));
+  });
+  test('should return conf file path when file exists', () => {
+    _configPathResolver.getConfigPath.mockReturnValue('uat/conf');
+    _fs.existsSync.mockReturnValue(true);
+    const result = (0, _configFileNameProvider.getEnvConfigFilePath)('uat', 'cd');
+    expect(_configPathResolver.getConfigPath).toHaveBeenCalledWith('uat');
+    expect(_fs.existsSync).toHaveBeenCalled();
+    expect(result).toBe('uat/conf/cd/settings.json');
+  });
+  test('should return default path when file does not exist', () => {
+    _configPathResolver.getConfigPath.mockReturnValue('uat/conf');
+    _fs.existsSync.mockReturnValue(false);
+    const result = (0, _configFileNameProvider.getEnvConfigFilePath)('uat', 'ci');
+    expect(result).toBe('uat/conf/default/settings.json');
   });
 });

package/build/test/core/playwright/helpers/__tests__/configPathResolver.test.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _propertiesReader = _interopRequireDefault(require("properties-reader"));
+var _configPathResolver = require("../../../../../core/playwright/helpers/configPathResolver");
+var _logger = require("../../../../../utils/logger");
+var _configConstants = _interopRequireDefault(require("../../../../../core/playwright/constants/configConstants"));
+jest.mock('fs');
+jest.mock('path');
+jest.mock('properties-reader');
+jest.mock('../../../../../utils/logger', () => ({
+  Logger: {
+    log: jest.fn(),
+    INFO_TYPE: 'info',
+    FAILURE_TYPE: 'failure'
+  }
+}));
+describe('getConfigPath', () => {
+  const mockProps = {
+    get: jest.fn(),
+    set: jest.fn()
+  };
+  beforeEach(() => {
+    jest.clearAllMocks();
+    _propertiesReader.default.mockReturnValue(mockProps);
+    _path.default.resolve.mockImplementation((...args) => args.join('/'));
+  });
+  test('should return config path when properties file exists and has mapping', () => {
+    _fs.default.existsSync.mockReturnValue(true);
+    mockProps.get.mockReturnValue('uat/conf');
+    const result = (0, _configPathResolver.getConfigPath)('uat');
+    expect(_fs.default.existsSync).toHaveBeenCalledWith(expect.stringContaining(_configConstants.default.STAGE_CONFIG_MAP_FILE));
+    expect(_propertiesReader.default).toHaveBeenCalled();
+    expect(mockProps.get).toHaveBeenCalledWith('uat');
+    expect(result).toBe('uat/conf');
+    expect(_logger.Logger.log).not.toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, expect.any(String));
+  });
+  test('should log info and use default mapping if file does not exist', () => {
+    _fs.default.existsSync.mockReturnValue(false);
+    mockProps.get.mockImplementation(key => key === 'uat' ? 'uat/conf' : undefined);
+    const result = (0, _configPathResolver.getConfigPath)('uat');
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.INFO_TYPE, expect.stringContaining('not found'));
+    expect(mockProps.set).toHaveBeenCalledWith('uat', 'uat/conf');
+    expect(result).toBe('uat/conf');
+  });
+  test('should log failure if config mapping not found for stage', () => {
+    _fs.default.existsSync.mockReturnValue(true);
+    mockProps.get.mockReturnValue(undefined);
+    const result = (0, _configPathResolver.getConfigPath)('stageX');
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, expect.stringContaining('stageX'));
+    expect(result).toBeUndefined();
+  });
+});