@zohodesk/testinglibrary 0.1.8 → 0.1.9

package/build/bdd-framework/reporter/cucumber/messagesBuilder/Builder.js

@@ -0,0 +1,196 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MessagesBuilder = void 0;
+var _TestCaseRun = require("./TestCaseRun");
+var _TestCase = require("./TestCase");
+var _Meta = require("./Meta");
+var _timing = require("./timing");
+var _events = _interopRequireDefault(require("events"));
+var _EventDataCollector = _interopRequireDefault(require("../../../cucumber/formatter/EventDataCollector"));
+var _AutofillMap = require("../../../utils/AutofillMap");
+var _GherkinDocuments = require("./GherkinDocuments");
+var _Pickles = require("./Pickles");
+class MessagesBuilder {
+  report = {
+    meta: null,
+    source: [],
+    gherkinDocument: [],
+    pickle: [],
+    stepDefinition: [],
+    hook: [],
+    testRunStarted: null,
+    testCase: [],
+    testCaseRuns: [],
+    testRunFinished: null
+  };
+  fullResult;
+  onTestEnds = [];
+  testCaseRuns = [];
+  testCases = new _AutofillMap.AutofillMap();
+  hooks = new _AutofillMap.AutofillMap();
+  gherkinDocuments = new _GherkinDocuments.GherkinDocuments();
+  fullResultTiming;
+  onEndPromise;
+  onEndPromiseResolve = () => {};
+  buildMessagesPromise;
+  eventDataCollectorEmitter = new _events.default();
+  eventDataCollector = new _EventDataCollector.default(this.eventDataCollectorEmitter);
+  constructor() {
+    this.onEndPromise = new Promise(resolve => this.onEndPromiseResolve = resolve);
+  }
+  onTestEnd(test, result) {
+    this.onTestEnds.push({
+      test,
+      result
+    });
+  }
+  onEnd(fullResult) {
+    this.fullResult = fullResult;
+    this.onEndPromiseResolve();
+  }
+  /**
+     * Builds Cucumber messages.
+     * Note: wrapped into promise to build messages once for all reporters.
+     */
+  async buildMessages() {
+    if (!this.buildMessagesPromise) {
+      this.buildMessagesPromise = this.doBuildMessages();
+    }
+    return this.buildMessagesPromise;
+  }
+  // eslint-disable-next-line max-statements
+  async doBuildMessages() {
+    await this.onEndPromise;
+    // order here is important
+    this.createTestCaseRuns();
+    await this.loadFeatures();
+    this.createTestCases();
+    this.addMeta();
+    this.addSourcesAndDocuments();
+    this.addPickles();
+    this.addHooks();
+    this.addTestRunStarted();
+    this.addTestCases();
+    this.addTestCaseRuns();
+    this.addTestRunFinished();
+    this.buildEventDataCollector();
+  }
+  emitMessages(eventBroadcaster) {
+    Object.values(this.report).forEach(value => {
+      if (!value) {
+        return;
+      }
+      const messages = Array.isArray(value) ? value : [value];
+      messages.forEach(message => eventBroadcaster.emit('envelope', message));
+    });
+  }
+  createTestCases() {
+    this.testCaseRuns.forEach(testCaseRun => {
+      const testId = testCaseRun.test.id;
+      const gherkinDocsForProject = this.gherkinDocuments.getDocumentsForProject(testCaseRun.projectInfo);
+      const testCase = this.testCases.getOrCreate(testId, () => new _TestCase.TestCase(testId, gherkinDocsForProject));
+      testCase.addRun(testCaseRun);
+      testCaseRun.testCase = testCase;
+    });
+  }
+  async loadFeatures() {
+    await this.gherkinDocuments.load(this.testCaseRuns);
+  }
+  createTestCaseRuns() {
+    this.onTestEnds.forEach(({
+      test,
+      result
+    }) => {
+      // For skipped tests Playwright doesn't run fixtures
+      // and we don't have bddData attachment -> don't know feature uri.
+      // Don't add such test run to report.
+      if (test.expectedStatus === 'skipped') {
+        return;
+      }
+      const testCaseRun = new _TestCaseRun.TestCaseRun(test, result, this.hooks);
+      this.testCaseRuns.push(testCaseRun);
+    });
+  }
+  addMeta() {
+    this.report.meta = new _Meta.Meta().buildMessage();
+  }
+  addSourcesAndDocuments() {
+    const {
+      sources,
+      gherkinDocuments
+    } = this.gherkinDocuments.buildMessages();
+    this.report.source = sources;
+    this.report.gherkinDocument = gherkinDocuments;
+  }
+  addPickles() {
+    this.report.pickle = new _Pickles.Pickles().buildMessages(this.testCases);
+  }
+  addHooks() {
+    this.hooks.forEach(hook => {
+      const message = hook.buildMessage();
+      this.report.hook.push(message);
+    });
+  }
+  addTestCases() {
+    this.testCases.forEach(testCase => {
+      const message = testCase.buildMessage();
+      this.report.testCase.push(message);
+    });
+  }
+  addTestCaseRuns() {
+    this.testCaseRuns.map(testCaseRun => {
+      const messages = testCaseRun.buildMessages();
+      this.report.testCaseRuns.push(...messages);
+    });
+  }
+  addTestRunStarted() {
+    const {
+      startTime
+    } = this.getFullResultTiming();
+    const testRunStarted = {
+      timestamp: (0, _timing.toCucumberTimestamp)(startTime.getTime())
+    };
+    this.report.testRunStarted = {
+      testRunStarted
+    };
+  }
+  addTestRunFinished() {
+    const {
+      startTime,
+      duration
+    } = this.getFullResultTiming();
+    const testRunFinished = {
+      success: this.fullResult.status === 'passed',
+      timestamp: (0, _timing.toCucumberTimestamp)(startTime.getTime() + duration)
+    };
+    this.report.testRunFinished = {
+      testRunFinished
+    };
+  }
+  buildEventDataCollector() {
+    this.emitMessages(this.eventDataCollectorEmitter);
+  }
+  getFullResultTiming() {
+    if (this.fullResultTiming) {
+      return this.fullResultTiming;
+    }
+    // result.startTime and result.duration were added in pw 1.37
+    // see: https://github.com/microsoft/playwright/pull/26760
+    if ('startTime' in this.fullResult && 'duration' in this.fullResult) {
+      this.fullResultTiming = {
+        startTime: this.fullResult.startTime,
+        duration: this.fullResult.duration
+      };
+    } else {
+      // Calculate overall startTime and duration based on test timings
+      const items = this.testCaseRuns.map(t => t.result);
+      this.fullResultTiming = (0, _timing.calcMinMaxByArray)(items);
+    }
+    return this.fullResultTiming;
+  }
+}
+exports.MessagesBuilder = MessagesBuilder;

