@zohodesk/testinglibrary 0.0.4 → 0.0.5-exp.2

package/build/bdd-framework/cucumber/loadFeatures.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadFeatures = loadFeatures;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _loadSources = require("./loadSources");
+var _utils = require("../utils");
+var _loadFeatures;
+function loadFeatures(_x, _x2) {
+  return (_loadFeatures = _loadFeatures || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(runConfiguration, environment) {
+    var _yield$loadSources, filteredPickles, parseErrors;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return (0, _loadSources.loadSources)(runConfiguration.sources, environment);
+        case 2:
+          _yield$loadSources = _context.sent;
+          filteredPickles = _yield$loadSources.filteredPickles;
+          parseErrors = _yield$loadSources.parseErrors;
+          handleParseErrors(parseErrors);
+          return _context.abrupt("return", groupByDocument(filteredPickles));
+        case 7:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }))).apply(this, arguments);
+}
+function groupByDocument(filteredPickles) {
+  var features = new Map();
+  filteredPickles.forEach(function (_ref) {
+    var pickle = _ref.pickle,
+      gherkinDocument = _ref.gherkinDocument;
+    var pickles = features.get(gherkinDocument);
+    if (!pickles) {
+      pickles = [];
+      features.set(gherkinDocument, pickles);
+    }
+    pickles.push(pickle);
+  });
+  return features;
+}
+function handleParseErrors(parseErrors) {
+  if (parseErrors.length) {
+    var message = parseErrors.map(function (parseError) {
+      return "Parse error in \"".concat(parseError.source.uri, "\" ").concat(parseError.message);
+    }).join('\n');
+    (0, _utils.exitWithMessage)(message);
+  }
+}

package/build/bdd-framework/cucumber/loadSnippetBuilder.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadSnippetBuilder = loadSnippetBuilder;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _cucumber = require("@cucumber/cucumber");
+var _loadSnippetBuilder;
+/**
+ * Loads snippet builder
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/formatter/builder.ts
+ */
+function loadSnippetBuilder(_x, _x2, _x3) {
+  return (_loadSnippetBuilder = _loadSnippetBuilder || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(supportCodeLibrary, snippetInterface, snippetSyntax) {
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          return _context.abrupt("return", _cucumber.FormatterBuilder.getStepDefinitionSnippetBuilder({
+            cwd: process.cwd(),
+            snippetInterface: snippetInterface,
+            snippetSyntax: snippetSyntax,
+            supportCodeLibrary: supportCodeLibrary
+          }));
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }))).apply(this, arguments);
+}

package/build/bdd-framework/cucumber/loadSources.js

@@ -0,0 +1,89 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadSources = loadSources;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _paths = require("@cucumber/cucumber/lib/api/paths");
+var _messages = require("@cucumber/messages");
+var _environment = require("@cucumber/cucumber/lib/api/environment");
+var _gherkin = require("@cucumber/cucumber/lib/api/gherkin");
+var _console_logger = require("@cucumber/cucumber/lib/api/console_logger");
+var _loadSources;
+/**
+ * Copied from original load_sources, but returns full Pickles.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/api/load_sources.ts
+ */
+/// <reference path="./gherkin.d.ts" />
+/**
+ * Load and parse features, produce a filtered and ordered test plan and/or parse errors.
+ *
+ * @public
+ * @param coordinates - Coordinates required to find features
+ * @param environment - Project environment.
+ */
+function loadSources(_x) {
+  return (_loadSources = _loadSources || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(coordinates) {
+    var environment,
+      _mergeEnvironment,
+      cwd,
+      stderr,
+      debug,
+      logger,
+      newId,
+      _yield$resolvePaths,
+      unexpandedFeaturePaths,
+      featurePaths,
+      _yield$getFilteredPic,
+      filteredPickles,
+      parseErrors,
+      _args = arguments;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          environment = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+          _mergeEnvironment = (0, _environment.mergeEnvironment)(environment), cwd = _mergeEnvironment.cwd, stderr = _mergeEnvironment.stderr, debug = _mergeEnvironment.debug;
+          logger = new _console_logger.ConsoleLogger(stderr, debug);
+          newId = _messages.IdGenerator.uuid();
+          _context.next = 6;
+          return (0, _paths.resolvePaths)(logger, cwd, coordinates);
+        case 6:
+          _yield$resolvePaths = _context.sent;
+          unexpandedFeaturePaths = _yield$resolvePaths.unexpandedFeaturePaths;
+          featurePaths = _yield$resolvePaths.featurePaths;
+          if (!(featurePaths.length === 0)) {
+            _context.next = 11;
+            break;
+          }
+          return _context.abrupt("return", {
+            filteredPickles: [],
+            parseErrors: []
+          });
+        case 11:
+          _context.next = 13;
+          return (0, _gherkin.getFilteredPicklesAndErrors)({
+            newId: newId,
+            cwd: cwd,
+            logger: logger,
+            unexpandedFeaturePaths: unexpandedFeaturePaths,
+            featurePaths: featurePaths,
+            coordinates: coordinates
+          });
+        case 13:
+          _yield$getFilteredPic = _context.sent;
+          filteredPickles = _yield$getFilteredPic.filteredPickles;
+          parseErrors = _yield$getFilteredPic.parseErrors;
+          return _context.abrupt("return", {
+            filteredPickles: filteredPickles,
+            parseErrors: parseErrors
+          });
+        case 17:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }))).apply(this, arguments);
+}

