@zohodesk/testinglibrary 0.0.4 → 0.0.5-exp.2

package/build/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createBdd", {
+  enumerable: true,
+  get: function get() {
+    return _index.createBdd;
+  }
+});
+Object.defineProperty(exports, "expect", {
+  enumerable: true,
+  get: function get() {
+    return _index.expect;
+  }
+});
+Object.defineProperty(exports, "fireEvent", {
+  enumerable: true,
+  get: function get() {
+    return _react.fireEvent;
+  }
+});
+Object.defineProperty(exports, "render", {
+  enumerable: true,
+  get: function get() {
+    return _react.render;
+  }
+});
+Object.defineProperty(exports, "test", {
+  enumerable: true,
+  get: function get() {
+    return _index.test;
+  }
+});
+var _index = require("./core/playwright/index");
+var _react = require("@testing-library/react");

package/build/lib/cli.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+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"));
+var _process$argv = (0, _slicedToArray2["default"])(process.argv, 3),
+  option = _process$argv[2];
+var args = process.argv.slice(3);
+var 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;
+    }
+  default:
+    {
+      console.log('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"));
+var playwrightPath = _path["default"].resolve('node_modules', '.bin', (0, _getFilePath["default"])('playwright'));
+var command = playwrightPath;
+var args = ['install'];
+_logger.Logger.log(_logger.Logger.INFO_TYPE, 'Downloading browsers for running tests');
+var childProcess = (0, _child_process.spawn)(command, args, {
+  stdio: 'inherit'
+});
+childProcess.on('error', function (error) {
+  _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error);
+});

package/build/lint/index.js

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

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

@@ -0,0 +1,17 @@
+{
+  "dev": {
+    "domain": "https://desk.localzoho.com/agent",
+    "username": "your-username",
+    "password": "your-password"
+  },
+  "prod": {
+    "domain": "https://desk.localzoho.com/agent",
+    "username": "your-username",
+    "password": "your-password"
+  },
+  "k8test": {
+    "domain": "https://desk.localzoho.com/agent",
+    "username": "your-username",
+    "password": "your-password"
+  }
+}

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

@@ -0,0 +1,102 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = setupProject;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../utils/logger");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function getScriptsToBeAdded() {
+  return {
+    "ua-test": "ZDTestingFramework test --mode=prod --headed",
+    "ua-test-debug": "ZDTestingFramework test --mode=prod --debug",
+    "ua-report": "ZDTestingFramework report --port=9009",
+    "codegen": "ZDTestingFramework codegen deskclientapp.localzoho.com/agent"
+  };
+}
+function updatePackageJSONScripts() {
+  var packageJsonPath = _path["default"].resolve(process.cwd(), './package.json');
+  if ((0, _fs.existsSync)(packageJsonPath)) {
+    var packageContents = (0, _fs.readFileSync)(packageJsonPath);
+    var configJSON = JSON.parse(packageContents);
+    var _configJSON$scripts = configJSON.scripts,
+      scripts = _configJSON$scripts === void 0 ? {} : _configJSON$scripts;
+    var modifiedScripts = _objectSpread(_objectSpread({}, scripts), getScriptsToBeAdded());
+    var modifiedConfigJSON = _objectSpread(_objectSpread({}, configJSON), {}, {
+      scripts: modifiedScripts
+    });
+    (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() {
+  var 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();
+}
+function createUatConfig() {
+  var 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);
+  }
+}
+function createAuthenticationFile() {
+  var 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
+      });
+      var authFilePath = _path["default"].resolve(process.cwd(), 'playwright', '.auth', 'user.json');
+      (0, _fs.writeFileSync)(authFilePath, getSetupFileAsString('user-example.json'), null, 2);
+    } catch (err) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Something went wrong ! Folder not Created. Please re-initialize npm init-uat');
+    }
+  } else {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Something went wrong. Please re-initialize the @zohodesk/testinglibrary');
+  }
+}
+function createConfigJson() {
+  var 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);
+  } else {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Something went wrong. Please re-initialize the @zohodesk/testinglibrary');
+  }
+}
+function setupProject() {
+  updatePackageJSONScripts();
+  createUatConfig();
+  createFolderForUAT();
+  createConfigJson();
+  createAuthenticationFile();
+  // Create folder for playwright . Inside .auth folder needs to be created. user.json
+  // Add playwright and test-results to .gitignore
+  setTimeout(function () {
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Setup Project is Ready ..');
+  }, 2000);
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+
+/**
+* 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 {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} isCucumberPreprocessingRequired: Feature files needs to be processed
+*/
+/**
+* @type {UserConfig}
+*/
+module.exports = {
+  headed: true,
+  browsers: ['Chrome', 'Firefox'],
+  mode: 'dev',
+  isAuthMode: true,
+  trace: true,
+  video: true
+};

package/build/setup-folder-structure/user-example.json

@@ -0,0 +1,3 @@
+{
+    "cookies": []
+}

package/build/utils/cliArgsToObject.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cliArgsToObject = cliArgsToObject;
+exports.objectToCliArgs = objectToCliArgs;
+/**
+ * Converts an array of command-line arguments into an object.
+ *
+ * @param {string[]} cliArgs - An array of command-line arguments.
+ * @param {boolean} [isKeyNeedToBeAdded=true] - Indicates whether the keys should be added to the resulting object.
+ * @returns {Object} An object representing the command-line arguments, where keys are argument names (without '--') and values are argument values.
+ * If `isKeyNeedToBeAdded` is set to `false`, only values are included in the object with numeric indexes as keys.
+ *
+ * @example
+ * // Example usage:
+ * const args = ['--port=8080', '--verbose', 'input.txt'];
+ * const result = cliArgsToObject(args);
+ * // result will be: { port: '8080', verbose: true }
+ */
+function cliArgsToObject(cliArgs, isKeyNeedToBeAdded) {
+  var processEnv = {};
+  cliArgs.forEach(function (option) {
+    if (/^--./.test(option)) {
+      var equIndex = option.indexOf('=');
+      var key = option.slice(2, equIndex);
+      var value = option.slice(equIndex + 1);
+      if (equIndex === -1) {
+        key = option.slice(2);
+        value = true;
+      }
+      processEnv[key] = value;
+    }
+  });
+  return processEnv;
+}
+
+/**
+ * Converts an object to an array of command-line arguments.
+ *
+ * @param {Object} objectToBeConverted - The object to be converted to command-line arguments.
+ * @param {(string|function(string): boolean)} [isKeyNeedToBeAdded=true] - A string representing a key, or a function that determines whether a key should be added to the resulting array.
+ * @returns {string[]} An array of command-line arguments generated from the object's key-value pairs. Keys are transformed into argument names (with '--') and values are added as argument values.
+ *
+ * @example
+ * // Example usage:
+ * const options = { port: 8080, verbose: true, input: 'input.txt' };
+ * const args = objectToCliArgs(options);
+ * // args will be: ['--port=8080', '--verbose', '--input=input.txt']
+ */
+function objectToCliArgs(objectToBeConverted, isKeyNeedToBeAdded) {
+  var argsArray = [];
+  Object.keys(objectToBeConverted).forEach(function (key) {
+    if (isKeyNeedToBeAdded(key)) {
+      if (typeof objectToBeConverted[key] === 'boolean' && objectToBeConverted[key]) {
+        argsArray.push("--".concat(key));
+      } else {
+        argsArray.push("--".concat(key, "=").concat(objectToBeConverted[key]));
+      }
+    }
+  });
+  return argsArray;
+}

package/build/utils/getFilePath.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getFilePathWithExtension;
+var _os = require("os");
+var isWindows = (0, _os.platform)().toLowerCase() === 'win32';
+function getFilePathWithExtension(binName) {
+  return isWindows ? "".concat(binName, ".cmd") : binName;
+}

package/build/utils/logger.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Logger = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+// const SUCCESS_TYPE = 'success';
+// const FAILURE_TYPE = 'failure';
+// const INFO_TYPE = 'info';
+// function logger() {
+//   this.colors = {
+//     'success': ['\x1b[36m', '\x1b[0m'],
+//     'failure': ['\x1b[31m', '\x1b[0m'],
+//     'info': ['\x1b[33m', '\x1b[0m']
+//   }
+//   this.consoleLogger = console;
+//   return {
+//     SUCCESS_TYPE,
+//     FAILURE_TYPE,
+//     INFO_TYPE,
+//     error: () => { },
+//     info: () => { },
+//     log: (type, message) => {
+//       const color = this.colors[type];
+//       console.log(type, color)
+//       this.consoleLogger.log(`${color[0]}${message}${color[1]}`)
+//     }
+//   }
+// }
+// module.exports = {
+//   Logger: logger()
+// }
+var LoggerImpl = /*#__PURE__*/function () {
+  function LoggerImpl() {
+    (0, _classCallCheck2["default"])(this, LoggerImpl);
+    (0, _defineProperty2["default"])(this, "SUCCESS_TYPE", 'success');
+    (0, _defineProperty2["default"])(this, "FAILURE_TYPE", 'failure');
+    (0, _defineProperty2["default"])(this, "INFO_TYPE", 'info');
+    this.colors = {
+      'success': ['\x1b[36m', '\x1b[0m'],
+      'failure': ['\x1b[31m', '\x1b[0m'],
+      'info': ['\x1b[33m', '\x1b[0m']
+    };
+    this.consoleLogger = console;
+  }
+  (0, _createClass2["default"])(LoggerImpl, [{
+    key: "error",
+    value: function error() {}
+  }, {
+    key: "info",
+    value: function info() {}
+  }, {
+    key: "log",
+    value: function log(type, message) {
+      var color = this.colors[type];
+      this.consoleLogger.log("".concat(color[0]).concat(message).concat(color[1]));
+    }
+  }]);
+  return LoggerImpl;
+}();
+var Logger = new LoggerImpl();
+exports.Logger = Logger;

package/build/utils/rootPath.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBinPath = getBinPath;
+exports.getExecutableBinaryPath = getExecutableBinaryPath;
+exports.getRootNodeModulesPath = getRootNodeModulesPath;
+exports.getRootPath = getRootPath;
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _logger = require("./logger");
+var _getFilePath = _interopRequireDefault(require("./getFilePath"));
+function findBinaryPath(directory, command) {
+  var binaryPath = _path["default"].join(directory, '.bin', (0, _getFilePath["default"])(command));
+  if (_fs["default"].existsSync(binaryPath)) {
+    return binaryPath;
+  }
+
+  // Recursively search parent directories. Might be time-consuming ?? Can we look for npm module like which?
+  var parentDir = _path["default"].dirname(directory);
+  if (parentDir === directory) {
+    return null;
+  }
+  return findBinaryPath(parentDir, command);
+}
+function getRootPath() {
+  return _path["default"].resolve(__dirname, '../', '../');
+}
+function getRootNodeModulesPath() {
+  return _path["default"].resolve(getRootPath(), 'node_modules');
+}
+function getBinPath(command) {
+  var packageNodeModulesPath = getRootNodeModulesPath();
+  return findBinaryPath(packageNodeModulesPath, command);
+}
+function getExecutableBinaryPath(command) {
+  var binPath = getBinPath(command);
+  if (binPath !== null) {
+    return binPath;
+  } else {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, "Error: Could not find executable bin ".concat(command, " file. Make sure to npm install before proceeding"));
+    process.exit();
+  }
+}

package/changelog.md

@@ -2,6 +2,20 @@
 
 ## Framework that abstracts the configuration for playwright and Jest
 
+# 0.0.5-exp.2
+
+- Provided Initial Support for cucumber feature files
+  - Playwright-bdd and cucumber
+- Added config isCucumberPreprocessingRequired which toggles the feature files processing
+- Internal Library change
+  - Provided support for import/export statements
+
+# 0.0.5
+
+- Added Init command to initialize the folder structure and configuration for testing
+- Renamed config.json to env-config.json
+- Configured report file path directory and Handled Edge case in Cookies Handling
+
 # 0.0.4
 
 - Issue Fixes while loading the storage state