@zohodesk/testinglibrary 0.1.8-stb-bdd-v26 → 0.1.9-exp-actors

package/build/bdd-framework/playwright/testTypeImpl.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isTestContainsSubtest = isTestContainsSubtest;
+exports.runStepWithCustomLocation = runStepWithCustomLocation;
+var _test = require("@playwright/test");
+var _utils = require("../utils");
+/**
+ * Helpers to deal with Playwright test internal stuff.
+ * See: https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/testType.ts
+ */
+
+const testTypeSymbol = (0, _utils.getSymbolByName)(_test.test, 'testType');
+/**
+ * Returns test fixtures using Symbol.
+ */
+function getTestFixtures(test) {
+  return getTestImpl(test).fixtures;
+}
+function getTestImpl(test) {
+  return test[testTypeSymbol];
+}
+/**
+ * Run step with location pointing to Given, When, Then call.
+ */
+// eslint-disable-next-line max-params
+async function runStepWithCustomLocation(test, stepText, location, body) {
+  const testInfo = test.info();
+  // See: https://github.com/microsoft/playwright/blob/main/packages/playwright/src/common/testType.ts#L221
+  // @ts-expect-error _runAsStep is hidden from public
+  return testInfo._runAsStep({
+    category: 'test.step',
+    title: stepText,
+    location
+  }, async () => {
+    return await body();
+  });
+}
+/**
+ * Returns true if test contains all fixtures of subtest.
+ * - test was extended from subtest
+ * - test is a result of mergeTests(subtest, ...)
+ */
+function isTestContainsSubtest(test, subtest) {
+  if (test === subtest) {
+    return true;
+  }
+  const testFixtures = new Set(getTestFixtures(test).map(f => locationToString(f.location)));
+  return getTestFixtures(subtest).every(f => {
+    return testFixtures.has(locationToString(f.location));
+  });
+}
+function locationToString({
+  file,
+  line,
+  column
+}) {
+  return `${file}:${line}:${column}`;
+}

package/build/bdd-framework/playwright/transform.js

@@ -0,0 +1,88 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.installTransform = installTransform;
+exports.requireTransform = requireTransform;
+var _module = _interopRequireDefault(require("module"));
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("./utils");
+/* eslint-disable max-params */
+/**
+ * Installs require hook to transform ts.
+ * Extracted from playwright.
+ * See: https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/transform/transform.ts
+ */
+function installTransform() {
+  const {
+    pirates
+  } = (0, _utils.requirePlaywrightModule)('lib/utilsBundle.js');
+  const {
+    resolveHook,
+    shouldTransform,
+    transformHook
+  } = requireTransform();
+  let reverted = false;
+  const originalResolveFilename = _module.default._resolveFilename;
+  function resolveFilename(specifier, parent, ...rest) {
+    if (!reverted && parent) {
+      const resolved = resolveHook(parent.filename, specifier);
+      if (resolved !== undefined) {
+        specifier = resolved;
+      }
+    }
+    return originalResolveFilename.call(this, specifier, parent, ...rest);
+  }
+  _module.default._resolveFilename = resolveFilename;
+  const revertPirates = pirates.addHook((code, filename) => {
+    if (!shouldTransform(filename)) {
+      return code;
+    }
+    // Since PW 1.42 transformHook returns { code, serializedCache } instead of code string
+    // See: https://github.com/microsoft/playwright/commit/f605a5009b3c75746120a6ec6d940f62624af5ec#diff-0f8a2f313f1572108f59a6e84663858ebb4fc455163410526b56878794001103
+    // See: https://github.com/vitalets/playwright-bdd/issues/96
+    const res = transformHook(code, filename);
+    return typeof res === 'string' ? res : res.code;
+  }, {
+    exts: ['.ts', '.tsx', '.js', '.jsx', '.mjs']
+  });
+  return () => {
+    reverted = true;
+    _module.default._resolveFilename = originalResolveFilename;
+    revertPirates();
+  };
+}
+function requireTransform() {
+  const transformPathSince1_35 = (0, _utils.getPlaywrightModulePath)('lib/transform/transform.js');
+  if (_fs.default.existsSync(transformPathSince1_35)) {
+    const {
+      resolveHook,
+      shouldTransform,
+      transformHook,
+      requireOrImport
+    } = (0, _utils.requirePlaywrightModule)(transformPathSince1_35);
+    return {
+      resolveHook,
+      shouldTransform,
+      transformHook,
+      requireOrImport
+    };
+  } else {
+    const {
+      resolveHook,
+      transformHook,
+      requireOrImport
+    } = (0, _utils.requirePlaywrightModule)('lib/common/transform.js');
+    // see: https://github.com/microsoft/playwright/blob/b4ffb848de1b00e9a0abad6dacdccce60cce9bed/packages/playwright-test/src/reporters/base.ts#L524
+    const shouldTransform = file => !file.includes(`${_path.default.sep}node_modules${_path.default.sep}`);
+    return {
+      resolveHook,
+      shouldTransform,
+      transformHook,
+      requireOrImport
+    };
+  }
+}

