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

package/build/index.d.ts

@@ -0,0 +1,78 @@
+import {
+  expect,
+  test,
+  createBdd
+} from './core/playwright/index';
+import { fireEvent, render } from '@testing-library/react';
+import {
+  PlaywrightTestArgs,
+  PlaywrightTestOptions,
+  PlaywrightWorkerArgs,
+  PlaywrightWorkerOptions,
+  TestType,
+  Page
+} from '@playwright/test';
+import { DefineStepPattern } from '@cucumber/cucumber/lib/support_code_library_builder/types';
+
+export type KeyValue = { [key: string]: any };
+
+export type BuiltInFixturesWorker = PlaywrightWorkerArgs &
+  PlaywrightWorkerOptions;
+export type BuiltInFixtures = PlaywrightTestArgs &
+  PlaywrightTestOptions &
+  BuiltInFixturesWorker;
+
+export type FixturesArg<T extends KeyValue = {}, W extends KeyValue = {}> = T &
+  W &
+  BuiltInFixtures;
+
+export declare let hasCustomTest: boolean;
+
+export declare function createBdd<
+  T extends KeyValue = BuiltInFixtures,
+  W extends KeyValue = BuiltInFixturesWorker,
+  World
+>(
+  customTest?: TestType<T, W> | null,
+  _CustomWorld?: new (...args: any[]) => World
+): {
+  Given: (pattern: DefineStepPattern, fn: StepFunction<T, W>) => void;
+  When: (pattern: DefineStepPattern, fn: StepFunction<T, W>) => void;
+  Then: (pattern: DefineStepPattern, fn: StepFunction<T, W>) => void;
+  And: (pattern: DefineStepPattern, fn: StepFunction<T, W>) => void;
+  But: (pattern: DefineStepPattern, fn: StepFunction<T, W>) => void;
+  Step: (pattern: DefineStepPattern, fn: StepFunction<T, W>) => void;
+  Before: any;
+  After: any;
+  BeforeAll: any;
+  AfterAll: any;
+};
+
+type StepFunctionFixturesArg<
+  T extends KeyValue,
+  W extends KeyValue
+> = FixturesArg<T, W>;
+type StepFunction<T extends KeyValue, W extends KeyValue> = (
+  fixtures: StepFunctionFixturesArg<T, W>,
+  ...args: any[]
+) => unknown;
+
+const { Given, Then, When, Step, And, But } = createBdd();
+
+type UserConfig = import('./core/playwright/readConfigFile').UserConfig;
+
+export {
+  UserConfig,
+  Given,
+  Then,
+  When,
+  Step,
+  And,
+  But,
+  expect,
+  test,
+  createBdd,
+  Page
+};
+
+export * from '@playwright/test/types/test';

package/build/index.js

