@zohodesk/testinglibrary 0.2.8 → 0.2.9

package/.gitlab-ci.yml

@@ -0,0 +1,45 @@
+image: node:14.17.3
+
+workflow:
+  rules:
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+
+stages:
+  - build
+  - unit
+  - uat
+
+# Install dependencies stage
+build:
+  stage: build
+  image: node:14.17.3
+  script:
+    - npm install
+  artifacts:
+    paths:
+      - node_modules/
+
+
+# Unit tests stage
+unit:
+  stage: unit
+  image: node:14.17.3
+  script:
+    - npm test
+  artifacts:
+    when: always
+    paths:
+      - test-reports
+
+uat:
+  stage: uat
+  image: node:14.17.3
+  script:
+    - cd examples
+    - npm i
+    - npm install $(npm pack ../ | tail -1)
+    - npm run uat
+  artifacts:
+    when: always
+    paths:
+      - uat-reports

package/README.md

@@ -24,4 +24,12 @@
   - Added support for writing unitcases for framework implementations
 
 ### Bug fix
-  - 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. 
+  - 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. 
+
+### v0.2.9 - 24-10-2024
+
+#### Feature
+  - Added support for scenario level tag support
+  - Added a new cli optin like uat-validate to validate the feature files using playwright-bdd
+  - Mode based configuration implementations
+  - @only option enabled in dev pipeline

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

