cucumberjs-qase-reporter 2.0.0-beta.0 → 2.0.0-beta.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { CucumberQaseReporter } from './reporter';
+export = CucumberQaseReporter;

package/dist/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const reporter_1 = require("./reporter");
+module.exports = reporter_1.CucumberQaseReporter;

package/dist/reporter.d.ts

@@ -0,0 +1,86 @@
+import { Formatter, IFormatterOptions, Status } from '@cucumber/cucumber';
+import { ConfigType, ConfigLoader, TestStatusEnum } from 'qase-javascript-commons';
+type TestStepResultStatus = (typeof Status)[keyof typeof Status];
+export type CucumberQaseOptionsType = IFormatterOptions & {
+    qase?: ConfigType;
+};
+/**
+ * @class CucumberQaseReporter
+ * @extends Formatter
+ */
+export declare class CucumberQaseReporter extends Formatter {
+    /**
+     * @type {Record<TestStepResultStatus, TestStatusEnum | null>}
+     */
+    static statusMap: Record<TestStepResultStatus, TestStatusEnum | null>;
+    /**
+     * @type {RegExp}
+     */
+    static qaseIdRegExp: RegExp;
+    /**
+     * @param {readonly PickleTag[]} tagsList
+     * @returns {number[]}
+     * @private
+     */
+    private static getCaseIds;
+    /**
+     * @type {Record<string, PickleInfoType>}
+     * @private
+     */
+    private pickleInfo;
+    /**
+     * @type {Record<string, TestCaseStarted>}
+     * @private
+     */
+    private testCaseStarts;
+    /**
+     * @type {Record<string, >}
+     * @private
+     */
+    private testCaseStartedResult;
+    /**
+     * @type {Record<string, string[]>}
+     * @private
+     */
+    private testCaseStartedErrors;
+    /**
+     * @type {Record<string, string>}
+     * @private
+     */
+    private testCaseScenarioId;
+    /**
+     * @type {Record<string, string>}
+     * @private
+     */
+    private scenarios;
+    /**
+     * @type {Record<string, string>}
+     * @private
+     */
+    private attachments;
+    /**
+     * @type {ReporterInterface}
+     * @private
+     */
+    private reporter;
+    /**
+     * @type {EventEmitter}
+     * @private
+     */
+    private eventBroadcaster;
+    /**
+     * @param {CucumberQaseOptionsType} options
+     * @param {ConfigLoaderInterface} configLoader
+     */
+    constructor(options: CucumberQaseOptionsType, configLoader?: ConfigLoader<Partial<ConfigType> & Record<string, unknown>>);
+    /**
+     * @private
+     */
+    private bindEventListeners;
+    /**
+     * @returns {Promise<void>}
+     * @private
+     */
+    private publishResults;
+}
+export {};