package/build/bdd-framework/reporter/cucumber/messagesBuilder/GherkinDocument.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GherkinDocumentMessage = void 0;
+var _utils = require("../../../utils");
+var _Projects = require("./Projects");
+const gherkinDocumentMetaSymbol = Symbol('gherkinDocumentMeta');
+class GherkinDocumentMessage {
+  projectInfo;
+  gherkinDocument;
+  static extractMeta(gherkinDocument) {
+    return gherkinDocument[gherkinDocumentMetaSymbol];
+  }
+  constructor(projectInfo, gherkinDocument) {
+    this.projectInfo = projectInfo;
+    this.gherkinDocument = gherkinDocument;
+  }
+  build() {
+    const gherkinDocument = this.copyDocumentWithoutPickles();
+    this.setUriWithProject(gherkinDocument);
+    this.setMeta(gherkinDocument);
+    return {
+      gherkinDocument
+    };
+  }
+  copyDocumentWithoutPickles() {
+    return (0, _utils.omit)(this.gherkinDocument, 'pickles');
+  }
+  setUriWithProject(gherkinDocument) {
+    gherkinDocument.uri = (0, _Projects.getFeatureUriWithProject)(this.projectInfo, this.gherkinDocument.uri);
+  }
+  setMeta(gherkinDocument) {
+    var _this$projectInfo, _this$projectInfo2;
+    gherkinDocument[gherkinDocumentMetaSymbol] = {
+      originalUri: this.gherkinDocument.uri || '',
+      projectName: (_this$projectInfo = this.projectInfo) === null || _this$projectInfo === void 0 ? void 0 : _this$projectInfo.projectName,
+      browserName: (_this$projectInfo2 = this.projectInfo) === null || _this$projectInfo2 === void 0 ? void 0 : _this$projectInfo2.browserName
+    };
+  }
+}
+exports.GherkinDocumentMessage = GherkinDocumentMessage;