@@ -11,7 +11,7 @@ var _readConfigFile = require("../readConfigFile");
 /* eslint-disable global-require */
 
 function getTagInputFromSelectedTags(tags, inputString) {
-  const selectedTag = tags.find(tag => tag.startsWith(inputString));
+  const selectedTag = [...tags].reverse().find(tag => tag.startsWith(inputString));
   let tagInput = null;
   if (selectedTag) {
     tagInput = selectedTag.split(`${inputString}_`).pop().toLowerCase();

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

@@ -0,0 +1,25 @@
+"use strict";
+
+var _ConfigurationHelper = require("./ConfigurationHelper");
+class Configuration {
+  properties = {};
+  constructor(props) {
+    this.properties = props;
+  }
+  add(key, value) {
+    this.properties[key] = value;
+  }
+  addAll(newConfig) {
+    this.properties = (0, _ConfigurationHelper.combineConfiguration)(this.properties, newConfig.getAll());
+  }
+  get(key) {
+    return this.properties[key];
+  }
+  getAll() {
+    return this.properties;
+  }
+  delete(key) {
+    delete this.properties[key];
+  }
+}
+module.exports = Configuration;

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

@@ -0,0 +1,43 @@
+"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"));
+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 => {
+    let configValue = userConfiguration[configKey];
+    if (configValue !== null && configValue !== undefined) {
+      configurationObj[configKey] = configValue;
+    } else if (defaultConfig[configKey]) {
+      configurationObj[configKey] = defaultConfig[configKey];
+    } else {
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `key - ${configKey} is not yet supported in uat configuration. This will not be used while creating playwright configuration`);
+    }
+  });
+  return (0, _mergeObjects.mergeObjects)(defaultConfig, configurationObj);
+}
+function getApplicationConfig(mode) {
+  let filePath = "";
+  try {
+    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);
+    }
+    const config = require(filePath);
+    return config;
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Founded Path - ${filePath} Application config file not Exist ...`);
+    _logger.Logger.error(err);
+    return {};
+  }
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+
+var _cliArgsToObject = require("../../../utils/cliArgsToObject");
+class UserArgs {
+  static parseToObject(config) {
+    return (0, _cliArgsToObject.cliArgsToObject)(config);
+  }
+  static parseToArgs(object) {
+    return (0, _cliArgsToObject.objectToCliArgs)(object);
+  }
+}
+module.exports = UserArgs;

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

@@ -10,7 +10,6 @@ var _path = _interopRequireDefault(require("path"));
 var _configFileNameProvider = require("./helpers/configFileNameProvider");
 var _logger = require("../../utils/logger");
 var _getUsers = require("./helpers/auth/getUsers");
-var _readConfigFile = require("./readConfigFile");
 function setEnvironmentVariables(configJSON) {
   for (const key in configJSON) {
     process.env[key] = configJSON[key];

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

@@ -33,12 +33,17 @@ function getDefaultActorConf() {
   const {
     uatDirectory
   } = (0, _readConfigFile.generateConfigFromFile)();
-  const defaultSettingFile = `conf/${getRunMode()}/settings.json`;
-  const filePath = _path.default.join(uatDirectory, defaultSettingFile);
-  if (!(0, _fs.existsSync)(filePath)) {
-    throw new Error(`${defaultSettingFile} is missing.`);
+  const modeSettingsFile = `conf/${getRunMode()}/settings.json`;
+  const filePath = _path.default.join(uatDirectory, modeSettingsFile);
+  try {
+    if (!(0, _fs.existsSync)(filePath)) {
+      const defaultSettingsFile = _path.default.join(uatDirectory, `conf/default/settings.json`);
+      return require(defaultSettingsFile);
+    }
+    return require(filePath);
+  } catch (error) {
+    throw new Error(`${defaultSettingFile} ${filePath} both files are missing.`);
   }
-  return require(filePath);
 }
 function getDefaultActor() {
   const {
@@ -52,18 +57,25 @@ function getListOfActors() {
     uatDirectory
   } = (0, _readConfigFile.generateConfigFromFile)();
   const mode = getRunMode();
-  const configFile = `conf/${mode}/actors/index`;
-  const filePath = _path.default.join(uatDirectory, configFile);
-  if (!(0, _fs.existsSync)(filePath + '.js')) {
-    throw new Error(`${configFile}.js is missing.`);
+  let configFile = _path.default.join(uatDirectory, `conf/${mode}/actors/index.js`);
+  if (!(0, _fs.existsSync)(configFile)) {
+    configFile = _path.default.join(uatDirectory, `conf/default/actors/index.js`);
+  }
+  try {
+    return require(configFile);
+  } catch (error) {
+    throw new Error(`Error loading actor configuration from ${configFile}`);
   }
-  return require(filePath);
 }
 function getUserForSelectedEditionAndProfile(preferedEdition, preferredProfile, betaFeature, testDataPortal = null) {
+  const actorsData = getListOfActors();
+  if (!actorsData || !actorsData.editions) {
+    throw new Error("The actors data is missing.");
+  }
   const {
     editions: userdata,
     beta: betaPortals
-  } = getListOfActors();
+  } = actorsData;
   const defaultConf = getDefaultActorConf();
   const edition = preferedEdition || defaultConf.edition;
   const profile = preferredProfile || defaultConf.profile;

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

@@ -9,8 +9,14 @@ exports.getReportFileName = getReportFileName;
 exports.getUATFileName = getUATFileName;
 var _path = _interopRequireDefault(require("path"));
 var _fs = _interopRequireDefault(require("fs"));
-function getUATFileName() {
-  return 'uat.config.js';
+var _auth = require("./auth");
+function getUATFileName(mode) {
+  mode = mode || (0, _auth.getRunMode)();
+  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(), `uat.config.js`);
 }
 function getEnvConfigFilePath(mode) {
   const confFilePath = _path.default.resolve(process.cwd(), `uat/conf/${mode}/settings.json`);
@@ -18,7 +24,7 @@ function getEnvConfigFilePath(mode) {
   if (_fs.default.existsSync(confFilePath)) {
     return `uat/conf/${mode}/settings.json`;
   }
-  return `uat/env-config.json`;
+  return `uat/conf/default/settings.json`;
 }
 function getReportFileName() {
   return `test-summary.json`;

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

@@ -3,9 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.parseUserArgs = parseUserArgs;
 var _cliArgsToObject = require("../../../utils/cliArgsToObject");
 function parseUserArgs() {
   return (0, _cliArgsToObject.cliArgsToObject)(process.argv.slice(2));
-}
-var _default = exports.default = parseUserArgs;
+}

package/build/core/playwright/readConfigFile.js

@@ -6,18 +6,24 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.generateConfigFromFile = generateConfigFromFile;
 exports.getAuthFilePath = getAuthFilePath;
+exports.getDefaultConfig = getDefaultConfig;
 exports.isUserConfigFileAvailable = isUserConfigFileAvailable;
 var _fs = require("fs");
 var _path = _interopRequireDefault(require("path"));
 var _logger = require("../../utils/logger");
 var _configFileNameProvider = require("./helpers/configFileNameProvider");
 var _mergeObjects = require("./helpers/mergeObjects");
+var _Configuration = _interopRequireDefault(require("./configuration/Configuration"));
+var _UserArgs = _interopRequireDefault(require("./configuration/UserArgs"));
+var _ConfigurationHelper = require("./configuration/ConfigurationHelper");
 let cachedConfig = null;
 function getDefaultConfig() {
   return {
     uatDirectory: _path.default.join(process.cwd(), 'uat'),
     headless: false,
     browsers: ['Chrome'],
+    forbidOnly: false,
+    retries: 0,
     trace: false,
     video: false,
     isAuthMode: false,
@@ -32,26 +38,18 @@ function getDefaultConfig() {
       height: 720
     },
     debug: false,
-    mode: process.env.mode || 'dev',
+    testIdAttribute: 'data-testid',
     additionalPages: {},
     featureFilesFolder: 'feature-files',
     stepDefinitionsFolder: 'steps',
-    testIdAttribute: 'data-testid',
     testSetup: {},
     editionOrder: ['Free', 'Express', 'Standard', 'Professional', 'Enterprise']
   };
 }
-function checkForDeprecatedKeys(configKey) {
-  let deprecatedConfigInUatConfigFile = ['mode'];
-  if (deprecatedConfigInUatConfigFile.includes(configKey)) {
-    _logger.Logger.log(_logger.Logger.INFO_TYPE, `key ${configKey} is deprecated. Please use other options`);
-  }
-}
 function combineDefaultConfigWithUserConfig(userConfiguration) {
   let defaultConfig = getDefaultConfig();
   let configurationObj = {};
   Object.keys(userConfiguration).forEach(configKey => {
-    checkForDeprecatedKeys(configKey);
     let configValue = userConfiguration[configKey];
     if (configValue !== null && configValue !== undefined) {
       configurationObj[configKey] = configValue;
@@ -110,22 +108,26 @@ function combineDefaultConfigWithUserConfig(userConfiguration) {
  *
  * @returns {UserConfig}
  */
+
+function getConfigFilePath() {
+  return _path.default.resolve(process.cwd(), (0, _configFileNameProvider.getUATFileName)());
+}
 function generateConfigFromFile() {
-  if (cachedConfig !== null) {
-    return cachedConfig; // If cached, return the cached configuration
-  }
-  const filePath = _path.default.resolve(process.cwd(), (0, _configFileNameProvider.getUATFileName)());
-  if ((0, _fs.existsSync)(filePath)) {
-    /** @type {UserConfig} */
-    const config = require(filePath);
-    const modifiedConfiguration = combineDefaultConfigWithUserConfig(config);
-    cachedConfig = modifiedConfiguration;
-    return modifiedConfiguration;
+  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)));
+    // overriding the user config's from CLI
+    uatConfig.addAll(appConfig);
+    uatConfig.addAll(userArgConfig);
+    cachedConfig = uatConfig.getAll();
   }
-  return {};
+  return cachedConfig;
 }
 function isUserConfigFileAvailable() {
-  const filePath = _path.default.resolve(process.cwd(), (0, _configFileNameProvider.getUATFileName)());
+  const filePath = getConfigFilePath();
   if ((0, _fs.existsSync)(filePath)) {
     return true;
   }

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

@@ -9,6 +9,7 @@ var _test = require("@playwright/test");
 var _path = _interopRequireDefault(require("path"));
 var _readConfigFile = require("../readConfigFile");
 var _configUtils = require("./config-utils");
+const uatConfig = (0, _readConfigFile.generateConfigFromFile)();
 const {
   browsers,
   trace,
@@ -25,7 +26,7 @@ const {
   stepDefinitionsFolder,
   testIdAttribute,
   globalTimeout
-} = (0, _readConfigFile.generateConfigFromFile)();
+} = uatConfig;
 const projects = (0, _configUtils.getProjects)({
   browsers,
   isAuthMode,
@@ -51,13 +52,11 @@ const testOptions = (0, _configUtils.getTestUseOptions)({
  * @returns {import('@playwright/test').PlaywrightTestConfig}
  */
 function getPlaywrightConfig() {
-  return {
+  const playwrightConfig = {
     testDir,
     globalTimeout: globalTimeout || 3600000,
     outputDir: _path.default.join(process.cwd(), 'uat', 'test-results'),
     fullyParallel: true,
-    forbidOnly: !!process.env.CI,
-    retries: process.env.CI ? 2 : 0,
     reporter: [['html', {
       outputFolder: reportPath,
       open: openReportOn
@@ -76,7 +75,9 @@ function getPlaywrightConfig() {
       name: 'cleanup',
       testMatch: /.*\.teardown\.js/,
       testDir: _path.default.join(process.cwd(), 'uat')
-    }, ...projects] : [...projects]
+    }, ...projects] : [...projects],
+    ...uatConfig
   };
+  return playwrightConfig;
 }
 var _default = exports.default = (0, _test.defineConfig)(getPlaywrightConfig());

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+exports.runPreprocessing = runPreprocessing;
 var _child_process = require("child_process");
 var _path = _interopRequireDefault(require("path"));
 var _customCommands = require("./custom-commands");
@@ -16,7 +17,9 @@ var _rootPath = require("../../utils/rootPath");
 var _tagProcessor = require("./tag-processor");
 var _configUtils = require("./setup/config-utils");
 var _browserTypes = require("./constants/browserTypes");
-var _parseUserArgs = _interopRequireDefault(require("./helpers/parseUserArgs"));
+var _ConfigurationHelper = require("./configuration/ConfigurationHelper");
+var _Configuration = _interopRequireDefault(require("./configuration/Configuration"));
+var _UserArgs = _interopRequireDefault(require("./configuration/UserArgs"));
 function getPlaywrightArgs(userArgsObject, debug, bddMode, tagArgs, headless) {
   const {
     browsers = null
@@ -55,7 +58,7 @@ function runPreprocessing(tagArgs, configPath) {
     });
     childProcessForPreprocessing.on('error', data => {
       _logger.Logger.log(_logger.Logger.FAILURE_TYPE, data);
-      reject();
+      reject(data);
     });
     childProcessForPreprocessing.on('exit', code => {
       if (code === 0) {
@@ -97,16 +100,28 @@ function runPlaywright(command, args) {
   });
 }
 function main() {
-  const userArgsObject = (0, _parseUserArgs.default)();
-  const uatConfig = (0, _readConfigFile.generateConfigFromFile)();
+  // Getting the default config's from framework
+  const uatConfig = new _Configuration.default((0, _readConfigFile.getDefaultConfig)());
+
+  // 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)));
+
+  // overriding the user config's from CLI
+  uatConfig.addAll(userArgConfig);
   const {
+    isAuthMode,
+    editionOrder,
     debug,
     bddMode = false,
-    headless = false,
-    editionOrder,
-    isAuthMode
-  } = uatConfig;
-  (0, _envInitializer.initializeEnvConfig)(userArgsObject.mode, isAuthMode);
+    headless = false
+  } = uatConfig.getAll();
+  (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();
   const tagArgs = (0, _tagProcessor.tagProcessor)(userArgsObject, editionOrder);
   const playwrightArgs = getPlaywrightArgs(userArgsObject, debug, bddMode, tagArgs, headless);
   const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));

package/build/core/playwright/validateFeature.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _parseUserArgs = _interopRequireDefault(require("./helpers/parseUserArgs"));
+var _readConfigFile = require("./readConfigFile");
+var _tagProcessor = require("./tag-processor");
+var _testRunner = require("./test-runner");
+var _logger = require("../../utils/logger");
+// @cucumber/gherkins need to be includ in package.json
+
+// const getFeatureFiles = (dir) => {
+//     let featureFiles = [];
+//     const files = fs.readdirSync(dir, { withFileTypes: true });
+//     files.forEach(file => {
+//       const fullPath = path.join(dir, file.name);
+//       if (file.isDirectory()) {
+//         featureFiles = featureFiles.concat(getFeatureFiles(fullPath));
+//       } else if (file.isFile() && fullPath.endsWith('.feature')) {
+//         featureFiles.push(fullPath);
+//       }
+//     });
+//     return featureFiles;
+//   };
+
+//const validateFeatureFiles = () => {
+// const featuresDir = path.join(process.cwd(), 'uat/modules');
+// const parser = new Parser();
+// const featureFiles = getFeatureFiles(featuresDir);
+// featureFiles.forEach( filePath => {
+//         const featureFileContent = fs.readFileSync(filePath, 'utf-8');
+//         try {
+//             parser.parse(featureFileContent);
+//             console.log(`${filePath}: Feature file is valid!`);
+//         } catch (error) {
+//             console.error(`${filePath}: Feature file is invalid - ${error.message}`);
+//         }
+// })
+//}
+
+const validateFeatureFiles = () => {
+  const userArgsObject = (0, _parseUserArgs.default)();
+  const uatConfig = (0, _readConfigFile.generateConfigFromFile)();
+  const {
+    editionOrder
+  } = uatConfig;
+  const configPath = (0, _readConfigFile.isUserConfigFileAvailable)() ? require.resolve('./setup/config-creator.js') : require.resolve('../../../playwright.config.js');
+  const tagArgs = (0, _tagProcessor.tagProcessor)(userArgsObject, editionOrder);
+  (0, _testRunner.runPreprocessing)(tagArgs, configPath).then(() => {
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Feature files validated successfully.');
+  }).catch(error => {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Error while validating the feature files - ${error}`);
+  });
+};
+var _default = exports.default = validateFeatureFiles;

