@zohodesk/testinglibrary 0.4.99-n18-experimental → 0.4.101-n18-experimental

package/README.md

@@ -17,22 +17,20 @@
 
      - npm run report
 
-### 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
 

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

@@ -1,5 +1,6 @@
 import { test } from '@zohodesk/testinglibrary';
 import DataGenerator from '@zohodesk/testinglibrary/DataGenerator';
+ import {getUserForSelectedEditionAndProfile} from '@zohodesk/testinglibrary/helpers'
 
 const dataGenerator = new DataGenerator();
 
@@ -9,7 +10,8 @@ export async function generateAndCacheTestData(executionContext, type, identifie
     const scenarioName = testInfo.title.split('/').pop() || 'Unknown Scenario';
 
     if (profile) {
-        actorInfo = await dataGenerator.getDataGenUserExecutionContext(executionContext.actorInfo.edition, profile);
+        const { edition, orgName: portal, beta } = executionContext.actorInfo;
+        actorInfo = await getUserForSelectedEditionAndProfile(edition, profile, beta, portal);
     } else {
         actorInfo = executionContext.actorInfo;
     }

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

@@ -1,6 +1,6 @@
-import {createBdd } from '@zohodesk/testinglibrary';
+import {createBdd} from '@zohodesk/testinglibrary';
+import { jsonpath } from '@zohodesk/testinglibrary/thirdPartyHelper';
 import { executeRpcRequest , entityIdReConstructor } from '../helpers/rpcRequestHelper';
-// import jp from 'jsonpath';
 
 const { Given } = createBdd();
 
@@ -54,7 +54,7 @@ Given('a search entity using {string}', async ({page,cacheLayer}, reference,data
         entityIdValue = searchObj;
     } else {
         const jsonPath = searchEntity?.startsWith?.('$') ? searchEntity : `$.${searchEntity}`;
-        const result = null;//jp.query(searchObj, jsonPath);
+        const result = jsonpath.query(searchObj, jsonPath);
         
         if (!result || result.length === 0) {
             throw new Error(`JSONPath query '${jsonPath}' returned no results from cache object for reference: ${reference}`);

package/build/core/dataGenerator/DataGenerator.js

@@ -47,15 +47,6 @@ class DataGenerator {
       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;

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

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

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 = ['stage', 'mode', 'tags', 'edition', 'browsers', 'filePath', 'headless', 'modules', 'isTearDown'];
+const CUSTOM_COMMANDS = exports.CUSTOM_COMMANDS = ['mode', 'tags', 'edition', 'browsers', 'filePath', 'headless', 'modules', 'isTearDown'];

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "jsonpath", {
+  enumerable: true,
+  get: function () {
+    return _jsonpath.default;
+  }
+});
+var _jsonpath = _interopRequireDefault(require("jsonpath"));

package/build/core/playwright/readConfigFile.js

@@ -111,16 +111,15 @@ function combineDefaultConfigWithUserConfig(userConfiguration) {
  */
 
 function getConfigFilePath() {
-  return (0, _configFileNameProvider.getUATFileName)();
+  return _path.default.resolve(process.cwd(), (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/test-runner.js

@@ -86,8 +86,7 @@ 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");
-  const stage = userArgConfig.get("stage");
-  uatConfig.addAll(new _Configuration.default((0, _ConfigurationHelper.getApplicationConfig)(stage, mode)));
+  uatConfig.addAll(new _Configuration.default((0, _ConfigurationHelper.getApplicationConfig)(mode)));
   // overriding the user config's from CLI
   uatConfig.addAll(userArgConfig);
   const modules = uatConfig.get('modules');
@@ -96,7 +95,6 @@ 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,
@@ -104,7 +102,7 @@ function main() {
     bddMode = false,
     headless = false
   } = uatConfig.getAll();
-  (0, _envInitializer.initializeEnvConfig)(stage, mode, isAuthMode);
+  (0, _envInitializer.initializeEnvConfig)(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/Test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+delete require.cache[require.resolve('../core/playwright/runner/Runner')];
+function test() {
+  const inputString = "@hc";
+  const selectedTag = ["@hc_1234"].reverse().find(tag => tag.startsWith(inputString));
+  let tagInput = null;
+  if (selectedTag) {
+    tagInput = selectedTag.split(`${inputString}_`).pop().toLowerCase();
+  }
+  console.log(tagInput);
+}
+test();

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

@@ -4,72 +4,31 @@ 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', () => ({
-  resolve: jest.fn()
-}));
-jest.mock("../../../../../core/playwright/helpers/configPathResolver", () => ({
-  getConfigPath: jest.fn()
-}));
+jest.mock('path');
 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('should return pipeline-matched config path when file exists', () => {
-    const stage = 'uat';
+  test('return the pipeline matched config files for pipeline matched files exists', () => {
     const mode = 'cd';
-    _configPathResolver.getConfigPath.mockReturnValue(`${stage}/conf`);
-    _fs.existsSync.mockReturnValue(true);
-    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('should use default stage and mode when not provided', () => {
-    const mode = 'dev';
-    const stageConfigPath = 'uat/conf';
-    const expectedPath = `${mockCwd}/${stageConfigPath}/${mode}/uat.config.js`;
+    const mockPath = `${mockCwd}/uat/conf/${mode}/uat.config.js`;
     _fs.existsSync.mockReturnValue(true);
+    _path.default.resolve.mockImplementation((...args) => args.join('/'));
     const result = (0, _configFileNameProvider.getUATFileName)(mode);
-    expect(_fs.existsSync).toHaveBeenCalledWith(`${mockCwd}/uat/conf/${mode}/uat.config.js`);
-    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');
+    expect(_fs.existsSync).toHaveBeenCalledWith(mockPath);
+    expect(result).toBe(mockPath);
   });
-  test('should return default path when file does not exist', () => {
-    _configPathResolver.getConfigPath.mockReturnValue('uat/conf');
+  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);
-    const result = (0, _configFileNameProvider.getEnvConfigFilePath)('uat', 'ci');
-    expect(result).toBe('uat/conf/default/settings.json');
+    _path.default.resolve.mockImplementation((...args) => args.join('/'));
+    const result = (0, _configFileNameProvider.getUATFileName)(mode);
+    expect(_fs.existsSync).toHaveBeenCalledWith(`${mockCwd}/uat/conf/${mode}/uat.config.js`);
+    expect(result).toBe(defaultPath);
   });
 });

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

@@ -1,83 +1,80 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _fs = _interopRequireDefault(require("fs"));
+var _fs = require("fs");
 var _path = _interopRequireDefault(require("path"));
-var _getUsers = require("../../../../../core/playwright/helpers/auth/getUsers");
-var _configPathResolver = require("../../../../../core/playwright/helpers/configPathResolver");
 jest.mock('fs');
 jest.mock('path');
-jest.mock('../../../../../core/playwright/helpers/configPathResolver', () => ({
-  getConfigPath: jest.fn()
+jest.mock('../../../../../core/playwright/readConfigFile', () => ({
+  generateConfigFromFile: jest.fn(() => ({
+    uatDirectory: '/test/directory'
+  })),
+  getRunMode: jest.fn(() => 'dev')
 }));
+const {
+  getListOfActors
+} = require('../../../../../core/playwright/helpers/auth/getUsers');
 describe('getListOfActors', () => {
-  const stageConfig = 'uat/conf';
-  const mode = 'dev';
-  const stage = 'uat';
   beforeEach(() => {
     jest.clearAllMocks();
     _path.default.join.mockImplementation((...args) => args.join('/'));
-    _path.default.resolve.mockImplementation((...args) => args.join('/'));
-    _configPathResolver.getConfigPath.mockReturnValue('uat/conf');
   });
   test('throws an error when config file cannot be loaded', () => {
-    _fs.default.existsSync.mockReturnValueOnce(true);
-    jest.mock('/uat/conf/dev/actors/index.js', () => {
+    _fs.existsSync.mockReturnValueOnce(true); // Main config file exists
+
+    jest.mock('/test/directory/conf/dev/actors/index.js', () => {
       throw new Error('Loading error');
     }, {
       virtual: true
     });
-    expect(() => (0, _getUsers.getListOfActors)()).toThrow(`Error loading actor configuration from ${_path.default.join(_path.default.resolve(process.cwd(), 'uat/conf/dev/actors/index.js'))}`);
+    expect(() => getListOfActors()).toThrow('Error loading actor configuration from /test/directory/conf/dev/actors/index.js');
   });
   test('throws an error when beta feature config does not exist', () => {
-    _fs.default.existsSync.mockReturnValueOnce(true) // Main config file exists
+    _fs.existsSync.mockReturnValueOnce(true) // Main config file exists
     .mockReturnValueOnce(false); // Beta feature config does not exist in either path
 
     const betaFeature = 'nonExistentFeature';
-    expect(() => (0, _getUsers.getListOfActors)(betaFeature)).toThrow(`There is no beta feature configured with the name "${betaFeature}"`);
+    expect(() => getListOfActors(betaFeature)).toThrow(`There is no beta feature configured with the name "${betaFeature}"`);
   });
-  test('loads main configuration when betaFeature is not provided and main config exists', () => {
-    _fs.default.existsSync.mockReturnValueOnce(true);
-    const file = _path.default.join(_path.default.resolve(process.cwd(), `${stageConfig}/${mode}/actors/index.js`));
-    jest.doMock(file, () => ({
+  test('loads main configuration when betaFeature is not provided and main config file exists', () => {
+    _fs.existsSync.mockReturnValueOnce(true);
+    jest.doMock('/test/directory/conf/dev/actors/index.js', () => ({
       actors: []
     }), {
       virtual: true
     });
-    const result = (0, _getUsers.getListOfActors)();
+    const result = getListOfActors();
     expect(result).toEqual({
       actors: []
     });
   });
   test('falls back to default configuration if main config file does not exist', () => {
-    _fs.default.existsSync.mockReturnValueOnce(false) // Main config file missing
-    .mockReturnValueOnce(true); // Beta feature config exists
-
-    const defaultConfigFile = _path.default.join(_path.default.resolve(process.cwd(), `${stage}/conf/default/actors/index.js`));
-    jest.doMock(defaultConfigFile, () => ({
+    _fs.existsSync.mockReturnValueOnce(false).mockReturnValueOnce(true);
+    jest.doMock('/test/directory/conf/default/actors/index.js', () => ({
       actors: []
     }), {
       virtual: true
     });
-    const result = (0, _getUsers.getListOfActors)();
+    const result = getListOfActors();
     expect(result).toEqual({
       actors: []
     });
   });
   test('loads beta feature configuration when betaFeature is provided', () => {
-    _fs.default.existsSync.mockReturnValueOnce(true) // Main config file exists
+    _fs.existsSync.mockReturnValueOnce(true) // Main config file exists
     .mockReturnValueOnce(true); // Beta feature config exists
 
     const betaFeature = 'parentchild';
-    const betaFeaturePath = _path.default.join(_path.default.resolve(process.cwd(), `${stageConfig}/${mode}/actors/beta/${betaFeature}/index.js`));
+    const betaFeaturePath = `/test/directory/conf/dev/actors/beta/${betaFeature}/index.js`;
     jest.doMock(betaFeaturePath, () => ({
       betaActors: []
     }), {
       virtual: true
     });
-    const result = (0, _getUsers.getListOfActors)(betaFeature);
+    const result = getListOfActors(betaFeature);
     expect(result).toEqual({
       betaActors: []
     });
+    expect(_path.default.join).toHaveBeenCalledWith('/test/directory', `conf/dev/actors/beta/${betaFeature}/index.js`);
   });
 });