package/build/bdd-framework/cucumber/loadSteps.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findStepDefinition = findStepDefinition;
+exports.hasTsNodeRegister = hasTsNodeRegister;
+exports.loadSteps = loadSteps;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _api = require("@cucumber/cucumber/api");
+var _utils = require("../utils");
+var _transform = require("../playwright/transform");
+var _loadSteps;
+var cache = new Map();
+function loadSteps(_x) {
+  return (_loadSteps = _loadSteps || (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(runConfiguration) {
+    var environment,
+      cacheKey,
+      lib,
+      uninstall,
+      _args = arguments;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          environment = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+          cacheKey = JSON.stringify(runConfiguration);
+          lib = cache.get(cacheKey);
+          if (!lib) {
+            // use Playwright's built-in hook to compile TypeScript steps
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            uninstall = !hasTsNodeRegister(runConfiguration) ? (0, _transform.installTransform)() : function () {};
+            lib = (0, _api.loadSupport)(runConfiguration, environment)["finally"](function () {
+              return uninstall();
+            });
+            cache.set(cacheKey, lib);
+          }
+          return _context.abrupt("return", lib);
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }))).apply(this, arguments);
+}
+function findStepDefinition(supportCodeLibrary, stepText, file) {
+  var matchedSteps = supportCodeLibrary.stepDefinitions.filter(function (step) {
+    return step.matchesStepName(stepText);
+  });
+  if (matchedSteps.length === 0) {
+    return;
+  }
+  ;
+  if (matchedSteps.length > 1) {
+    (0, _utils.exitWithMessage)(["Several step definitions found for text: ".concat(stepText, " (").concat(file, ")")].concat((0, _toConsumableArray2["default"])(matchedSteps.map(function (s) {
+      return "- ".concat(s.pattern);
+    }))).join('\n'));
+  }
+  // todo: check stepDefinition.keyword with PickleStepType
+  return matchedSteps[0];
+}
+function hasTsNodeRegister(runConfiguration) {
+  return runConfiguration.support.requireModules.includes('ts-node/register');
+}

package/build/bdd-framework/decorators.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Fixture", {
+  enumerable: true,
+  get: function get() {
+    return _createDecorators.Fixture;
+  }
+});
+exports.When = exports.Then = exports.Step = exports.Given = void 0;
+var _createDecorators = require("./stepDefinitions/createDecorators");
+var Given = (0, _createDecorators.createStepDecorator)('Given');
+exports.Given = Given;
+var When = (0, _createDecorators.createStepDecorator)('When');
+exports.When = When;
+var Then = (0, _createDecorators.createStepDecorator)('Then');
+exports.Then = Then;
+var Step = (0, _createDecorators.createStepDecorator)('Unknown');
+exports.Step = Step;

package/build/bdd-framework/gen/formatter.js