package/build/lib/cli.js

@@ -10,6 +10,7 @@ var _parser = require("../parser/parser");
 var _clearCaches = _interopRequireDefault(require("../core/playwright/clear-caches"));
 var _helper = _interopRequireDefault(require("../setup-folder-structure/helper"));
 var _parseUserArgs = _interopRequireDefault(require("../core/playwright/helpers/parseUserArgs"));
+var _validateFeature = _interopRequireDefault(require("../core/playwright/validateFeature"));
 // import createJestRunner from '../core/jest/runner/jest-runner';
 
 const [,, option, ...otherOptions] = process.argv;
@@ -21,6 +22,11 @@ switch (option) {
       //createJestRunner();
       break;
     }
+  case 'validate':
+    {
+      (0, _validateFeature.default)();
+      break;
+    }
   case 're-run-failed':
     {
       _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Running Failed Tests..');

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

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _validateFeature = _interopRequireDefault(require("../../../../core/playwright/validateFeature"));
+var _parseUserArgs = _interopRequireDefault(require("../../../../core/playwright/helpers/parseUserArgs"));
+var _readConfigFile = require("../../../../core/playwright/readConfigFile");
+var _tagProcessor = require("../../../../core/playwright/tag-processor");
+var _testRunner = require("../../../../core/playwright/test-runner");
+var _logger = require("../../../../utils/logger");
+jest.mock('../../../../core/playwright/helpers/parseUserArgs', () => ({
+  __esModule: true,
+  default: jest.fn()
+}));
+jest.mock('../../../../core/playwright/readConfigFile');
+jest.mock('../../../../core/playwright/tag-processor');
+jest.mock('../../../../core/playwright/test-runner');
+jest.mock('../../../../utils/logger', () => ({
+  __esModule: true,
+  Logger: {
+    log: jest.fn(),
+    SUCCESS_TYPE: 'success',
+    FAILURE_TYPE: 'failure'
+  }
+}));
+describe('validateFeatureFiles', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('runPreprocessing with correct arguments and log success', async () => {
+    const mockUserArgs = {
+      mode: 'dev'
+    };
+    _parseUserArgs.default.mockReturnValue(mockUserArgs);
+    const mockConfig = {
+      editionOrder: ["beta", "enterprice"]
+    };
+    _readConfigFile.generateConfigFromFile.mockReturnValue(mockConfig);
+    _readConfigFile.isUserConfigFileAvailable.mockReturnValue(true);
+    const mockTagArgs = ['@beta_admin'];
+    _tagProcessor.tagProcessor.mockReturnValue(mockTagArgs);
+    _testRunner.runPreprocessing.mockResolvedValueOnce();
+    await (0, _validateFeature.default)();
+    expect(_parseUserArgs.default).toHaveBeenCalled();
+    expect(_readConfigFile.generateConfigFromFile).toHaveBeenCalled();
+    expect(_readConfigFile.isUserConfigFileAvailable).toHaveBeenCalled();
+    expect(_tagProcessor.tagProcessor).toHaveBeenCalledWith(mockUserArgs, ["beta", "enterprice"]);
+    expect(_testRunner.runPreprocessing).toHaveBeenCalledWith(mockTagArgs, expect.stringContaining('config-creator.js'));
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.SUCCESS_TYPE, 'Feature files validated successfully.');
+  });
+  test('runPreprocessing with playwright conf', async () => {
+    const mockTagArgs = ['@beta_admin'];
+    _tagProcessor.tagProcessor.mockReturnValue(mockTagArgs);
+    _readConfigFile.isUserConfigFileAvailable.mockReturnValue(false);
+    _testRunner.runPreprocessing.mockResolvedValueOnce();
+    await (0, _validateFeature.default)();
+    expect(_testRunner.runPreprocessing).toHaveBeenCalledWith(mockTagArgs, expect.stringContaining('playwright.config.js'));
+  });
+  test('error when runPreprocessing fails', async () => {
+    const mockError = new Error('Test error');
+    _testRunner.runPreprocessing.mockRejectedValueOnce(mockError);
+    await await (0, _validateFeature.default)();
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, `Error while validating the feature files - ${mockError}`);
+  });
+});

