@zohodesk/testinglibrary 0.1.8 → 0.1.9-exp-actors

package/build/bdd-framework/hooks/scenario.js

@@ -11,6 +11,8 @@ exports.scenarioHookFactory = scenarioHookFactory;
 var _tagExpressions = _interopRequireDefault(require("@cucumber/tag-expressions"));
 var _fixtureParameterNames = require("../playwright/fixtureParameterNames");
 var _utils = require("../utils");
+var _getLocationInFile = require("../playwright/getLocationInFile");
+var _testTypeImpl = require("../playwright/testTypeImpl");
 /**
  * Scenario level hooks: Before / After.
  *
@@ -27,14 +29,16 @@ function scenarioHookFactory(type) {
     addHook({
       type,
       options: getOptionsFromArgs(args),
-      fn: getFnFromArgs(args)
+      fn: getFnFromArgs(args),
+      // offset = 3 b/c this call is 3 steps below the user's code
+      location: (0, _getLocationInFile.getLocationByOffset)(3)
     });
   };
 }
 function hasScenarioHooks() {
   return scenarioHooks.length > 0;
 }
-// eslint-disable-next-line complexity
+// eslint-disable-next-line complexity, max-statements
 async function runScenarioHooks(type, fixtures) {
   let error;
   for (const hook of scenarioHooks) {
@@ -44,11 +48,9 @@ async function runScenarioHooks(type, fixtures) {
     if (hook.tagsExpression && !hook.tagsExpression.evaluate(fixtures.$tags)) {
       continue;
     }
-    const {
-      timeout
-    } = hook.options;
     try {
-      await (0, _utils.callWithTimeout)(() => hook.fn.call(fixtures.$bddWorld, fixtures), timeout, `${type} hook timeout (${timeout} ms)`);
+      const hookFn = wrapHookFn(hook, fixtures);
+      await (0, _testTypeImpl.runStepWithCustomLocation)(fixtures.$bddWorld.test, hook.options.name || '', hook.location, hookFn);
     } catch (e) {
       if (type === 'before') {
         throw e;
@@ -77,6 +79,20 @@ function getScenarioHooksFixtures() {
   }
   return scenarioHooksFixtures;
 }
+/**
+ * Wraps hook fn with timeout and waiting Cucumber attachments to fulfill.
+ */
+function wrapHookFn(hook, fixtures) {
+  const {
+    timeout
+  } = hook.options;
+  const {
+    $bddWorld
+  } = fixtures;
+  return async () => {
+    await (0, _utils.callWithTimeout)(() => hook.fn.call($bddWorld, fixtures), timeout, getTimeoutMessage(hook));
+  };
+}
 function getOptionsFromArgs(args) {
   if (typeof args[0] === 'string') {
     return {
@@ -104,4 +120,11 @@ function addHook(hook) {
     // 'after' hooks run in reverse order
     scenarioHooks.unshift(hook);
   }
+}
+function getTimeoutMessage(hook) {
+  const {
+    timeout,
+    name: hookName
+  } = hook.options;
+  return `${hook.type} hook ${hookName ? `"${hookName}" ` : ''}timeout (${timeout} ms)`;
 }

package/build/bdd-framework/hooks/worker.js

@@ -37,7 +37,7 @@ async function runWorkerHooks(type, fixtures) {
       timeout
     } = hook.options;
     try {
-      await (0, _utils.callWithTimeout)(() => hook.fn(fixtures), timeout, `${type} hook timeout (${timeout} ms)`);
+      await (0, _utils.callWithTimeout)(() => hook.fn(fixtures), timeout, getTimeoutMessage(hook));
     } catch (e) {
       if (type === 'beforeAll') {
         throw e;
@@ -80,4 +80,10 @@ function addHook(hook) {
     // 'afterAll' hooks run in reverse order
     workerHooks.unshift(hook);
   }
+}
+function getTimeoutMessage(hook) {
+  const {
+    timeout
+  } = hook.options;
+  return `${hook.type} hook timeout (${timeout} ms)`;
 }

package/build/bdd-framework/index.js

@@ -27,6 +27,12 @@ Object.defineProperty(exports, "createBdd", {
     return _createBdd.createBdd;
   }
 });
+Object.defineProperty(exports, "cucumberReporter", {
+  enumerable: true,
+  get: function () {
+    return _helper.cucumberReporter;
+  }
+});
 Object.defineProperty(exports, "defineBddConfig", {
   enumerable: true,
   get: function () {
@@ -42,4 +48,5 @@ Object.defineProperty(exports, "test", {
 var _config = require("./config");
 var _createBdd = require("./stepDefinitions/createBdd");
 var _bddFixtures = require("./run/bddFixtures");
-var _bddWorld = require("./run/bddWorld");
+var _bddWorld = require("./run/bddWorld");
+var _helper = require("./reporter/cucumber/helper");

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

@@ -4,33 +4,60 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.getLocationByOffset = getLocationByOffset;
 exports.getLocationInFile = getLocationInFile;
 var _url = _interopRequireDefault(require("url"));
 var _utils = require("./utils");
 /**
- * Inspects stacktrace and finds call location in provided file.
- * This function is based on Playwright's getLocationByStacktrace().
- * See: https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/transform.ts#L229
+ * Finds first frame in the callstack that matches provided file.
+ * Constructs location object from that frame.
+ *
+ * Example:
+ * Calling getLocationInFile('file-3.js');
+ * Call stack:
+ * - at <anonymous> (file-1.js:1:2)
+ * - at myFunction2 (file-2.js:3:4)
+ * - at myFunction3 (file-3.js:5:6)
+ * - at myFunction4 (file-4.js:7:8)
+ *
+ * Returned value: { file: 'file-3.js', line: 5, column: 6 }
  */
 function getLocationInFile(filePath) {
   const filePathUrl = _url.default.pathToFileURL(filePath).toString();
+  return getLocationBy(stackFrames => {
+    return stackFrames.find(frame => {
+      const frameFile = frame.getFileName();
+      return frameFile === filePath || frameFile === filePathUrl;
+    });
+  });
+}
+function getLocationByOffset(offset) {
+  return getLocationBy(stackFrames => stackFrames[offset]);
+}
+/**
+ * Iterates stacktrace of the call of this function
+ * and finds frame using provided findFrame predicate.
+ * Constructs location object from the found frame.
+ *
+ * This function is based on Playwright's wrapFunctionWithLocation().
+ * See: https://github.com/microsoft/playwright/blob/main/packages/playwright/src/transform/transform.ts#L261
+ */
+function getLocationBy(findFrame) {
   const {
     sourceMapSupport
   } = (0, _utils.requirePlaywrightModule)('lib/utilsBundle.js');
   const oldPrepareStackTrace = Error.prepareStackTrace;
+  // modify prepareStackTrace to return Location object instead of string
   Error.prepareStackTrace = (error, stackFrames) => {
-    const frameInFile = stackFrames.find(frame => {
-      const frameFile = frame.getFileName();
-      return frameFile === filePath || frameFile === filePathUrl;
-    });
-    if (!frameInFile) {
+    const foundFrame = findFrame(stackFrames);
+    if (!foundFrame) {
       return {
         file: '',
         line: 0,
         column: 0
       };
     }
-    const frame = sourceMapSupport.wrapCallSite(frameInFile);
+    const frame = sourceMapSupport.wrapCallSite(foundFrame);
     const fileName = frame.getFileName();
     // Node error stacks for modules use file:// urls instead of paths.
     const file = fileName !== null && fileName !== void 0 && fileName.startsWith('file://') ? _url.default.fileURLToPath(fileName) : fileName;

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

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requireOrImportDefaultFunction = requireOrImportDefaultFunction;
+var _path = _interopRequireDefault(require("path"));
+var _transform = require("./transform");
+/**
+ * Partial from: https://github.com/microsoft/playwright/blob/main/packages/playwright/src/runner/loadUtils.ts
+ */
+/* eslint-disable complexity */
+
+async function requireOrImportDefaultFunction(file, expectConstructor) {
+  let func = await (0, _transform.requireTransform)().requireOrImport(file);
+  if (func && typeof func === 'object' && 'default' in func) {
+    func = func['default'];
+  }
+  if (typeof func !== 'function') {
+    throw errorWithFile(file, `file must export a single ${expectConstructor ? 'class' : 'function'}.`);
+  }
+  return func;
+}
+function relativeFilePath(file) {
+  if (!_path.default.isAbsolute(file)) {
+    return file;
+  }
+  return _path.default.relative(process.cwd(), file);
+}
+function errorWithFile(file, message) {
+  return new Error(`${relativeFilePath(file)}: ${message}`);
+}

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

@@ -41,7 +41,11 @@ function installTransform() {
     if (!shouldTransform(filename)) {
       return code;
     }
-    return transformHook(code, filename);
+    // 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']
   });

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;
+}