package/build/bdd-framework/playwright/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/build/bdd-framework/playwright/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPlaywrightModulePath = getPlaywrightModulePath;
+exports.requirePlaywrightModule = requirePlaywrightModule;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("../utils");
+// cache playwright root
+let playwrightRoot = '';
+/**
+ * Requires Playwright's internal module that is not exported via package.exports.
+ */
+function requirePlaywrightModule(modulePath) {
+  const absPath = _path.default.isAbsolute(modulePath) ? modulePath : getPlaywrightModulePath(modulePath);
+  return require(absPath);
+}
+function getPlaywrightModulePath(relativePath) {
+  return _path.default.join(getPlaywrightRoot(), relativePath);
+}
+function getPlaywrightRoot() {
+  if (!playwrightRoot) {
+    // Since 1.38 all modules moved from @playwright/test to playwright.
+    // Here we check existance of 'lib' dir instead of checking version.
+    // See: https://github.com/microsoft/playwright/pull/26946
+    const playwrightTestRoot = (0, _utils.resolvePackageRoot)('@playwright/test');
+    const libDir = _path.default.join(playwrightTestRoot, 'lib');
+    playwrightRoot = _fs.default.existsSync(libDir) ? playwrightTestRoot : (0, _utils.resolvePackageRoot)('playwright');
+  }
+  return playwrightRoot;
+}

package/build/bdd-framework/reporter/cucumber/base.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _stream = require("stream");
+/**
+ * Base reporter for Cucumber reporters.
+ * Reference: https://github.com/cucumber/cucumber-js/blob/main/src/formatter/index.ts
+ */
+
+// Import pipeline from the 'stream' module
+
+class BaseReporter {
+  internalOptions;
+  outputStream = process.stdout;
+  constructor(internalOptions) {
+    this.internalOptions = internalOptions;
+  }
+  get eventBroadcaster() {
+    return this.internalOptions.eventBroadcaster;
+  }
+  get eventDataCollector() {
+    return this.internalOptions.eventDataCollector;
+  }
+  printsToStdio() {
+    return isStdout(this.outputStream);
+  }
+  async init() {}
+  async finished() {
+    if (!isStdout(this.outputStream)) {
+      this.outputStream.end();
+      await new Promise((resolve, reject) => {
+        this.outputStream.on('finish', resolve);
+        this.outputStream.on('error', reject);
+      });
+    }
+  }
+  setOutputStream(outputFile) {
+    if (!outputFile) {
+      return;
+    }
+    const absolutePath = _path.default.resolve(this.internalOptions.cwd, outputFile);
+    _fs.default.mkdirSync(_path.default.dirname(absolutePath), {
+      recursive: true
+    });
+    this.outputStream = _fs.default.createWriteStream(absolutePath);
+  }
+}
+exports.default = BaseReporter;
+function isStdout(stream) {
+  return stream === process.stdout;
+}

package/build/bdd-framework/reporter/cucumber/custom.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _base = _interopRequireDefault(require("./base"));
+var _loadUtils = require("../../playwright/loadUtils");
+var _getColorFns = _interopRequireDefault(require("../../cucumber/formatter/getColorFns"));
+/**
+ * Custom Cucumber reporter.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/docs/custom_formatters.md
+ */
+
+class CustomReporter extends _base.default {
+  reporterPathOrModule;
+  userOptions;
+  formatter;
+  constructor(internalOptions, reporterPathOrModule, userOptions = {}) {
+    super(internalOptions);
+    this.reporterPathOrModule = reporterPathOrModule;
+    this.userOptions = userOptions;
+    this.setOutputStream(this.userOptions.outputFile);
+  }
+  printsToStdio() {
+    // currently always return true, b/c loading of custom reporter is async,
+    // but printsToStdio() is called synchronously at the beginning.
+    return true;
+  }
+  async init() {
+    const formatterOptions = this.buildFormatterOptions();
+    const FormatterConstructor = await this.loadFormatterFromFile();
+    this.formatter = new FormatterConstructor(formatterOptions);
+  }
+  async finished() {
+    var _this$formatter;
+    await ((_this$formatter = this.formatter) === null || _this$formatter === void 0 ? void 0 : _this$formatter.finished());
+    await super.finished();
+  }
+  async loadFormatterFromFile() {
+    // see: https://github.com/microsoft/playwright/blob/main/packages/playwright/src/common/config.ts#L225
+    const reporterPath = require.resolve(this.reporterPathOrModule, {
+      paths: [this.internalOptions.cwd]
+    });
+    return (0, _loadUtils.requireOrImportDefaultFunction)(reporterPath, true);
+  }
+  buildFormatterOptions() {
+    const colorFns = (0, _getColorFns.default)(this.outputStream, process.env, this.userOptions.colorsEnabled);
+    return {
+      cwd: this.internalOptions.cwd,
+      eventBroadcaster: this.eventBroadcaster,
+      eventDataCollector: this.eventDataCollector,
+      parsedArgvOptions: this.userOptions,
+      colorFns,
+      stream: this.outputStream,
+      log: this.outputStream.write.bind(this.outputStream),
+      cleanup: async () => {},
+      snippetBuilder: null,
+      supportCodeLibrary: {
+        World: {}
+      }
+    };
+  }
+}
+// const fakeSuportCodeLibrary = {
+//   parameterTypeRegistry: ParameterTypeRegistry;
+// stepDefinitions: StepDefinition[];
+// // eslint-disable-next-line @typescript-eslint/no-explicit-any
+// World: any;
+// originalCoordinates: ISupportCodeCoordinates;
+// }
+exports.default = CustomReporter;