package/build/test/core/playwright/configuration/__tests__/Configuration.test.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const Configuration = require("../../../../../core/playwright/configuration/Configuration");
+const {
+  combineConfiguration
+} = require("../../../../../core/playwright/configuration/ConfigurationHelper");
+jest.mock('../../../../../core/playwright/configuration/ConfigurationHelper', () => ({
+  combineConfiguration: jest.fn()
+}));
+describe('Configuration Class', () => {
+  let config;
+  let sampleData;
+  beforeEach(() => {
+    // Sample data as a JSON object
+    sampleData = {
+      headless: false,
+      trace: true,
+      video: true,
+      bddMode: true
+    };
+
+    // Initialize the Configuration instance with sample data
+    config = new Configuration(sampleData);
+  });
+  test('should add new key-value pair to the configuration', () => {
+    config.add('newKey', 'newValue');
+    expect(config.get('newKey')).toBe('newValue');
+  });
+  test('should combine configurations correctly using addAll', () => {
+    const newConfig = new Configuration({
+      newKey1: 'newValue1',
+      trace: false // existing key to test override
+    });
+    const combinedConfig = {
+      headless: false,
+      trace: false,
+      // trace overridden
+      video: true,
+      bddMode: true,
+      newKey1: 'newValue1'
+    };
+    combineConfiguration.mockReturnValue(combinedConfig);
+    config.addAll(newConfig);
+    expect(combineConfiguration).toHaveBeenCalledWith(sampleData, newConfig.getAll());
+    expect(config.getAll()).toEqual(combinedConfig);
+  });
+  test('should return correct value for a given key', () => {
+    expect(config.get('headless')).toBe(false);
+    expect(config.get('trace')).toBe(true);
+    expect(config.get('video')).toBe(true);
+    expect(config.get('bddMode')).toBe(true);
+  });
+});

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

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _configFileNameProvider = require("../../../../../core/playwright/helpers/configFileNameProvider");
+jest.mock('fs');
+jest.mock('path');
+const mockCwd = '/mock/current/directory';
+_path.default.resolve = jest.fn();
+process.cwd = jest.fn(() => mockCwd);
+describe('getUATFileName', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('return the pipeline matched config files for pipeline matched files exists', () => {
+    const mode = 'cd';
+    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(mockPath);
+    expect(result).toBe(mockPath);
+  });
+  test('return the default config files for pipeline matched files not exists', () => {
+    const mode = 'ci';
+    const defaultPath = `${mockCwd}/uat.config.js`;
+    _fs.existsSync.mockReturnValue(false);
+    _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/utils/cliArgsToObject.js

@@ -36,6 +36,9 @@ function cliArgsToObject(cliArgs, isKeyNeedToBeAdded) {
         value = true;
       }
       processEnv[key] = value;
+      if (!isNaN(parseInt(value))) {
+        processEnv[key] = parseInt(value);
+      }
     }
   });
   return processEnv;