package/build/bdd-framework/reporter/cucumber/messagesBuilder/GherkinDocumentClone.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GherkinDocumentClone = void 0;
+var _crypto = require("crypto");
+var _AutofillMap = require("../../../utils/AutofillMap");
+/**
+ * Creates gherkin document copy with re-generated ast node IDs,
+ * pickle IDs and pickle steps IDs.
+ */
+
+class GherkinDocumentClone {
+  gherkinDocument;
+  oldNewIds = new _AutofillMap.AutofillMap();
+  constructor(gherkinDocument) {
+    this.gherkinDocument = gherkinDocument;
+  }
+  getClone() {
+    const copiedDoc = this.getDocumentCopyWithNewIds();
+    this.remapPickleAstNodeIds(copiedDoc);
+    return copiedDoc;
+  }
+  getDocumentCopyWithNewIds() {
+    return JSON.parse(JSON.stringify(this.gherkinDocument, (key, value) => {
+      return key === 'id' ? this.getOrGenerateNewId(value) : value;
+    }));
+  }
+  remapPickleAstNodeIds(copiedDoc) {
+    copiedDoc.pickles.forEach(pickle => {
+      pickle.astNodeIds = pickle.astNodeIds.map(oldId => this.getNewId(oldId));
+      this.remapPickleStepsAstNodeIds(pickle);
+    });
+  }
+  remapPickleStepsAstNodeIds(pickle) {
+    pickle.steps.forEach(step => {
+      step.astNodeIds = step.astNodeIds.map(oldId => this.getNewId(oldId));
+    });
+  }
+  getOrGenerateNewId(oldId) {
+    return this.oldNewIds.getOrCreate(oldId, () => (0, _crypto.randomUUID)());
+  }
+  getNewId(oldId) {
+    const newId = this.oldNewIds.get(oldId);
+    if (!newId) {
+      throw new Error(`New ID is not found for old ID: ${oldId}`);
+    }
+    return newId;
+  }
+}
+exports.GherkinDocumentClone = GherkinDocumentClone;

