@zohodesk/testinglibrary 0.0.5 → 0.0.6

package/build/lib/cli.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _testRunner = _interopRequireDefault(require("../core/playwright/test-runner"));
+var _reportGenerator = _interopRequireDefault(require("../core/playwright/report-generator"));
+var _codegen = _interopRequireDefault(require("../core/playwright/codegen"));
+var _logger = require("../utils/logger");
+var _setupProject = _interopRequireDefault(require("../setup-folder-structure/setupProject"));
+var _parser = require("../parser/parser");
+// import createJestRunner from '../core/jest/runner/jest-runner';
+
+const [,, option, ...otherOptions] = process.argv;
+// const args = process.argv.slice(3);
+// const appPath = process.cwd();
+
+switch (option) {
+  case 'test':
+    {
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Running Tests..');
+      (0, _testRunner.default)();
+      //createJestRunner();
+      break;
+    }
+  case 'report':
+    {
+      // console.log('\x1b[36mGenerating Reports...\x1b[0m');
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Generating Reports...');
+      (0, _reportGenerator.default)();
+      break;
+    }
+  case 'codegen':
+    {
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'The purpose of codegen is to assist developer .....');
+      (0, _codegen.default)();
+      break;
+    }
+  case 'init':
+    {
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Initializing projects...');
+      (0, _setupProject.default)();
+      break;
+    }
+  case 'generateSpecFile':
+    {
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Generating Spec file...');
+      (0, _parser.generateSpecCodeForFeatureFile)(otherOptions);
+      break;
+    }
+  default:
+    {
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Supported Commands test and report');
+      break;
+    }
+}

package/build/lib/post-install.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _path = _interopRequireDefault(require("path"));
+var _child_process = require("child_process");
+var _logger = require("../utils/logger");
+var _getFilePath = _interopRequireDefault(require("../utils/getFilePath"));
+const playwrightPath = _path.default.resolve('node_modules', '.bin', (0, _getFilePath.default)('playwright'));
+const command = playwrightPath;
+const args = ['install'];
+_logger.Logger.log(_logger.Logger.INFO_TYPE, 'Downloading browsers for running tests');
+const childProcess = (0, _child_process.spawn)(command, args, {
+  stdio: 'inherit'
+});
+childProcess.on('error', error => {
+  _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error);
+});

package/build/lint/index.js

@@ -0,0 +1,4 @@
+// const { parse, Document } = require('gherkin-io');
+
+// const document = await parse("Feature: Test\n...", "./features/test.feature");
+"use strict";

package/build/parser/parser.js