package/build/bdd-framework/reporter/cucumber/helper.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cucumberReporter = cucumberReporter;
+function cucumberReporter(type, userOptions) {
+  return ['../../../bdd-framework/reporter/cucumber/index.js', {
+    $type: type,
+    ...(userOptions || {})
+  }];
+}

package/build/bdd-framework/reporter/cucumber/html.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _htmlFormatter = _interopRequireDefault(require("@cucumber/html-formatter"));
+var _utils = require("../../utils");
+var _path = _interopRequireDefault(require("path"));
+var _base = _interopRequireDefault(require("./base"));
+class HtmlReporter extends _base.default {
+  userOptions;
+  htmlStream;
+  constructor(internalOptions, userOptions = {}) {
+    super(internalOptions);
+    this.userOptions = userOptions;
+    this.setOutputStream(this.userOptions.outputFile);
+    const packageRoot = (0, _utils.resolvePackageRoot)('@cucumber/html-formatter');
+    this.htmlStream = new _htmlFormatter.default(_path.default.join(packageRoot, 'dist/main.css'), _path.default.join(packageRoot, 'dist/main.js'));
+    this.eventBroadcaster.on('envelope', envelope => {
+      this.htmlStream.write(envelope);
+    });
+    this.htmlStream.pipe(this.outputStream);
+  }
+  async finished() {
+    this.htmlStream.end();
+    await new Promise((resolve, reject) => {
+      this.htmlStream.on('finish', resolve);
+      this.htmlStream.on('error', reject);
+    });
+    await super.finished();
+  }
+}
+exports.default = HtmlReporter;

package/build/bdd-framework/reporter/cucumber/index.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _events = _interopRequireDefault(require("events"));
+var _messagesBuilder = require("./messagesBuilder");
+var _configDir = require("../../config/configDir");
+var _enrichReporterData = require("../../config/enrichReporterData");
+var _message = _interopRequireDefault(require("./message"));
+var _html = _interopRequireDefault(require("./html"));
+var _junit = _interopRequireDefault(require("./junit"));
+var _json = _interopRequireDefault(require("./json"));
+var _custom = _interopRequireDefault(require("./custom"));
+/**
+ * Playwright reporter that generates different Cucumber reports.
+ */
+
+const builtinReporters = {
+  html: _html.default,
+  message: _message.default,
+  junit: _junit.default,
+  json: _json.default
+};
+class CucumberReporterAdapter {
+  messagesBuilderRef;
+  type;
+  userOptions;
+  reporter;
+  constructor(fullOptions) {
+    const {
+      $type,
+      ...userOptions
+    } = fullOptions;
+    this.type = $type;
+    this.userOptions = userOptions;
+    (0, _enrichReporterData.enableEnrichReporterData)();
+    this.messagesBuilderRef = (0, _messagesBuilder.getMessagesBuilderRef)();
+    this.reporter = this.createCucumberReporter();
+  }
+  printsToStdio() {
+    return this.reporter.printsToStdio();
+  }
+  onTestEnd(test, result) {
+    this.messagesBuilderRef.onTestEnd(test, result);
+  }
+  async onEnd(result) {
+    this.messagesBuilderRef.onEnd(result);
+    await this.reporter.init();
+    await this.messagesBuilderRef.builder.buildMessages();
+    this.messagesBuilderRef.builder.emitMessages(this.reporter.eventBroadcaster);
+    await this.reporter.finished();
+  }
+  createCucumberReporter() {
+    const internalOptions = {
+      cwd: (0, _configDir.getPlaywrightConfigDir)(),
+      eventBroadcaster: new _events.default(),
+      eventDataCollector: this.messagesBuilderRef.builder.eventDataCollector
+    };
+    if (isBuiltInReporter(this.type)) {
+      const BuiltInReporter = builtinReporters[this.type];
+      return new BuiltInReporter(internalOptions, this.userOptions);
+    } else {
+      const reporterPath = this.type;
+      return new _custom.default(internalOptions, reporterPath, this.userOptions);
+    }
+  }
+}
+exports.default = CucumberReporterAdapter;
+function isBuiltInReporter(type) {
+  return type in builtinReporters;
+}