@zohodesk/testinglibrary 0.5.10-n18-experimental → 0.5.12-n18-experimental

package/build/core/playwright/setup/config-utils.js

@@ -16,11 +16,14 @@ var _playwrightBdd = require("playwright-bdd");
 var _logger = require("../../../utils/logger");
 var _browserTypes = require("../constants/browserTypes");
 var _fileUtils = require("../../../utils/fileUtils");
+var _ConfigurationHelper = require("../configuration/ConfigurationHelper");
+var _configConstants = _interopRequireDefault(require("../constants/configConstants"));
 /**
  ** Playwright project configuration
  * @returns {import('@playwright/test').Project}
  */
 
+const stage = (0, _ConfigurationHelper.getRunStage)();
 function getBrowserConfig({
   browserName,
   isAuthMode,
@@ -142,7 +145,8 @@ function getPathsForFeatureFiles(cwd) {
       const {
         failed = []
       } = JSON.parse(testSummary);
-      const casesToRun = failed.map(filePath => _path.default.join(cwd, 'uat', filePath.replace(/\.spec\.js$|\.js$/, '')));
+      const casesToRun = failed.map(filePath => _path.default.join(cwd, _configConstants.default.TEST_SLICE_FOLDER, filePath.replace(/\.spec\.js$|\.js$/, '')));
+      ;
       return casesToRun;
     } else {
       _logger.Logger.log(_logger.Logger.INFO_TYPE, `Unable to read test summary from the ${reportPath}. Verify If File Exists in the path`);
@@ -153,12 +157,12 @@ function getPathsForFeatureFiles(cwd) {
     let moduleList = modules.split(',');
     return getModulePathForFeatureFiles(moduleList);
   }
-  return [_path.default.join(cwd, 'uat', 'modules', '**', '*.feature')];
+  return [_path.default.join(cwd, _configConstants.default.TEST_SLICE_FOLDER, stage, 'modules', '**', 'feature-files', '*.feature')];
 }
 function getModulePathForFeatureFiles(moduleList) {
   let validModuleList = [];
   moduleList.forEach(moduleName => {
-    let modulePath = _path.default.join(process.cwd(), 'uat', 'modules', '**', `${moduleName}`);
+    let modulePath = _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, '**', 'modules', '**', `${moduleName}`);
     if ((0, _fileUtils.checkIfFolderExistsWithPattern)(modulePath)) {
       validModuleList.push(_path.default.join(modulePath, '**', '*.feature'));
     } else {

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

@@ -8,11 +8,14 @@ exports.default = void 0;
 var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
 var _codeFrame = require("@babel/code-frame");
+var _configConstants = _interopRequireDefault(require("../constants/configConstants"));
+var _ConfigurationHelper = require("../configuration/ConfigurationHelper");
+const stage = (0, _ConfigurationHelper.getRunStage)();
 class CustomJsonReporter {
   constructor({
     outputFile = 'test-results.json'
   } = {}) {
-    this.outputFile = _path.default.resolve(process.cwd(), 'uat/test-results/', outputFile);
+    this.outputFile = _path.default.resolve(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'test-results/', outputFile);
     this.rootSuite = null;
     this.report = {
       config: {},

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

@@ -8,15 +8,11 @@ exports.default = void 0;
 exports.runPreprocessing = runPreprocessing;
 var _child_process = require("child_process");
 var _path = _interopRequireDefault(require("path"));
-var _customCommands = require("./custom-commands");
-var _cliArgsToObject = require("../../utils/cliArgsToObject");
 var _envInitializer = require("./env-initializer");
 var _logger = require("../../utils/logger");
 var _readConfigFile = require("./readConfigFile");
 var _rootPath = require("../../utils/rootPath");
 var _tagProcessor = _interopRequireDefault(require("./tagProcessor"));
-var _configUtils = require("./setup/config-utils");
-var _browserTypes = require("./constants/browserTypes");
 var _ConfigurationHelper = require("./configuration/ConfigurationHelper");
 var _Configuration = _interopRequireDefault(require("./configuration/Configuration"));
 var _UserArgs = _interopRequireDefault(require("./configuration/UserArgs"));
@@ -86,7 +82,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 +92,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 +100,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/index.js

@@ -40,6 +40,12 @@ Object.defineProperty(exports, "getRunMode", {
     return _index.getRunMode;
   }
 });
+Object.defineProperty(exports, "getRunStage", {
+  enumerable: true,
+  get: function () {
+    return _index.getRunStage;
+  }
+});
 Object.defineProperty(exports, "getUserForSelectedEditionAndProfile", {
   enumerable: true,
   get: function () {

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();
+  });
+});

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

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

package/build/utils/commonUtils.js

@@ -7,11 +7,14 @@ Object.defineProperty(exports, "__esModule", {
 exports.copyCommonSpecs = copyCommonSpecs;
 var _fileUtils = require("./fileUtils");
 var _path = _interopRequireDefault(require("path"));
+var _configConstants = _interopRequireDefault(require("../core/playwright/constants/configConstants"));
+var _ConfigurationHelper = require("../core/playwright/configuration/ConfigurationHelper");
+const stage = (0, _ConfigurationHelper.getRunStage)();
 function copyCommonSpecs() {
   const libraryPath = require.resolve("@zohodesk/testinglibrary");
   // libraryPath will be build/index.js to go to the common specs we need to go one level up
   const commonSpecPath = _path.default.resolve(libraryPath, '../', 'common');
-  const destDirectory = _path.default.resolve(process.cwd(), 'uat', 'modules', '.testingLib-common');
+  const destDirectory = _path.default.resolve(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'modules', '.testingLib-common');
   (0, _fileUtils.deleteFolder)(destDirectory);
   (0, _fileUtils.copyDirectory)(commonSpecPath, destDirectory);
 }