package/build/bdd-framework/reporter/cucumber/messagesBuilder/GherkinDocuments.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GherkinDocuments = void 0;
+var _AutofillMap = require("../../../utils/AutofillMap");
+var _loadFeatures = require("../../../cucumber/loadFeatures");
+var _configDir = require("../../../config/configDir");
+var _GherkinDocumentClone = require("./GherkinDocumentClone");
+var _GherkinDocument = require("./GherkinDocument");
+var _Projects = require("./Projects");
+var _env = require("../../../config/env");
+var _lang = require("../../../config/lang");
+class GherkinDocuments {
+  featuresLoader = new _loadFeatures.FeaturesLoader();
+  projectsPerFeaturePath = new _AutofillMap.AutofillMap();
+  gherkinDocumentsPerProject = new _AutofillMap.AutofillMap();
+  constructor() {}
+  async load(testCaseRuns) {
+    this.fillProjectsPerFeaturePath(testCaseRuns);
+    const cwd = (0, _configDir.getPlaywrightConfigDir)();
+    const featurePaths = [...this.projectsPerFeaturePath.keys()];
+    await this.featuresLoader.load(featurePaths, {
+      relativeTo: cwd,
+      defaultDialect: this.getFeaturesLang()
+    });
+    this.fillGherkinDocumentsPerProject();
+  }
+  getDocumentsForProject(projectInfo) {
+    const docs = this.gherkinDocumentsPerProject.get(projectInfo);
+    if (!docs) {
+      throw new Error(`No gherkin docs for project ${projectInfo === null || projectInfo === void 0 ? void 0 : projectInfo.projectName}`);
+    }
+    return docs;
+  }
+  buildMessages() {
+    const sources = [];
+    const gherkinDocuments = [];
+    this.gherkinDocumentsPerProject.forEach((docs, project) => {
+      docs.forEach(doc => {
+        sources.push(this.buildSourceMessage(project, doc));
+        gherkinDocuments.push(new _GherkinDocument.GherkinDocumentMessage(project, doc).build());
+      });
+    });
+    return {
+      sources,
+      gherkinDocuments
+    };
+  }
+  fillProjectsPerFeaturePath(testCaseRuns) {
+    testCaseRuns.forEach(testCaseRun => {
+      const projects = this.projectsPerFeaturePath.getOrCreate(testCaseRun.bddData.uri, () => new Set());
+      projects.add(testCaseRun.projectInfo);
+    });
+  }
+  fillGherkinDocumentsPerProject() {
+    this.featuresLoader.getDocumentsWithPickles().forEach(gherkinDocument => {
+      if (!gherkinDocument.uri) {
+        throw new Error(`Feature without uri`);
+      }
+      const projects = this.projectsPerFeaturePath.get(gherkinDocument.uri);
+      if (!projects) {
+        throw new Error(`Feature without projects: ${gherkinDocument.uri}`);
+      }
+      projects.forEach(project => {
+        this.addGherkinDocumentToProject(project, gherkinDocument);
+      });
+    });
+  }
+  addGherkinDocumentToProject(projectInfo, gherkinDocument) {
+    const projectDocs = this.gherkinDocumentsPerProject.getOrCreate(projectInfo, () => []);
+    const clonedDocument = new _GherkinDocumentClone.GherkinDocumentClone(gherkinDocument).getClone();
+    projectDocs.push(clonedDocument);
+  }
+  buildSourceMessage(projectInfo, doc) {
+    if (!doc.uri) {
+      throw new Error(`Doc without uri`);
+    }
+    const originalSource = this.featuresLoader.gherkinQuery.getSource(doc.uri);
+    if (!originalSource) {
+      throw new Error(`No source`);
+    }
+    const source = {
+      ...originalSource,
+      uri: (0, _Projects.getFeatureUriWithProject)(projectInfo, doc.uri)
+    };
+    return {
+      source
+    };
+  }
+  getFeaturesLang() {
+    const langsSet = new Set();
+    const envConfigs = (0, _env.getEnvConfigs)();
+    Object.values(envConfigs).forEach(config => {
+      langsSet.add(config.language || _lang.LANG_EN);
+    });
+    const langs = [...langsSet];
+    if (langs.length > 1) {
+      throw new Error([`Multi-language features are not supported yet.`, `Detected languages: ${langs.join(', ')}`].join(' '));
+    }
+    return langs[0];
+  }
+}
+exports.GherkinDocuments = GherkinDocuments;

package/build/bdd-framework/reporter/cucumber/messagesBuilder/Hook.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Hook = void 0;
+var _crypto = require("crypto");
+var _configDir = require("../../../config/configDir");
+var _path = _interopRequireDefault(require("path"));
+/**
+ * Hook that can be used in different test cases.
+ * Builds Cucumber's hook message.
+ */
+
+class Hook {
+  internalId;
+  static getInternalId(pwStep) {
+    const {
+      file,
+      line,
+      column
+    } = pwStep.location || {};
+    return [pwStep.category, ...pwStep.titlePath(), file, line, column].join('|');
+  }
+  id;
+  name;
+  sourceReference;
+  constructor(internalId, /* one of pwSteps for this hook */
+  pwStep) {
+    this.internalId = internalId;
+    this.id = (0, _crypto.randomUUID)();
+    this.name = this.getName(pwStep);
+    this.sourceReference = this.getSourceReference(pwStep);
+  }
+  buildMessage() {
+    const hook = {
+      id: this.id,
+      name: this.name,
+      sourceReference: this.sourceReference
+    };
+    return {
+      hook
+    };
+  }
+  getName(pwStep) {
+    // These fixture names are for anonymous hooks
+    // created with Before() / After() functions.
+    // Keep name empty for them to be consistent with Cucumber.
+    // const bddSystemFixtures = ['fixture: $before', 'fixture: $after'];
+    // if (!pwStep.title || bddSystemFixtures.includes(pwStep.title)) return undefined;
+    return pwStep.title;
+  }
+  getSourceReference(pwStep) {
+    const {
+      file,
+      line,
+      column
+    } = pwStep.location || {};
+    const uri = file ? _path.default.relative((0, _configDir.getPlaywrightConfigDir)(), file) : undefined;
+    return {
+      uri,
+      location: {
+        line: line || 0,
+        column
+      }
+    };
+  }
+}
+exports.Hook = Hook;