@@ -0,0 +1,124 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Formatter = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _jsStringWrap = require("../utils/jsStringWrap");
+/**
+ * Helper to format Playwright test file.
+ */
+
+var TAGS_FIXTURE_TEST_KEY_SEPARATOR = '|';
+var Formatter = /*#__PURE__*/function () {
+  function Formatter(config) {
+    (0, _classCallCheck2["default"])(this, Formatter);
+    this.config = config;
+  }
+  (0, _createClass2["default"])(Formatter, [{
+    key: "fileHeader",
+    value: function fileHeader(uri, importTestFrom) {
+      var file = (importTestFrom === null || importTestFrom === void 0 ? void 0 : importTestFrom.file) || '@zohodesk/testinglibrary';
+      var varName = (importTestFrom === null || importTestFrom === void 0 ? void 0 : importTestFrom.varName) || 'test';
+      if (varName !== 'test') varName = "".concat(varName, " as test");
+      return ["/** Generated from: ".concat(uri, " */"), // prettier-ignore
+      // this.quoted() is not possible for 'import from' as backticks not parsed
+      "import { ".concat(varName, " } from ").concat(JSON.stringify(file), ";"), ''];
+    }
+  }, {
+    key: "suite",
+    value: function suite(node, children) {
+      // prettier-ignore
+      return ["test.describe".concat(this.getSubFn(node), "(").concat(this.quoted(node.title), ", () => {"), ''].concat((0, _toConsumableArray2["default"])(children.map(indent)), ["});", '']);
+    }
+  }, {
+    key: "beforeEach",
+    value: function beforeEach(fixtures, children) {
+      var fixturesStr = (0, _toConsumableArray2["default"])(fixtures).join(', ');
+      // prettier-ignore
+      return ["test.beforeEach(async ({ ".concat(fixturesStr, " }) => {")].concat((0, _toConsumableArray2["default"])(children.map(indent)), ["});", '']);
+    }
+  }, {
+    key: "test",
+    value: function test(node, fixtures, children) {
+      var fixturesStr = (0, _toConsumableArray2["default"])(fixtures).join(', ');
+      // prettier-ignore
+      return ["test".concat(this.getSubFn(node), "(").concat(this.quoted(node.title), ", async ({ ").concat(fixturesStr, " }) => {")].concat((0, _toConsumableArray2["default"])(children.map(indent)), ["});", '']);
+    }
+
+    // eslint-disable-next-line max-params
+  }, {
+    key: "step",
+    value: function step(keyword, text, argument) {
+      var fixtureNames = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+      var fixtures = fixtureNames.length ? "{ ".concat(fixtureNames.join(', '), " }") : '';
+      var argumentArg = argument ? JSON.stringify(argument) : fixtures ? 'null' : '';
+      var textArg = this.quoted(text);
+      var args = [textArg, argumentArg, fixtures].filter(function (arg) {
+        return arg !== '';
+      }).join(', ');
+      return "await ".concat(keyword, "(").concat(args, ");");
+    }
+  }, {
+    key: "missingStep",
+    value: function missingStep(keyword, text) {
+      return "// missing step: ".concat(keyword, "(").concat(this.quoted(text), ");");
+    }
+  }, {
+    key: "useFixtures",
+    value: function useFixtures(fixtures) {
+      return fixtures.length > 0 ? ['// == technical section ==',
+      // prettier-ignore
+      '', 'test.use({'].concat((0, _toConsumableArray2["default"])(fixtures.map(indent)), ['});']) : [];
+    }
+  }, {
+    key: "testFixture",
+    value: function testFixture() {
+      return ['$test: ({}, use) => use(test),'];
+    }
+  }, {
+    key: "tagsFixture",
+    value: function tagsFixture(testNodes) {
+      var lines = testNodes.filter(function (node) {
+        return node.tags.length;
+      }).map(function (node) {
+        // remove first parent as it is the same for all tests: root suite
+        var key = node.titlePath.slice(1).join(TAGS_FIXTURE_TEST_KEY_SEPARATOR);
+        return "".concat(JSON.stringify(key), ": ").concat(JSON.stringify(node.tags), ",");
+      });
+      return lines.length > 0 ? ['$tags: ({}, use, testInfo) => use({'].concat((0, _toConsumableArray2["default"])(lines.map(indent)), [// .slice(2) -> b/c we remove filename and root suite title
+      "}[testInfo.titlePath.slice(2).join(".concat(JSON.stringify(TAGS_FIXTURE_TEST_KEY_SEPARATOR), ")] || []),")]) : [];
+    }
+  }, {
+    key: "getSubFn",
+    value: function getSubFn(node) {
+      if (node.flags.only) return '.only';
+      if (node.flags.skip) return '.skip';
+      if (node.flags.fixme) return '.fixme';
+      return '';
+    }
+
+    /**
+     * Apply this function only to string literals (mostly titles here).
+     * Objects and arrays are handled with JSON.strinigfy,
+     * b/c object keys can't be in backtiks.
+     * See: https://stackoverflow.com/questions/33194138/template-string-as-object-property-name
+     */
+  }, {
+    key: "quoted",
+    value: function quoted(str) {
+      return (0, _jsStringWrap.jsStringWrap)(str, {
+        quotes: this.config.quotes
+      });
+    }
+  }]);
+  return Formatter;
+}();
+exports.Formatter = Formatter;
+function indent(value) {
+  return value ? '  '.concat(value) : value;
+}

package/build/bdd-framework/gen/i18n.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getKeywordsMap = getKeywordsMap;
+var _gherkin = require("@cucumber/gherkin");
+/**
+ * Get i18n keywords.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/cli/i18n.ts
+ */
+
+// todo: cache targetMap
+
+function getKeywordsMap(language) {
+  var origMap = _gherkin.dialects[language];
+  if (!origMap) {
+    throw new Error("Language not found: ".concat(language));
+  }
+  ;
+  var targetMap = new Map();
+  var enKeywords = Object.keys(origMap);
+  enKeywords.forEach(function (enKeyword) {
+    return handleKeyword(enKeyword, origMap, targetMap);
+  });
+  return targetMap;
+}
+function handleKeyword(enKeyword, origMap, targetMap) {
+  var nativeKeywords = origMap[enKeyword];
+  // Array.isArray converts to any[]
+  if (typeof nativeKeywords === 'string') {
+    return;
+  }
+  ;
+  nativeKeywords.forEach(function (nativeKeyword) {
+    nativeKeyword = nativeKeyword.trim();
+    if (!nativeKeyword || nativeKeyword === '*') {
+      return;
+    }
+    ;
+    targetMap.set(nativeKeyword, capitalizeFirstLetter(enKeyword));
+  });
+}
+function capitalizeFirstLetter(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}