@zohodesk/testinglibrary 0.0.5-exp.9 → 0.0.5-n20-experimental

package/build/parser/verifier.js

@@ -0,0 +1,130 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _path = _interopRequireDefault(require("path"));
+var _fastGlob = _interopRequireDefault(require("fast-glob"));
+var _parser = require("./parser");
+var _logger = require("../utils/logger");
+var _fileUtils = require("../utils/fileUtils");
+var _readConfigFile = require("../core/playwright/readConfigFile");
+var _stepDefinitionsFormatter = require("../utils/stepDefinitionsFormatter");
+// Specify the directory where you want to search for .feature and .spec.js files
+const directoryPath = './uat';
+
+// Use glob to match .feature files in the directory
+const featurePattern = _path.default.join(process.cwd(), directoryPath, '**/*.feature');
+
+// function onSpecFileNotFound() { }
+
+function verifyIfMultipleStepsExists(steps) {
+  let isMultipleStepsFound = false;
+  Object.keys(steps).map(step => {
+    if (steps[step].length > 1) {
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Multiple Steps Found for ${step} \n`);
+      steps[step].forEach(fileName => {
+        _logger.Logger.log(_logger.Logger.INFO_TYPE, `Files: \n ${fileName} \n`);
+      });
+      // multipleSteps.push({ step: steps[step] });
+      isMultipleStepsFound = true;
+    }
+  });
+  return isMultipleStepsFound;
+}
+function extractExamplesToSeperateFile(examples, scenarioIndex, filePath, featureName) {
+  let exampleFileContent = `export const ${featureName.toUpperCase()}_SCENARIO_${scenarioIndex} = ${JSON.stringify(examples, null, 2)};\r\n`;
+  const cleanedData = exampleFileContent.replace(/\r\n/g, '\n');
+  try {
+    (0, _fileUtils.writeFileContents)(filePath, cleanedData, {
+      flag: 'a'
+    });
+  } catch (err) {
+    _logger.Logger.error(err);
+    throw new Error(`Error appending or creating the test data file: ${filePath}`);
+  }
+}
+function verifyFeatureFileWithSpecFile() {
+  try {
+    let errorCount = 0;
+    let allStepsFound = {};
+    let {
+      featureFilesFolder = 'feature-files',
+      stepDefinitionsFolder = 'steps'
+    } = (0, _readConfigFile.generateConfigFromFile)();
+    const featureFiles = _fastGlob.default.globSync([featurePattern], {
+      dot: true
+    });
+    featureFiles.forEach(featureFile => {
+      // Construct the corresponding .spec.js filename
+      const specFile = featureFile.replace(/\.feature$/, '.spec.js').replace(`/${featureFilesFolder}/`, `/${stepDefinitionsFolder}/`);
+      let featureFileNameExtract = featureFile.split('/').pop();
+      let featurePrefixName = featureFileNameExtract.split('.')[0];
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `parsing feature file ${featureFileNameExtract}...`);
+      // Check if the .spec.js file exists
+
+      if ((0, _fileUtils.checkIfFileExists)(specFile)) {
+        let featureContents = (0, _fileUtils.readFileContents)(featureFile);
+        let specContents = (0, _fileUtils.readFileContents)(specFile);
+        //let [featureContents, specContents] = Promise.all([readFileContents(featureFile), readFileContents(specFile)]);
+        if (featureContents !== null && specContents !== null) {
+          const featureJSON = (0, _parser.parseFeature)(featureContents);
+          if (featureJSON && featureJSON.feature) {
+            let featureName = featureJSON.feature.name;
+            if (specContents.includes(featureName)) {
+              const scenarios = featureJSON.feature.scenarios;
+              const specLines = specContents.split('\n'); // Split specContents into lines
+              let testDataFilePath = featureFile.replace(`/${featureFilesFolder}/`, '/test-data/').replace(/\.feature$/, '.data.js');
+              // Examples to test data conversion. we are deleting the existing test data file and create a new file.
+              (0, _fileUtils.deleteFile)(testDataFilePath);
+              for (let i = 0; i < scenarios.length; i++) {
+                let scenario = scenarios[i];
+                const scenarioName = scenario.name;
+                const scenarioExamples = scenario.examples;
+                extractExamplesToSeperateFile(scenarioExamples, i, testDataFilePath, featurePrefixName);
+
+                // spec file check
+                if (!specLines.some(line => line.includes(scenarioName))) {
+                  errorCount++;
+                  _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Scenario: ${scenarioName} is missing in spec file`);
+                }
+                for (const step of scenario.steps) {
+                  if (!allStepsFound[step]) {
+                    allStepsFound[step] = [specFile];
+                  } else {
+                    allStepsFound[step].push(specFile);
+                  }
+                  const foundDelimiter = (0, _stepDefinitionsFormatter.findDelimiterFromStep)(step);
+                  if (foundDelimiter) {
+                    let splitResult = step.split(foundDelimiter);
+                    if (!specLines.some(line => line.includes(splitResult[1].trim().replace(/"/g, '\\"')))) {
+                      errorCount++;
+                      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Scenario: ${scenarioName} \n Step: ${step} is missing in the spec file ${specFile}`);
+                    }
+                  }
+                }
+              }
+            } else {
+              errorCount++;
+              _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `Feature Name ${featureName} does not match/exist in ${specFile}`);
+            }
+          }
+        } else {
+          errorCount++;
+          _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Error while reading feature file ${featureFile} or spec file ${specFile}`);
+        }
+      } else {
+        errorCount++;
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `No corresponding .spec.js file found for ${featureFile}`);
+      }
+    });
+    // Multiple steps found warning
+    verifyIfMultipleStepsExists(allStepsFound);
+    if (errorCount > 0) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Total Number of Errors found - ${errorCount}`);
+      throw new Error('Error while parsing feature files. Please fix the above issues before running test cases');
+    }
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, err);
+    process.exit(1);
+  }
+}
+verifyFeatureFileWithSpecFile();

package/build/setup-folder-structure/helper.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _commander = require("commander");
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../utils/logger");
+function helpercmd() {
+  const packageJsonPath = _path.default.resolve(process.cwd(), './package.json');
+  if ((0, _fs.existsSync)(packageJsonPath) && process.argv.includes('--version')) {
+    const {
+      dependencies
+    } = require(packageJsonPath);
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `zohodesk/testinglibrary Version : ${dependencies['@zohodesk/testinglibrary']}`);
+    _commander.program.version(dependencies['@zohodesk/testinglibrary'] || '0.0.1');
+    return;
+  }
+  _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Supported Commands...');
+  _commander.program.name('npx ZDTestingFramework');
+  _commander.program.command('test').description('This command is used to execute tests');
+  _commander.program.command('init').description('This command will initialize Project');
+  _commander.program.command('report').description('This command is used to generate a report summarizing the results of  executed tests.');
+  _commander.program.command('re-run-failed').description('This command will re-run the failed test cases based on test summary');
+  _commander.program.command('codegen').description('This command is used to assist developer to write test case');
+  _commander.program.option('--headed', 'Run tests with a headed browser.');
+  _commander.program.option('--debug', 'This command is used to initiate a debugging session');
+  _commander.program.option('--tags', 'Run specific test case with mentioned tags (Usage: -- --tags="@live")');
+  _commander.program.option('--workers', 'Specify number of workers to run the test case parallely (Usage: -- --workers=2)');
+  _commander.program.option('--edition', 'Specify edition to run the test cases (Usage: -- --edition="standard". This will run the test cases with either no edition mentioned or edition standard)');
+  _commander.program.option('--browsers', 'Specify the browsers on which the test case should run (Usage: -- --browsers="chrome,firefox,safari")');
+  _commander.program.parse(process.argv);
+}
+var _default = exports.default = helpercmd;

package/build/setup-folder-structure/reportEnhancement/addonScript.html

@@ -0,0 +1,25 @@
+<script>
+    function sortEdition(event) {
+      var currentURL = window.location.href;
+      const endPointCount = window.location.href.indexOf('#');
+      if (!(endPointCount == -1)) {
+        window.history.pushState({}, '', currentURL.slice(0, endPointCount));
+        currentURL = currentURL.slice(0, endPointCount);
+      }
+      console.log(currentURL);
+      window.open(`${currentURL}#?q=@edition_${event.target.value}`, '_self');
+    }
+  </script>
+  <div class="mainContainer" style="margin-left: 20px; display: flex;">
+    <div class="selectEditionContainer" style="padding: 20px;">
+      <select class="selectEdition" style="padding: 5px; width: 100px; border-radius: 6px; border: 1px solid var(--color-border-default);"  onchange="sortEdition(event)">
+        <option value="EnterPrise">EnterPrise</option>
+        <option value="Professional">Professional</option>
+        <option value="Express">Express</option>
+        <option value="Standard">Standard</option>
+        <option value="Free">Free</option>
+      </select>
+    </div>
+  </div>
+
+  

package/build/setup-folder-structure/reportEnhancement/reportAlteration.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.preProcessReport = preProcessReport;
+var _fs = _interopRequireDefault(require("fs"));
+var _logger = require("./../../utils/logger");
+var _path = _interopRequireDefault(require("path"));
+const htmlFilePath = _path.default.resolve(process.cwd(), 'uat', 'playwright-report', 'index.html');
+const fileHtml = _fs.default.readFileSync(htmlFilePath, 'utf-8');
+const addOnHtml = _fs.default.readFileSync(_path.default.resolve(__filename, '../', 'addonScript.html'), 'utf-8');
+const splitedHTML = fileHtml.split('\n');
+const toAdd = addOnHtml.split('\n');
+function preProcessReport() {
+  if (_fs.default.existsSync(htmlFilePath)) {
+    const modifiedContent = [...splitedHTML.slice(0, 55), ...toAdd, ...splitedHTML.slice(56)].join('').toString();
+    _fs.default.writeFileSync(htmlFilePath, modifiedContent);
+    return;
+  } else {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Report is not generated Properly ...');
+  }
+  return null;
+}

package/build/setup-folder-structure/samples/accountLogin-sample.js

@@ -0,0 +1,19 @@
+// This is the sample file generated by testing framework. You can change as per the respective project login
+
+const getUrlOrigin = require('../shared/url-helpers/getUrlOrigin');
+
+async function accountLogin( { page, email, password } ) {
+  await page.locator('#login_id').fill(email);
+  await page.locator('#nextbtn').click();
+  await page.locator('#password').fill(password);
+  await page.locator('#nextbtn').click();
+
+  const domainUrlOrigin = getUrlOrigin(process.env.domain);
+  await page.waitForNavigation();
+  await Promise.race([
+    page.waitForURL(`${domainUrlOrigin}/**`),
+    page.waitForURL('**/announcement/**')
+  ]);
+}
+
+module.exports  = accountLogin;

package/build/setup-folder-structure/samples/actors-index.js

@@ -0,0 +1,2 @@
+const editions = require('./editions/index');
+module.exports = { editions }

package/build/setup-folder-structure/samples/auth-setup-sample.js

@@ -0,0 +1,15 @@
+/* eslint-disable no-console */
+import { test as setup, expect } from '@zohodesk/testinglibrary';
+import {
+  performLoginSteps,
+  getDefaultActor
+} from '@zohodesk/testinglibrary/helpers';
+
+import { loginSteps , validateLogin } from './testSetup';
+
+const user = getDefaultActor();
+
+setup(`${user.edition} - Authentication`, async ({ page }) => {
+  //Implement performLoginSteps here
+  await performLoginSteps({page, ...user},validateLogin ,loginSteps);
+}); 

package/build/setup-folder-structure/samples/editions-index.js

@@ -0,0 +1,3 @@
+const free = require('./free.json');
+const editions = { free};
+module.exports = editions;

package/build/setup-folder-structure/samples/free-sample.json

@@ -0,0 +1,25 @@
+[
+    {
+      "id": "1",
+      "edition": "free",
+      "orgName": "orgFree",
+      "profiles": [
+        {
+          "profile": "admin",
+          "email": "admin+free@zohotest.com",
+          "password": "password@0987"
+        },
+        {
+          "profile": "agent",
+          "email": "agent@zohotest.com",
+          "password": "password@12345"
+        },
+        {
+          "profile": "lightagent",
+          "email": "lightagent@zohotest.com",
+          "password": "password@12345"
+        }
+      ]
+    }
+  ]
+  

package/build/setup-folder-structure/samples/git-ignore.sample.js

@@ -0,0 +1,37 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import path from 'path';
+import { Logger } from '../utils/logger';
+import { generateConfigFromFile } from '../core/playwright/readConfigFile';
+const gitIgnoreAbsolutePath = path.resolve(process.cwd(), '../', '../')
+
+const { reportPath = path.resolve(process.cwd(), 'uat', 'playwright-reports') } = generateConfigFromFile();
+const testResultsPath = path.resolve(process.cwd(), 'uat', 'test-results');
+
+const testResultsRelativepath = path.relative(gitIgnoreAbsolutePath, testResultsPath)
+const reportRelativepath = path.relative(gitIgnoreAbsolutePath, reportPath)
+
+
+const absolutePathfeaturegen = path.resolve(process.cwd(), 'uat', '.features-gen');
+const featuregenRelativePath = path.relative(gitIgnoreAbsolutePath,absolutePathfeaturegen)
+
+const dirpathtoIgnore = `${testResultsRelativepath}\n${reportRelativepath}\n${featuregenRelativePath}`
+
+function updateGitIgnore() {
+  if (existsSync(path.resolve(process.cwd(), '../', '../', '.gitignore'))) {
+    let gitIgnoreData = readFileSync(path.resolve(process.cwd(), '../', '../', '.gitignore'), 'utf-8', (err) => {
+      if (err) {
+        Logger.log(Logger.FAILURE_TYPE, 'cannot able to read git ignore ')
+        // process.exit()
+      }
+    })
+    if (gitIgnoreData.includes(dirpathtoIgnore)) {
+      return
+    } else {
+      writeFileSync(path.resolve(process.cwd(), '../', '../', '.gitignore', dirpathtoIgnore, null, 2))
+    }
+  } else {
+    Logger.log(Logger.INFO_TYPE, 'GitIgnore file is No Found ....')
+  }
+}
+
+export default updateGitIgnore;

package/build/setup-folder-structure/samples/settings.json

@@ -0,0 +1,7 @@
+{
+  "environment": "dev",
+  "edition": "enterprise",
+  "profile": "admin",
+  "domain": "https://zdesk-devops25.csez.zohocorpin.com:31037/agent",
+  "devUrl" : "" 
+}

package/build/setup-folder-structure/samples/testSetup-sample.js

@@ -0,0 +1,14 @@
+/* eslint-disable global-require */
+const accountLogin = require('./accountLogin');
+
+async function verifyPageIsLoaded({page}) {
+
+    //Implement your validation logic here
+    //Refer deskclientapp testSetup.js
+}
+
+module.exports = {
+  loginSteps:accountLogin,
+  validateLogin:verifyPageIsLoaded,
+  page:()=>{}
+};

package/build/setup-folder-structure/samples/uat-config-sample.js

@@ -0,0 +1,46 @@
+const testSetup = require('../../fixtures/testSetup');
+/**
+ * @typedef {Object|null} viewportConfig
+ * @property {number} width - width of the viewport
+ * @property {number} height - height of the viewport 
+ */
+/**
+ * Represents the user configuration object.
+ * @typedef {Object} UserConfig
+ * @property {string} headless - Headless Browsers mode.
+ * @property {number} trace - trace for test cases.
+ * @property {boolean} video - video for test cases,
+ * @property {boolean} debug - debug mode
+ * @property {string} mode: mode in which the test cases needs to run
+ * @property {boolean} isAuthMode -  Auth Mode. config whether authentication step needed before running test cases
+ * @property {string} authFilePath - File Path where the cookies stored
+ * @property {any} browsers: List of browsers
+ * @property {string} openReportOn: default Option value (never, on-failure and always) 
+ * @property {any} reportPath : directory where report is generate
+ * @property {boolean} bddMode: Feature files needs to be processed
+ * @property {number} expectTimeout: time in milliseconds which the expect condition should fail
+ * @property {number} testTimeout: time in milliseconds which the test should fail
+ * @property {Object} additionalPages: custom pages configuration
+ * @property {string} featureFilesFolder: folder name under which feature-files will be placed. Default is feature-files
+ * @property {string} stepDefinitionsFolder: folder name under which step implementations will be placed. Default is steps
+ * @property {viewportConfig} viewport: viewport configuration for the browser. Default is { width: 1280, height: 720 }
+ * @property {string} testIdAttribute: Change the default data-testid attribute. configure what attribute to search while calling getByTestId
+ */
+
+/**
+* @type {UserConfig}
+*/
+module.exports = {
+  headless: false,
+  browsers: ['Chrome', 'Firefox', 'Safari', 'Edge'],
+  mode: 'dev',
+  isAuthMode: true,
+  authFilePath: 'uat/playwright/.auth/user.json',
+  trace: true,
+  video: true,
+  bddMode: true,
+  featureFilesFolder: 'feature-files',
+  stepDefinitionsFolder: 'steps',
+  viewport: { width: 1280, height: 720 },
+  testSetup
+}

package/build/setup-folder-structure/setupProject.js

@@ -10,9 +10,10 @@ var _path = _interopRequireDefault(require("path"));
 var _logger = require("../utils/logger");
 function getScriptsToBeAdded() {
   return {
-    "ua-test": "ZDTestingFramework test --mode=prod --headed",
-    "ua-test-debug": "ZDTestingFramework test --mode=prod --debug",
-    "ua-report": "ZDTestingFramework report --port=9009",
+    "uat": "ZDTestingFramework test --mode=dev --headed",
+    "uat-debug": "ZDTestingFramework test --mode=dev --debug",
+    "uat-validate": "ZDTestingFramework validate",
+    "uat-report": "ZDTestingFramework report --port=9009",
     "codegen": "ZDTestingFramework codegen deskclientapp.localzoho.com/agent"
   };
 }
@@ -35,27 +36,24 @@ function updatePackageJSONScripts() {
     (0, _fs.writeFileSync)(packageJsonPath, JSON.stringify(modifiedConfigJSON, null, 2));
   } else {
     _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Unable to find package json. Run init command in the root path of the project.');
-    process.exit();
   }
 }
 function createFolderForUAT() {
   const uatFolder = _path.default.resolve(process.cwd(), 'uat');
   if ((0, _fs.existsSync)(uatFolder)) {
     _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Uat Folder already Exists.');
-    process.exit();
   } else {
     _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating Uat Folder');
     (0, _fs.mkdirSync)(uatFolder);
   }
 }
 function getSetupFileAsString(fileName) {
-  return (0, _fs.readFileSync)(_path.default.resolve(__dirname, './', fileName)).toString();
+  return (0, _fs.readFileSync)(_path.default.resolve(__dirname, './samples/', fileName)).toString();
 }
 function createUatConfig() {
   const uatConfigPath = _path.default.resolve(process.cwd(), 'uat.config.js');
   if ((0, _fs.existsSync)(uatConfigPath)) {
     _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Uat Config already Exists.');
-    process.exit();
   } else {
     _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating Uat config file...');
     (0, _fs.writeFileSync)(uatConfigPath, getSetupFileAsString('uat-config-sample.js'), null, 2);
@@ -64,17 +62,23 @@ function createUatConfig() {
 function createAuthenticationFile() {
   const isUATexist = _path.default.resolve(process.cwd(), 'uat');
   if ((0, _fs.existsSync)(isUATexist)) {
-    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating Authentication File ....');
     try {
-      (0, _fs.mkdirSync)(_path.default.resolve(process.cwd(), 'playwright'), {
-        recursive: true
-      });
-      (0, _fs.mkdirSync)(_path.default.resolve(process.cwd(), 'playwright', '.auth'), {
-        recursive: true
-      });
-      const authFilePath = _path.default.resolve(process.cwd(), 'playwright', '.auth', 'user.json');
-      (0, _fs.writeFileSync)(authFilePath, getSetupFileAsString('user-example.json'), null, 2);
+      if (!(0, _fs.existsSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures'))) {
+        (0, _fs.mkdirSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures'));
+      }
+      if (!(0, _fs.existsSync)(_path.default.resolve(process.cwd(), 'uat', 'playwright', '.auth'))) {
+        (0, _fs.mkdirSync)(_path.default.resolve(process.cwd(), 'uat', 'playwright', '.auth'), {
+          recursive: true
+        });
+      }
+      (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'auth.setup.js'), getSetupFileAsString('auth-setup-sample.js'), null, 2);
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating Authentication File ....');
+      (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'accountLogin.js'), getSetupFileAsString('accountLogin-sample.js'), null, 2);
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating login script File ....');
+      (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'testSetup.js'), getSetupFileAsString('testSetup-sample.js'), null, 2);
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating testSetup File ....');
     } catch (err) {
+      _logger.Logger.error(err);
       _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Something went wrong ! Folder not Created. Please re-initialize npm init-uat');
     }
   } else {
@@ -84,8 +88,21 @@ function createAuthenticationFile() {
 function createConfigJson() {
   const uatFolder = _path.default.resolve(process.cwd(), 'uat');
   if ((0, _fs.existsSync)(uatFolder)) {
-    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating env-config file inside UAT Folder');
-    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, './env-config.json'), getSetupFileAsString('env-config-sample.json'), null, 2);
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating settings.json file inside UAT Folder');
+    if (!(0, _fs.existsSync)(_path.default.resolve(uatFolder, 'conf', 'default'))) {
+      (0, _fs.mkdirSync)(_path.default.resolve(uatFolder, 'conf', 'default'), {
+        recursive: true
+      });
+    }
+    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', './settings.json'), getSetupFileAsString('settings.json'), null, 2);
+    if (!(0, _fs.existsSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions'))) {
+      (0, _fs.mkdirSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions'), {
+        recursive: true
+      });
+    }
+    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions', 'free.json'), getSetupFileAsString('free-sample.json'), null, 2);
+    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions', 'index.js'), getSetupFileAsString('editions-index.js'), null, 2);
+    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'index.js'), getSetupFileAsString('actors-index.js'), null, 2);
   } else {
     _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Something went wrong. Please re-initialize the @zohodesk/testinglibrary');
   }
@@ -96,6 +113,7 @@ function setupProject() {
   createFolderForUAT();
   createConfigJson();
   createAuthenticationFile();
+  //updateGitIgnore()
   // Create folder for playwright . Inside .auth folder needs to be created. user.json
   // Add playwright and test-results to .gitignore
   setTimeout(() => {

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

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _tagProcessor = _interopRequireDefault(require("../../../../../src/core/playwright/tagProcessor"));
+var _logger = require("../../../../utils/logger");
+jest.mock('../../../../utils/logger');
+describe('TagProcessor', () => {
+  const editionOrder = ['edition1', 'edition2', 'edition3', 'edition4'];
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('should return tagArgs if no edition is provided', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: null
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1');
+  });
+  test('should handle a single edition with <= operator', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: '<=edition2'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition3 or @edition_edition4)');
+  });
+  test('should handle a single edition with >= operator', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: '>=edition2'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition1)');
+  });
+  test('should handle a single edition with < operator', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: '<edition3'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition3 or @edition_edition4)');
+  });
+  test('should handle a single edition with > operator', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: '>edition1'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition1)');
+  });
+  test('should handle a single edition with no operator', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: 'edition2'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition1 or @edition_edition3 or @edition_edition4)');
+  });
+  test('should log a message if edition is not found', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: 'nonexistentEdition'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1');
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.INFO_TYPE, expect.stringContaining('No matching editions for nonexistentEdition found.'));
+  });
+  test('should handle multiple editions', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: 'edition1,edition3'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition2 or @edition_edition4)');
+  });
+  test('should build tags correctly when tags are empty', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: '',
+      edition: 'edition1'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('not (@edition_edition2 or @edition_edition3 or @edition_edition4)');
+  });
+});