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

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,101 @@
+import { Formatter, IFormatterOptions, Status } from '@cucumber/cucumber';
+import { ConfigLoader, ConfigType, StepStatusEnum, 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 {Record<TestStepResultStatus, StepStatusEnum>}
+     */
+    static stepStatusMap: Record<TestStepResultStatus, StepStatusEnum>;
+    /**
+     * @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
+     */
+    /**
+     * @type {Record<string, TestStepFinished>}
+     * @private
+     */
+    private testCaseStepsFinished;
+    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;
+    private convertSteps;
+    /**
+     * @returns {Promise<void>}
+     * @private
+     */
+    private publishResults;
+    /**
+     * @returns {Promise<void>}
+     * @private
+     */
+    private startTestRun;
+}
+export {};

package/dist/reporter.js

@@ -0,0 +1,287 @@
+"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
+         */
+        /**
+         * @type {Record<string, TestStepFinished>}
+         * @private
+         */
+        this.testCaseStepsFinished = {};
+        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 = qase_javascript_commons_1.QaseReporter.getInstance({
+            ...(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],
+                    steps: envelope.pickle.steps,
+                };
+            }
+            else if (envelope.attachment) {
+                if (envelope.attachment.testCaseStartedId &&
+                    envelope.attachment.fileName) {
+                    this.attachments[envelope.attachment.testCaseStartedId] =
+                        envelope.attachment.fileName;
+                }
+            }
+            else if (envelope.testRunStarted) {
+                this.startTestRun();
+            }
+            else if (envelope.testRunFinished) {
+                void this.publishResults();
+            }
+            else if (envelope.testCase) {
+                this.testCaseScenarioId[envelope.testCase.id] =
+                    envelope.testCase;
+            }
+            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;
+                }
+                this.testCaseStepsFinished[stepFin.testStepId] = stepFin;
+                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 testCase = this.testCaseScenarioId[tcs.testCaseId];
+                if (!testCase) {
+                    return;
+                }
+                const info = this.pickleInfo[testCase.pickleId];
+                if (!info) {
+                    return;
+                }
+                let error;
+                if (this.testCaseStartedErrors[tcs.id]?.length) {
+                    error = new Error(this.testCaseStartedErrors[tcs.id]?.join('\n\n'));
+                }
+                let relations = null;
+                if (info.lastAstNodeId != undefined && this.scenarios[info.lastAstNodeId] != undefined) {
+                    relations = {
+                        suite: {
+                            data: [
+                                {
+                                    title: this.scenarios[info.lastAstNodeId] ?? '',
+                                    public_id: null,
+                                },
+                            ],
+                        },
+                    };
+                }
+                void this.reporter.addTestResult({
+                    attachments: [],
+                    author: null,
+                    execution: {
+                        status: this.testCaseStartedResult[envelope.testCaseFinished.testCaseStartedId] ?? qase_javascript_commons_1.TestStatusEnum.passed,
+                        start_time: null,
+                        end_time: null,
+                        duration: Math.abs(envelope.testCaseFinished.timestamp.seconds - tcs.timestamp.seconds),
+                        stacktrace: error?.stack ?? null,
+                        thread: null,
+                    },
+                    fields: {},
+                    message: null,
+                    muted: false,
+                    params: {},
+                    relations: relations,
+                    run_id: null,
+                    signature: '',
+                    steps: this.convertSteps(info.steps, testCase),
+                    testops_id: info.caseIds.length > 0 ? info.caseIds : null,
+                    id: tcs.id,
+                    title: info.name,
+                    // suiteTitle: info.lastAstNodeId && this.scenarios[info.lastAstNodeId],
+                });
+            }
+        });
+    }
+    convertSteps(steps, testCase) {
+        const results = [];
+        for (const s of testCase.testSteps) {
+            const finished = this.testCaseStepsFinished[s.id];
+            if (!finished) {
+                continue;
+            }
+            const step = steps.find((step) => step.id === s.pickleStepId);
+            if (!step) {
+                continue;
+            }
+            const result = {
+                id: s.id,
+                step_type: qase_javascript_commons_1.StepType.GHERKIN,
+                data: {
+                    keyword: step.text,
+                    name: step.text,
+                    line: 0,
+                },
+                execution: {
+                    status: CucumberQaseReporter.stepStatusMap[finished.testStepResult.status],
+                    start_time: null,
+                    end_time: null,
+                    duration: finished.testStepResult.duration.seconds,
+                },
+                attachments: [],
+                steps: [],
+                parent_id: null,
+            };
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * @returns {Promise<void>}
+     * @private
+     */
+    async publishResults() {
+        await this.reporter.publish();
+    }
+    /**
+     * @returns {Promise<void>}
+     * @private
+     */
+    startTestRun() {
+        this.reporter.startTestRun();
+    }
+}
+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 {Record<TestStepResultStatus, StepStatusEnum>}
+ */
+CucumberQaseReporter.stepStatusMap = {
+    [cucumber_1.Status.PASSED]: qase_javascript_commons_1.StepStatusEnum.passed,
+    [cucumber_1.Status.FAILED]: qase_javascript_commons_1.StepStatusEnum.failed,
+    [cucumber_1.Status.SKIPPED]: qase_javascript_commons_1.StepStatusEnum.blocked,
+    [cucumber_1.Status.AMBIGUOUS]: qase_javascript_commons_1.StepStatusEnum.blocked,
+    [cucumber_1.Status.PENDING]: qase_javascript_commons_1.StepStatusEnum.blocked,
+    [cucumber_1.Status.UNDEFINED]: qase_javascript_commons_1.StepStatusEnum.blocked,
+    [cucumber_1.Status.UNKNOWN]: qase_javascript_commons_1.StepStatusEnum.blocked,
+};
+/**
+ * @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.2",
   "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.8"
   },
   "peerDependencies": {
     "@cucumber/cucumber": ">=7.0.0"