@@ -0,0 +1,206 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateSpecCodeForFeatureFile = generateSpecCodeForFeatureFile;
+exports.parseFeature = parseFeature;
+exports.specFileGenerator = specFileGenerator;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../utils/logger");
+var _cliArgsToObject = require("../utils/cliArgsToObject");
+var _fileUtils = require("../utils/fileUtils");
+var _readConfigFile = require("../core/playwright/readConfigFile");
+var _stepDefinitionsFormatter = require("../utils/stepDefinitionsFormatter");
+function parseFeature(featureContent) {
+  const lines = featureContent.split('\n');
+  let currentFeature = null;
+  let currentScenario = null;
+  let insideExampleTable = false;
+  let isHeaderRow = false; // To skip the first row in the Examples section
+
+  const parsedData = {
+    feature: null,
+    scenarios: []
+  };
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.startsWith('Feature:')) {
+      if (currentFeature) {
+        parsedData.feature = currentFeature;
+      }
+      currentFeature = {
+        name: trimmedLine.replace('Feature:', '').trim(),
+        scenarios: []
+      };
+    } else if (trimmedLine.startsWith('Scenario:')) {
+      if (currentScenario) {
+        currentFeature.scenarios.push(currentScenario);
+      }
+      currentScenario = {
+        name: trimmedLine.replace('Scenario:', '').trim(),
+        steps: [],
+        examples: []
+      };
+      insideExampleTable = false;
+    } else if (trimmedLine.startsWith('Examples:')) {
+      insideExampleTable = true;
+      isHeaderRow = true; // Reset to true for each Examples section
+      const headerLine = lines[lines.indexOf(line) + 1].trim();
+      const tableHeader = headerLine.split('|').filter(cell => cell !== "").map(cell => cell.trim());
+      currentScenario.examples.push({
+        tableHeader,
+        tableRows: []
+      });
+    } else if (insideExampleTable && trimmedLine.startsWith('|')) {
+      if (!isHeaderRow) {
+        const exampleRow = trimmedLine.split('|').filter(cell => cell !== "").map(cell => cell.trim());
+        if (exampleRow.length === currentScenario.examples[0].tableHeader.length) {
+          currentScenario.examples[0].tableRows.push(exampleRow);
+        }
+      } else {
+        isHeaderRow = false;
+      }
+    } else if (trimmedLine.startsWith('Given') || trimmedLine.startsWith('When') || trimmedLine.startsWith('Then') || trimmedLine.startsWith('And')) {
+      currentScenario.steps.push(trimmedLine);
+    }
+  }
+  if (currentFeature) {
+    parsedData.feature = currentFeature;
+  }
+  if (currentScenario) {
+    currentFeature.scenarios.push(currentScenario);
+  }
+  return parsedData;
+}
+function generateSpecFileContent({
+  feature
+}) {
+  let specContent = 'import { test } from "@zohodesk/testinglibrary";\n\n';
+  if (feature && feature.scenarios && feature.scenarios.length > 0) {
+    //specContent += `test.describe('${feature.name}', () => {\n`;
+    specContent += `// Feature: ${feature.name} \n`;
+    feature.scenarios.forEach(scenario => {
+      // specContent += '	/*\n'
+      // if (scenario.steps && scenario.steps.length > 0) {
+      // 	scenario.steps.forEach(step => {
+      // 		specContent += `		** ${step}\n`
+      // 	})
+
+      // }
+      // specContent += '	*/\n'
+      specContent += `test('${scenario.name}', async({ Given, When, Then, And }) => {\n`;
+      //specContent += `		// Your implementation here\n`;
+      if (scenario.steps && scenario.steps.length > 0) {
+        scenario.steps.forEach(step => {
+          let foundDelimiter = (0, _stepDefinitionsFormatter.findDelimiterFromStep)(step);
+          if (foundDelimiter) {
+            // Wrap the part of the string after the delimiter with a function call
+            let splitResult = step.split(foundDelimiter);
+            let wrappedString = `	await ${foundDelimiter}(${JSON.stringify(splitResult[1].trim())}, () => {\n		//${foundDelimiter} Implementation will be here\n	})();\n\n`;
+            specContent += wrappedString;
+          }
+        });
+      }
+      specContent += `});\n\n`;
+    });
+    //specContent += `});\n\n`;
+  }
+
+  return specContent;
+}
+function updateExistingSpecFile({
+  feature
+}, specFile) {
+  if (feature && feature.scenarios && feature.scenarios.length > 0) {
+    let specFileCode = _fs.default.readFileSync(specFile, 'utf8');
+    feature.scenarios.forEach(({
+      name,
+      steps
+    }) => {
+      const scenarioComment = `/*\n${steps.map(step => `    ** ${step}`).join('\n')}\n	*/`;
+      const testNamePattern = new RegExp(`test\\('${name}',`, 'g');
+      const testNameMatches = specFileCode.match(testNamePattern);
+      if (testNameMatches) {
+        testNameMatches.forEach(match => {
+          const startIdx = specFileCode.indexOf(match);
+
+          // Find the index of the comment above the test block
+          const commentStartIdx = specFileCode.lastIndexOf('/*', startIdx);
+          const commentEndIdx = specFileCode.lastIndexOf('*/', startIdx);
+          if (commentStartIdx >= 0 && commentEndIdx > commentStartIdx) {
+            // Remove the old comment above the test block
+            specFileCode = specFileCode.slice(0, commentStartIdx) + scenarioComment + specFileCode.slice(commentEndIdx + 2);
+          }
+        });
+      } else {
+        // Create a new test block if the test name is not found
+        const newTestBlock = `	${scenarioComment}\n	test('${name}', () => {\n    // Your implementation here\n	});\n\n\n`;
+        // Locate the closest describe block for the new test
+        const lastDescribeEndIdx = specFileCode.lastIndexOf('});');
+        specFileCode = specFileCode.slice(0, lastDescribeEndIdx) + newTestBlock + specFileCode.slice(lastDescribeEndIdx);
+      }
+    });
+
+    // Save the updated code back to the spec file
+    _fs.default.writeFileSync(specFile, specFileCode, 'utf8');
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Spec file updated successfully');
+  }
+}
+function specFileGenerator(filePath, isUpdate) {
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Generating spec file using file ${filePath}`);
+  // Read the Gherkin feature file
+  let {
+    featureFilesFolder = 'feature-files',
+    stepDefinitionsFolder = 'steps'
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  _fs.default.readFile(filePath, 'utf8', (err, data) => {
+    if (err) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Error reading the file: ${err}`);
+    } else {
+      // Parse the feature file content and get the JSON-like object
+      const parsedFeature = parseFeature(data);
+      let specFilePath = filePath.replace(/\.feature$/, '.spec.js');
+      if (filePath.includes(`${featureFilesFolder}`)) {
+        specFilePath = specFilePath.replace(`/${featureFilesFolder}/`, `/${stepDefinitionsFolder}/`);
+      } else {
+        specFilePath = specFilePath.replace('./', `${stepDefinitionsFolder}`);
+      }
+      if ((0, _fileUtils.checkIfFileExists)(specFilePath)) {
+        if (isUpdate) {
+          updateExistingSpecFile(parsedFeature, specFilePath);
+        } else {
+          _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'File Already exists. Make sure to either delete or pass --update option true');
+        }
+        return;
+      }
+
+      // Output the JSON-like object
+      //console.log(JSON.stringify(parsedFeature, null, 2));
+      //fs.writeFileSync('./sample.json', JSON.stringify(parsedFeature, null, 2));
+      const specFileContent = generateSpecFileContent(parsedFeature);
+
+      // Write the spec file content to a new file
+      try {
+        (0, _fileUtils.writeFileContents)(specFilePath, specFileContent);
+        _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Spec file generated successfully.');
+      } catch (writeErr) {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Error writing the spec file: ${writeErr}`);
+      }
+    }
+  });
+}
+function generateSpecCodeForFeatureFile(options) {
+  let cliObj = (0, _cliArgsToObject.cliArgsToObject)(options);
+  let {
+    featureFile: featureFilePath = null,
+    update = false
+  } = cliObj;
+  if (featureFilePath) {
+    specFileGenerator(_path.default.join(process.cwd(), './', featureFilePath), update);
+  } else {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Need option --featureFile to run this command');
+  }
+}

package/build/parser/sample.feature

@@ -0,0 +1,34 @@
+Feature: Home Page
+
+  Scenario: Home Page Default content
+    Given user is on "<App>" home page
+    Then user gets a "<App>" bootcamp section
+    And username is also displayed on right corner
+
+    Examples: 
+      | App    |
+      | GitHub |
+
+  Scenario: GitHub Bootcamp Section
+    Given user is on "<Site>" home page
+    When user focuses on "<Site>" Bootcamp Section
+    Then user gets an option to setup git
+    And user gets an option to create repository
+    And user gets an option to Fork Repository
+    And user gets an option to work together
+
+    Examples: 
+      | Site   |
+      | GitHub |
+
+  Scenario: Top Banner content
+    Given user is on "<Product>" home page
+    When user focuses on Top Banner
+    Then user gets an option of home page
+    And user gets an option to search
+    And user gets settings options
+    And user gets an option to logout
+
+    Examples: 
+      | Product |
+      | GitHub  |

package/build/parser/sample.spec.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _testinglibrary = require("@zohodesk/testinglibrary");
+_testinglibrary.test.describe('Home Page', () => {
+  /*
+  ** Given user is on "<App>" home page
+  ** Then user gets a "<App>" bootcamp section
+  ** And username is also displayed on right corner
+  */
+  (0, _testinglibrary.test)('Home Page Default content', () => {
+    // Your implementation here
+  });
+
+  /*
+  ** Given user is on "<Site>" home page
+  ** When user focuses on "<Site>" Bootcamp Section
+  ** Then user gets an option to setup git
+  ** And user gets an option to create repository
+  ** And user gets an option to Fork Repository
+  ** And user gets an option to work together
+  */
+  (0, _testinglibrary.test)('GitHub Bootcamp Section', () => {
+    // Your implementation here
+  });
+
+  /*
+  ** Given user is on "<Product>" home page
+  ** When user focuses on Top Banner
+  ** Then user gets an option of home page
+  ** And user gets an option to search
+  ** And user gets settings options
+  ** And user gets an option to logout
+  */
+  (0, _testinglibrary.test)('Top Banner content', () => {
+    // Your implementation here
+  });
+});

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/samples/auth-setup-sample.js

@@ -0,0 +1,72 @@
+/* eslint-disable no-console */
+import { test as setup, expect } from '@zohodesk/testinglibrary';
+import path from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+
+const userdata = require('./authUsers.json');
+
+const authDirectory = path.resolve(process.cwd(), 'uat', 'playwright', '.auth');
+
+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) {
+    throw new Error(` Error while parsing cookies ${err} \n${path.resolve(process.cwd(), authFilePath)} File is Empty`)
+    // process.exit()
+  }
+}
+
+if (!existsSync(authDirectory)) {
+  console.log('Creating auth directory for the first time setup...');
+  mkdirSync(authDirectory, { recursive: 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)
+
+        await page.context().storageState({ path: authFile });
+      }
+
+    }
+
+  });
+
+
+})

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

@@ -0,0 +1,9 @@
+[
+    {
+        "useremail": "/ user name /",
+        "password": "/ password /",
+        "description": "/ description/",
+        "filename": "user.json",
+        "locator": "/ selector to identify page has been loaded completely /"
+    }
+]

package/build/setup-folder-structure/samples/env-config-sample.json

@@ -0,0 +1,21 @@
+{
+  "dev": {
+    "domain": "https://desk.localzoho.com/agent",
+    "orgName": "org-name",
+    "deptName": "dept-name",
+    "moduleName": "module-name",
+    "devURL": "Provide your devURL here"
+  },
+  "prod": {
+    "domain": "https://desk.localzoho.com/agent",
+    "orgName": "org-name",
+    "deptName": "dept-name",
+    "moduleName": "module-name"
+  },
+  "k8test": {
+    "domain": "https://desk.localzoho.com/agent",
+    "orgName": "org-name",
+    "deptName": "dept-name",
+    "moduleName": "module-name"
+  }
+}

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

@@ -0,0 +1,33 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import path from 'path';
+import { Logger } from '../utils/logger';
+import { generateConfigFromFile } from '../core/playwright/readConfigFile';
+
+
+const { reportPath = path.resolve(process.cwd(), 'uat', 'playwright-reports') } = generateConfigFromFile();
+const testResultsPath = path.resolve(process.cwd(), 'uat', 'test-results');
+
+const testResultsRelativepath = path.relative(path.resolve(process.cwd(), '../', '../'), testResultsPath)
+const reportRelativepath = path.relative(path.resolve(process.cwd(), '../', '../'), reportPath)
+
+const dirpathtoIgnore = `${testResultsRelativepath}\n${reportRelativepath}`
+
+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/uat-config-sample.js

@@ -0,0 +1,35 @@
+/**
+ * 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
+ * @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
+ */
+
+/**
+* @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,
+  featureFilesFolder: 'feature-files',
+  stepDefinitionsFolder: 'steps'
+}