package/build/bdd-framework/reporter/cucumber/messagesBuilder/Meta.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Meta = void 0;
+var _os = _interopRequireDefault(require("os"));
+var messages = _interopRequireWildcard(require("@cucumber/messages"));
+var _utils = require("../../../utils");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Builds meta message.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/cli/helpers.ts#L100
+ */
+
+class Meta {
+  buildMessage() {
+    const playwrightBddVersion = (0, _utils.getPackageVersion)('playwright-bdd');
+    const playwrightVersion = (0, _utils.getPackageVersion)('@playwright/test');
+    const meta = {
+      protocolVersion: messages.version,
+      implementation: {
+        version: `${playwrightBddVersion} (playwright ${playwrightVersion})`,
+        name: 'playwright-bdd'
+      },
+      cpu: {
+        name: _os.default.arch()
+      },
+      os: {
+        name: _os.default.platform(),
+        version: _os.default.release()
+      },
+      runtime: {
+        name: 'node.js',
+        version: process.versions.node
+      }
+    };
+    return {
+      meta
+    };
+  }
+}
+exports.Meta = Meta;

package/build/bdd-framework/reporter/cucumber/messagesBuilder/Pickles.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Pickles = void 0;
+var _utils = require("../../../utils");
+var _Projects = require("./Projects");
+class Pickles {
+  buildMessages(testCases) {
+    const messages = [];
+    testCases.forEach(testCase => {
+      messages.push(this.buildPickleMessage(testCase));
+    });
+    return messages;
+  }
+  buildPickleMessage(testCase) {
+    const pickle = {
+      ...(0, _utils.omit)(testCase.pickle, 'location'),
+      uri: (0, _Projects.getFeatureUriWithProject)(testCase.projectInfo, testCase.pickle.uri)
+    };
+    return {
+      pickle
+    };
+  }
+}
+exports.Pickles = Pickles;

package/build/bdd-framework/reporter/cucumber/messagesBuilder/Projects.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TITLE_SEPARATOR = void 0;
+exports.getFeatureNameWithProject = getFeatureNameWithProject;
+exports.getFeatureUriWithProject = getFeatureUriWithProject;
+exports.getProjectInfo = getProjectInfo;
+var _AutofillMap = require("../../../utils/AutofillMap");
+// title separator used in Playwright
+const TITLE_SEPARATOR = exports.TITLE_SEPARATOR = ' › ';
+const projectsMap = new _AutofillMap.AutofillMap();
+function getProjectInfo(test) {
+  const project = test.parent.project();
+  const projectId = project === null || project === void 0 ? void 0 : project.name;
+  return projectsMap.getOrCreate(projectId, () => {
+    return {
+      projectName: project === null || project === void 0 ? void 0 : project.name,
+      // browserName will be empty if not defined in project
+      // todo: get browser info from bddData
+      browserName: (project === null || project === void 0 ? void 0 : project.use.browserName) || (project === null || project === void 0 ? void 0 : project.use.defaultBrowserType)
+    };
+  });
+}
+/**
+ * Returns URI prepended with project name.
+ * It allows to separate PW projects runs of the same feature file.
+ *
+ * Now result should not contain spaces as Cucumber HTML report uses it as uuid.
+ * See: https://github.com/cucumber/react-components/issues/344
+ */
+function getFeatureUriWithProject(projectInfo, uri) {
+  return projectInfo !== null && projectInfo !== void 0 && projectInfo.projectName && uri ? `[${projectInfo.projectName}]:${uri}` : uri;
+}
+function getFeatureNameWithProject(projectName, featureName) {
+  return projectName ? `${projectName}${TITLE_SEPARATOR}${featureName}` : featureName;
+}