@@ -3,6 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.When = exports.Then = exports.Step = exports.Given = exports.But = exports.And = void 0;
+Object.defineProperty(exports, "accountLogin", {
+  enumerable: true,
+  get: function () {
+    return _index.accountLogin;
+  }
+});
 Object.defineProperty(exports, "createBdd", {
   enumerable: true,
   get: function () {
@@ -15,16 +22,58 @@ Object.defineProperty(exports, "expect", {
     return _index.expect;
   }
 });
-Object.defineProperty(exports, "fireEvent", {
+Object.defineProperty(exports, "getDefaultActor", {
+  enumerable: true,
+  get: function () {
+    return _index.getDefaultActor;
+  }
+});
+Object.defineProperty(exports, "getListOfActors", {
   enumerable: true,
   get: function () {
-    return _react.fireEvent;
+    return _index.getListOfActors;
   }
 });
-Object.defineProperty(exports, "render", {
+Object.defineProperty(exports, "getRunMode", {
   enumerable: true,
   get: function () {
-    return _react.render;
+    return _index.getRunMode;
+  }
+});
+Object.defineProperty(exports, "getUserForSelectedEditionAndProfile", {
+  enumerable: true,
+  get: function () {
+    return _index.getUserForSelectedEditionAndProfile;
+  }
+});
+Object.defineProperty(exports, "isCI", {
+  enumerable: true,
+  get: function () {
+    return _index.isCI;
+  }
+});
+Object.defineProperty(exports, "isDevelopmentSetup", {
+  enumerable: true,
+  get: function () {
+    return _index.isDevelopmentSetup;
+  }
+});
+Object.defineProperty(exports, "loadCookiesIfPresent", {
+  enumerable: true,
+  get: function () {
+    return _index.loadCookiesIfPresent;
+  }
+});
+Object.defineProperty(exports, "performLoginSteps", {
+  enumerable: true,
+  get: function () {
+    return _index.performLoginSteps;
+  }
+});
+Object.defineProperty(exports, "setup", {
+  enumerable: true,
+  get: function () {
+    return _index.setup;
   }
 });
 Object.defineProperty(exports, "test", {
@@ -33,5 +82,24 @@ Object.defineProperty(exports, "test", {
     return _index.test;
   }
 });
+Object.defineProperty(exports, "verifyIfCookieFileExists", {
+  enumerable: true,
+  get: function () {
+    return _index.verifyIfCookieFileExists;
+  }
+});
 var _index = require("./core/playwright/index");
-var _react = require("@testing-library/react");
+// import { fireEvent, render } from '@testing-library/react';
+
+const {
+  Given,
+  Then,
+  When,
+  Step
+} = (0, _index.createBdd)();
+exports.Step = Step;
+exports.When = When;
+exports.Then = Then;
+exports.Given = Given;
+const And = exports.And = Then;
+const But = exports.But = Then;

package/build/lib/cli.js

@@ -2,14 +2,18 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _testRunner = _interopRequireDefault(require("../core/playwright/test-runner"));
-var _jestRunner = _interopRequireDefault(require("../core/jest/runner/jest-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"));
-const [,, option] = process.argv;
-const args = process.argv.slice(3);
-const appPath = process.cwd();
+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;
 switch (option) {
   case 'test':
     {
@@ -18,6 +22,22 @@ switch (option) {
       //createJestRunner();
       break;
     }
+  case 'validate':
+    {
+      (0, _validateFeature.default)();
+      break;
+    }
+  case 're-run-failed':
+    {
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Running Failed Tests..');
+      let {
+        filePath
+      } = (0, _parseUserArgs.default)();
+      process.env.isRerunFailedCases = true;
+      process.env.filePath = filePath;
+      (0, _testRunner.default)();
+      break;
+    }
   case 'report':
     {
       // console.log('\x1b[36mGenerating Reports...\x1b[0m');
@@ -37,9 +57,22 @@ switch (option) {
       (0, _setupProject.default)();
       break;
     }
+  case 'generateSpecFile':
+    {
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Generating Spec file...');
+      (0, _parser.generateSpecCodeForFeatureFile)(otherOptions);
+      break;
+    }
+  case 'clearCaches':
+    {
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Clearing caches...');
+      (0, _clearCaches.default)();
+      break;
+    }
+  case 'help':
   default:
     {
-      console.log('Supported Commands test and report');
+      (0, _helper.default)();
       break;
     }
 }

package/build/lib/post-install.js

@@ -4,14 +4,22 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 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);
-});
+var _rootPath = require("../utils/rootPath");
+// We are skipping the download of browsers when NODE_ENV is set to production or flag SKIP_BROWSER_DOWNLOAD is set to true
+
+let isSkipDownloadingBrowsers = Boolean(process.env.SKIP_BROWSER_DOWNLOAD);
+let isProductionMode = process.env.NODE_ENV === 'production';
+if (isSkipDownloadingBrowsers || isProductionMode) {
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Skipping browsers download in production mode');
+} else {
+  const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('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

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

package/build/parser/parser.js

@@ -0,0 +1,205 @@
+"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
+  });
+});