package/jest.config.js

@@ -56,14 +56,14 @@ module.exports = {
   collectCoverageFrom: ['src/**/*.js'],
   coverageDirectory: './build/cov',
   coverageReporters: ['lcov', 'json', 'html', 'json-summary', 'text'],
-  coverageThreshold: {
-    global: {
-      branches: 100,
-      functions: 100,
-      lines: 100,
-      statements: 100
-    }
-  },
+  // coverageThreshold: {
+  //   global: {
+  //     branches: 100,
+  //     functions: 100,
+  //     lines: 100,
+  //     statements: 100
+  //   }
+  // },
   globals: {
     __DEVELOPMENT__: true,
     __DOCS__: false,

package/npm-shrinkwrap.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/testinglibrary",
-  "version": "0.2.8",
+  "version": "0.3.8-experimental",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/testinglibrary",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "",
   "main": "./build/index.js",
   "scripts": {

package/playwright.config.js

@@ -18,7 +18,7 @@ export default defineConfig({
   /* Run tests in files in parallel */
   fullyParallel: true,
   /* Fail the build on CI if you accidentally left test.only in the source code. */
-  forbidOnly: !!process.env.CI,
+  //forbidOnly: !!process.env.CI,
   /* Retry on CI only */
   retries: process.env.CI ? 2 : 0,
   /* Reporter to use. See https://playwright.dev/docs/test-reporters */