package/dist/reporter.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CucumberQaseReporter = void 0;
+const cucumber_1 = require("@cucumber/cucumber");
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+/**
+ * @class CucumberQaseReporter
+ * @extends Formatter
+ */
+class CucumberQaseReporter extends cucumber_1.Formatter {
+    /**
+     * @param {readonly PickleTag[]} tagsList
+     * @returns {number[]}
+     * @private
+     */
+    static getCaseIds(tagsList) {
+        return tagsList.reduce((acc, tagInfo) => {
+            const ids = Array.from(tagInfo.name.matchAll(CucumberQaseReporter.qaseIdRegExp))
+                .map(([, id]) => Number(id))
+                .filter((id) => id !== undefined);
+            acc.push(...ids);
+            return acc;
+        }, []);
+    }
+    /**
+     * @param {CucumberQaseOptionsType} options
+     * @param {ConfigLoaderInterface} configLoader
+     */
+    constructor(options, configLoader = new qase_javascript_commons_1.ConfigLoader()) {
+        const { qase, ...formatterOptions } = options;
+        const config = configLoader.load();
+        super(formatterOptions);
+        /**
+         * @type {Record<string, PickleInfoType>}
+         * @private
+         */
+        this.pickleInfo = {};
+        /**
+         * @type {Record<string, TestCaseStarted>}
+         * @private
+         */
+        this.testCaseStarts = {};
+        /**
+         * @type {Record<string, >}
+         * @private
+         */
+        this.testCaseStartedResult = {};
+        /**
+         * @type {Record<string, string[]>}
+         * @private
+         */
+        this.testCaseStartedErrors = {};
+        /**
+         * @type {Record<string, string>}
+         * @private
+         */
+        this.testCaseScenarioId = {};
+        /**
+         * @type {Record<string, string>}
+         * @private
+         */
+        this.scenarios = {};
+        /**
+         * @type {Record<string, string>}
+         * @private
+         */
+        this.attachments = {};
+        this.reporter = new qase_javascript_commons_1.QaseReporter({
+            ...(0, qase_javascript_commons_1.composeOptions)(qase, config),
+            frameworkPackage: '@cucumber/cucumber',
+            frameworkName: 'cucumberjs',
+            reporterName: 'cucumberjs-qase-reporter',
+        });
+        this.eventBroadcaster = formatterOptions.eventBroadcaster;
+        this.bindEventListeners();
+    }
+    /**
+     * @private
+     */
+    bindEventListeners() {
+        this.eventBroadcaster.on('envelope', (envelope) => {
+            if (envelope.gherkinDocument) {
+                if (envelope.gherkinDocument.feature) {
+                    const { children, name } = envelope.gherkinDocument.feature;
+                    children.forEach(({ scenario }) => {
+                        if (scenario) {
+                            this.scenarios[scenario.id] = name;
+                        }
+                    });
+                }
+            }
+            else if (envelope.pickle) {
+                this.pickleInfo[envelope.pickle.id] = {
+                    caseIds: CucumberQaseReporter.getCaseIds(envelope.pickle.tags),
+                    name: envelope.pickle.name,
+                    lastAstNodeId: envelope.pickle.astNodeIds[envelope.pickle.astNodeIds.length - 1],
+                };
+            }
+            else if (envelope.attachment) {
+                if (envelope.attachment.testCaseStartedId &&
+                    envelope.attachment.fileName) {
+                    this.attachments[envelope.attachment.testCaseStartedId] =
+                        envelope.attachment.fileName;
+                }
+            }
+            else if (envelope.testRunFinished) {
+                void this.publishResults();
+            }
+            else if (envelope.testCase) {
+                this.testCaseScenarioId[envelope.testCase.id] =
+                    envelope.testCase.pickleId;
+            }
+            else if (envelope.testCaseStarted) {
+                this.testCaseStarts[envelope.testCaseStarted.id] =
+                    envelope.testCaseStarted;
+                this.testCaseStartedResult[envelope.testCaseStarted.id] =
+                    qase_javascript_commons_1.TestStatusEnum.passed;
+            }
+            else if (envelope.testStepFinished) {
+                const stepFin = envelope.testStepFinished;
+                const oldStatus = this.testCaseStartedResult[stepFin.testCaseStartedId];
+                const newStatus = CucumberQaseReporter.statusMap[stepFin.testStepResult.status];
+                if (newStatus === null) {
+                    return;
+                }
+                if (newStatus !== qase_javascript_commons_1.TestStatusEnum.passed) {
+                    if (stepFin.testStepResult.message) {
+                        const errors = this.testCaseStartedErrors[stepFin.testCaseStartedId] ?? [];
+                        if (!this.testCaseStartedErrors[stepFin.testCaseStartedId]) {
+                            this.testCaseStartedErrors[stepFin.testCaseStartedId] = errors;
+                        }
+                        errors.push(stepFin.testStepResult.message);
+                    }
+                    if (oldStatus) {
+                        if (oldStatus !== qase_javascript_commons_1.TestStatusEnum.failed) {
+                            this.testCaseStartedResult[stepFin.testCaseStartedId] = newStatus;
+                        }
+                    }
+                    else {
+                        this.testCaseStartedResult[stepFin.testCaseStartedId] = newStatus;
+                    }
+                }
+            }
+            else if (envelope.testCaseFinished) {
+                const tcs = this.testCaseStarts[envelope.testCaseFinished.testCaseStartedId];
+                if (!tcs) {
+                    return;
+                }
+                const pickleId = this.testCaseScenarioId[tcs.testCaseId];
+                if (!pickleId) {
+                    return;
+                }
+                const info = this.pickleInfo[pickleId];
+                if (!info) {
+                    return;
+                }
+                let error;
+                if (this.testCaseStartedErrors[tcs.id]?.length) {
+                    error = new Error(this.testCaseStartedErrors[tcs.id]?.join('\n\n'));
+                }
+                this.reporter.addTestResult({
+                    id: tcs.id,
+                    testOpsId: info.caseIds,
+                    title: info.name,
+                    suiteTitle: info.lastAstNodeId && this.scenarios[info.lastAstNodeId],
+                    status: this.testCaseStartedResult[envelope.testCaseFinished.testCaseStartedId] ?? qase_javascript_commons_1.TestStatusEnum.passed,
+                    startTime: tcs.timestamp.seconds,
+                    endTime: envelope.testCaseFinished.timestamp.seconds,
+                    duration: Math.abs(envelope.testCaseFinished.timestamp.seconds - tcs.timestamp.seconds),
+                    error,
+                });
+            }
+        });
+    }
+    /**
+     * @returns {Promise<void>}
+     * @private
+     */
+    async publishResults() {
+        await this.reporter.publish();
+    }
+}
+exports.CucumberQaseReporter = CucumberQaseReporter;
+/**
+ * @type {Record<TestStepResultStatus, TestStatusEnum | null>}
+ */
+CucumberQaseReporter.statusMap = {
+    [cucumber_1.Status.PASSED]: qase_javascript_commons_1.TestStatusEnum.passed,
+    [cucumber_1.Status.FAILED]: qase_javascript_commons_1.TestStatusEnum.failed,
+    [cucumber_1.Status.SKIPPED]: qase_javascript_commons_1.TestStatusEnum.skipped,
+    [cucumber_1.Status.AMBIGUOUS]: null,
+    [cucumber_1.Status.PENDING]: qase_javascript_commons_1.TestStatusEnum.blocked,
+    [cucumber_1.Status.UNDEFINED]: null,
+    [cucumber_1.Status.UNKNOWN]: null,
+};
+/**
+ * @type {RegExp}
+ */
+CucumberQaseReporter.qaseIdRegExp = /^@[Qq]-?(\d+)$/g;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cucumberjs-qase-reporter",
-  "version": "2.0.0-beta.0",
+  "version": "2.0.0-beta.1",
   "description": "Qase TMS CucumberJS Reporter",
   "homepage": "https://github.com/qase-tms/qase-javascript",
   "main": "./dist/index.js",
@@ -40,7 +40,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@cucumber/messages": "^22.0.0",
-    "qase-javascript-commons": "^2.0.0-beta.0"
+    "qase-javascript-commons": "^2.0.0-beta.1"
   },
   "peerDependencies": {
     "@cucumber/cucumber": ">=7.0.0"