@zohodesk/testinglibrary 0.3.0-experimental → 0.3.0

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

@@ -18,6 +18,7 @@ class JSONSummaryReporter {
     this.skipped = [];
     this.failed = [];
     this.warned = [];
+    this.errored = [];
     this.interrupted = [];
     this.timedOut = [];
     this.flakey = [];
@@ -29,7 +30,7 @@ class JSONSummaryReporter {
   onBegin() {
     this.startedAt = Date.now();
   }
-  onTestEnd(test, result) {
+  getTitle(test) {
     const title = [];
     const fileName = [];
     let clean = true;
@@ -39,35 +40,52 @@ class JSONSummaryReporter {
       }
       clean = false;
       title.push(s);
-      if (s.includes('.ts') || s.includes('.js')) {
+      if (s.endsWith('.ts') || s.endsWith('.js')) {
         fileName.push(s);
       }
     }
-    // This will publish the file name + line number test begins on
-    const z = `${fileName[0]}`;
-    // Using the t variable in the push will push a full test name + test description
-    const t = title.join(' > ');
+
+    //Using the fullTitle variable in the push will push a full test name + test description
+
+    return {
+      fullTitle: title.join(' > '),
+      fileName: fileName[0] || ''
+    };
+  }
+  onTestEnd(test, result) {
+    const {
+      fullTitle,
+      fileName
+    } = this.getTitle(test);
+
     // Set the status
-    const stepTitleList = result.steps.map(step => ({
+    const stepTitleList = result.steps.filter(step => step.error).map(step => ({
       title: step.title,
       error: step.error,
-      testTitle: t
-    })).filter(step => step.error !== undefined);
+      testTitle: fullTitle
+    }));
     if (stepTitleList.length > 0) {
       this.failedSteps = [...this.failedSteps, ...stepTitleList];
     }
-    const status = !['passed', 'skipped'].includes(result.status) && t.includes('@warn') ? 'warned' : result.status;
+    const status = !['passed', 'skipped'].includes(result.status) && fullTitle.includes('@warn') ? 'warned' : result.status;
     // Logic to push the results into the correct array
     if (result.status === 'passed' && result.retry >= 1) {
-      this.flakey.push(z);
+      this.flakey.push(fileName);
     } else {
-      this[status].push(z);
+      this[status].push(fileName);
     }
-    this[status].push(z);
+    this[status].push(fileName);
+  }
+  onError(error) {
+    this.errored.push({
+      error: error.message,
+      stack: error.stack
+    });
   }
   onEnd(result) {
     this.durationInMS = Date.now() - this.startedAt;
     this.status = result.status;
+
     // removing duplicate tests from passed array
     this.passed = this.passed.filter((element, index) => {
       return this.passed.indexOf(element) === index;
@@ -90,6 +108,14 @@ class JSONSummaryReporter {
     this.interrupted = this.interrupted.filter((element, index) => {
       return this.interrupted.indexOf(element) === index;
     });
+    this.errored = this.errored.filter((element, index) => {
+      return this.errored.indexOf(element) === index;
+    });
+    if (this.errored.length > 0) {
+      // Reflect setup failures in the final report status
+      this.status = "failed";
+    }
+
     // fs.writeFileSync('./summary.json', JSON.stringify(this, null, '  '));
     let {
       reportPath

package/build/core/playwright/tagProcessor.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _logger = require("../../utils/logger");
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var _TagProcessor_brand = /*#__PURE__*/new WeakSet();
+class TagProcessor {
+  constructor(editionOrder) {
+    _classPrivateMethodInitSpec(this, _TagProcessor_brand);
+    this.editionOrder = editionOrder;
+  }
+  processTags(userArgs) {
+    const tagArgs = userArgs['tags'] || '';
+    const edition = userArgs['edition'] || null;
+    if (!edition) return tagArgs;
+    const editionsArray = edition.split(',');
+    const editionTags = editionsArray.length === 1 ? _assertClassBrand(_TagProcessor_brand, this, _processSingleEdition).call(this, editionsArray[0], tagArgs) : _assertClassBrand(_TagProcessor_brand, this, _processMultipleEditions).call(this, editionsArray, tagArgs);
+    return editionTags;
+  }
+}
+function _buildTagsString(tags, editionTags) {
+  return tags && tags !== '' ? `${tags} and not (${editionTags})` : `not (${editionTags})`;
+}
+function _parseEdition(edition) {
+  if (edition.startsWith('<=')) return ['<=', edition.slice(2)];
+  if (edition.startsWith('>=')) return ['>=', edition.slice(2)];
+  if (edition.startsWith('<')) return ['<', edition.slice(1)];
+  if (edition.startsWith('>')) return ['>', edition.slice(1)];
+  return [null, edition];
+}
+function _processSingleEdition(selectedEdition, tagArgs) {
+  const editionArgs = _assertClassBrand(_TagProcessor_brand, this, _getEditionArgs).call(this, selectedEdition);
+  if (editionArgs && editionArgs.length > 0) {
+    const editionTags = _assertClassBrand(_TagProcessor_brand, this, _buildEditionTags).call(this, editionArgs, 'or');
+    return _assertClassBrand(_TagProcessor_brand, this, _buildTagsString).call(this, tagArgs, editionTags);
+  }
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `No matching editions for ${selectedEdition} found. Running with default edition`);
+  return tagArgs;
+}
+function _processMultipleEditions(editionsArray, tagArgs) {
+  const filteredEditions = this.editionOrder.filter(edition => !editionsArray.includes(edition));
+  const editionTags = _assertClassBrand(_TagProcessor_brand, this, _buildEditionTags).call(this, filteredEditions, 'or');
+  return _assertClassBrand(_TagProcessor_brand, this, _buildTagsString).call(this, tagArgs, editionTags);
+}
+function _getEditionArgs(selectedEdition) {
+  const [operator, editionValue] = _assertClassBrand(_TagProcessor_brand, this, _parseEdition).call(this, selectedEdition.toLowerCase());
+  const index = this.editionOrder.findIndex(edition => edition.toLowerCase() === editionValue);
+  if (index === -1) {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `No matching editions for ${selectedEdition} found. Running with default edition`);
+    return [];
+  }
+  switch (operator) {
+    case '<=':
+      return this.editionOrder.slice(index + 1);
+    case '>=':
+      return this.editionOrder.slice(0, index);
+    case '<':
+      return this.editionOrder.slice(index);
+    case '>':
+      return this.editionOrder.slice(0, index + 1);
+    default:
+      return this.editionOrder.filter((_, i) => i !== index);
+  }
+}
+function _buildEditionTags(editionArgs, operator = 'or') {
+  return editionArgs.map(edition => `@edition_${edition}`).join(` ${operator} `);
+}
+module.exports = TagProcessor;

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");
@@ -13,10 +14,12 @@ var _envInitializer = require("./env-initializer");
 var _logger = require("../../utils/logger");
 var _readConfigFile = require("./readConfigFile");
 var _rootPath = require("../../utils/rootPath");
-var _tagProcessor = require("./tag-processor");
+var _tagProcessor = _interopRequireDefault(require("./tagProcessor"));
 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
@@ -40,7 +43,7 @@ function getPlaywrightArgs(userArgsObject, debug, bddMode, tagArgs, headless) {
 }
 function runPreprocessing(tagArgs, configPath) {
   const beforeCommand = 'node';
-  const bddGenPath = _path.default.resolve(__dirname, '../', '../', 'bdd-framework', 'cli', 'index.js');
+  const bddGenPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('bddgen'));
   const beforeArgs = [bddGenPath, '-c', configPath];
   if (tagArgs) {
     beforeArgs.push('--tags');
@@ -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,17 +100,30 @@ 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);
-  const tagArgs = (0, _tagProcessor.tagProcessor)(userArgsObject, editionOrder);
+    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 tagProcessor = new _tagProcessor.default(editionOrder);
+  const tagArgs = tagProcessor.processTags(userArgsObject);
   const playwrightArgs = getPlaywrightArgs(userArgsObject, debug, bddMode, tagArgs, headless);
   const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
   const command = playwrightPath;

package/build/core/playwright/validateFeature.js

@@ -0,0 +1,28 @@
+"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 = _interopRequireDefault(require("./tagProcessor"));
+var _testRunner = require("./test-runner");
+var _logger = require("../../utils/logger");
+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 tagProcessor = new _tagProcessor.default(editionOrder);
+  const tagArgs = tagProcessor.processTags(userArgsObject);
+  (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/decorators.d.ts

@@ -1 +1 @@
-export * from './bdd-framework/decorators';
+export * from 'playwright-bdd/decorators';

package/build/decorators.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _decorators = require("./bdd-framework/decorators");
+var _decorators = require("playwright-bdd/decorators");
 Object.keys(_decorators).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _decorators[key]) return;

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/setup-folder-structure/samples/actors-index.js

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

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

@@ -1,73 +1,21 @@
 /* eslint-disable no-console */
 import { test as setup, expect } from '@zohodesk/testinglibrary';
-import path from 'path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { getAuthFileDirectory } from '../../core/playwright';
-import { Logger } from '../../utils/logger';
+import {
+  performLoginSteps,
+  getDefaultActor
+} from '@zohodesk/testinglibrary/helpers';
 
-const userdata = require('./authUsers.json');
+const user = getDefaultActor();
 
-const authContent = { cookies: [] };
-
-const LOGIN_ERR_MESSAGE = 'Need go be logged in';
-// const AUTH_ERR_MESSAGE = `Founded Path - ${path.resolve(process.cwd(),'uat','playwright','.auth')} \n Find if file is Properly Created. Cookies Cannot Be Read .. `
-
-function convertCookiesToParse(cookies, authFilePath) {
-  try {
-    return JSON.parse(cookies);
-  } catch (err) {
-    Logger.error(err);
-    throw new Error(
-      ` Error while parsing cookies ${err} \n${path.resolve(
-        process.cwd(),
-        authFilePath
-      )} File is Empty`
-    );
-    // process.exit()
-  }
-}
-const authDirectory = getAuthFileDirectory(); //path.resolve(process.cwd(), 'uat', 'playwright', '.auth');
-if (!existsSync(authDirectory)) {
-  console.log('Creating auth directory for the first time setup...');
-  mkdirSync(authDirectory, { recursive: true });
+async function verifyPageIsLoaded(page) {
+  //Implement your validation steps here
+  //Refer desk_client_app auth.setup.js
+  return true;
 }
 
-userdata.forEach(data => {
-  const authFile = path.resolve(path.join(authDirectory, `${data.filename}`));
-  if (!existsSync(authFile)) {
-    console.log('creating auth file..');
-    writeFileSync(authFile, JSON.stringify(authContent, null, 2));
-  }
-  setup(data.description, async ({ page }) => {
-    try {
-      const cookies = readFileSync(authFile);
-      const parsedCookies = convertCookiesToParse(cookies, authFile);
-      await page
-        .context()
-        .addCookies(
-          parsedCookies.cookies === undefined ? [] : parsedCookies.cookies
-        );
-      await page.goto(page.getBaseUrl());
-      await page.waitForLoadState();
-      if (await page.url().includes(process.env.domain)) {
-        await page.waitForSelector(data.locator);
-      } else {
-        throw new Error(LOGIN_ERR_MESSAGE);
-      }
-    } catch (err) {
-      if (err.message === LOGIN_ERR_MESSAGE) {
-        await expect(page.locator('.load-bg')).toBeHidden();
-        await page.locator('#login_id').type(data.useremail);
-        await page.locator('#nextbtn').click();
-        await page.locator('#password').type(data.password);
-        await page.locator('#nextbtn').click();
-
-        await page.waitForLoadState('networkidle');
-
-        await page.waitForSelector(data.locator);
+setup(`${user.edition} - Authentication`, async ({ page }) => {
 
-        await page.context().storageState({ path: authFile });
-      }
-    }
-  });
-});
+  //Implement performLoginSteps here
+  const { email, password } = user;
+  await performLoginSteps({ },verifyPageIsLoaded );
+});

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/settings.json

@@ -0,0 +1,7 @@
+{
+  "environment": "dev",
+  "edition": "enterprise",
+  "profile": "admin",
+  "domain": "https://desk.localzoho.com/agent",
+  "devUrl" : "" 
+}

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

@@ -10,8 +10,9 @@ var _path = _interopRequireDefault(require("path"));
 var _logger = require("../utils/logger");
 function getScriptsToBeAdded() {
   return {
-    "uat": "ZDTestingFramework test --mode=prod --headed",
-    "uat-debug": "ZDTestingFramework test --mode=prod --debug",
+    "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"
   };
@@ -71,7 +72,6 @@ function createAuthenticationFile() {
         });
       }
       (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'auth.setup.js'), getSetupFileAsString('auth-setup-sample.js'), null, 2);
-      (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'authUsers.json'), getSetupFileAsString('authUsers-sample.json'), null, 2);
       _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating Authentication File ....');
     } catch (err) {
       _logger.Logger.error(err);
@@ -84,8 +84,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');
   }

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

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

@@ -0,0 +1,69 @@
+"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 = _interopRequireDefault(require("../../../../core/playwright/tagProcessor"));
+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/tagProcessor');
+jest.mock('../../../../core/playwright/test-runner');
+jest.mock('../../../../utils/logger', () => ({
+  __esModule: true,
+  Logger: {
+    log: jest.fn(),
+    SUCCESS_TYPE: 'success',
+    FAILURE_TYPE: 'failure'
+  }
+}));
+describe('validateFeatureFiles', () => {
+  let tagProcessorInstance;
+  beforeEach(() => {
+    jest.clearAllMocks();
+    tagProcessorInstance = {
+      processTags: jest.fn()
+    };
+    _tagProcessor.default.mockImplementation(() => tagProcessorInstance);
+  });
+  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'];
+    tagProcessorInstance.processTags.mockReturnValue(mockTagArgs);
+    _testRunner.runPreprocessing.mockResolvedValueOnce();
+    await (0, _validateFeature.default)();
+    expect(_parseUserArgs.default).toHaveBeenCalled();
+    expect(_readConfigFile.generateConfigFromFile).toHaveBeenCalled();
+    expect(_readConfigFile.isUserConfigFileAvailable).toHaveBeenCalled();
+    expect(tagProcessorInstance.processTags).toHaveBeenCalledWith(mockUserArgs);
+    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'];
+    tagProcessorInstance.processTags.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}`);
+  });
+});