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

package/README.md

@@ -1,50 +1,69 @@
-> # Qase TMS Cucumber JS reporter
->
-> Publish results simple and easy.
+# Qase TMS Cucumber JS reporter
 
-## How to integrate
+Publish results simple and easy.
 
+## How to install
+
+```sh
+npm install -D cucumberjs-qase-reporter
 ```
-npm install cucumberjs-qase-reporter
-```
 
-## Example of usage
+## Updating from v1
+
+To update a test project using cucumberjs-qase-reporter@v1 to version 2:
+
+1. Update reporter configuration in `qase.config.json` and/or environment variables —
+   see the [configuration reference](#configuration) below.
 
-The Cucumber JS reporter has the ability to auto-generate test cases
+## Getting started
+
+The Cucumber JS reporter can auto-generate test cases
 and suites from your test data.
+Test results of subsequent test runs will match the same test cases
+as long as their names and file paths don't change.
+
+You can also annotate the tests with the IDs of existing test cases
+from Qase.io before executing tests. It's a more reliable way to bind
+autotests to test cases, that persists when you rename, move, or
+parameterize your tests.
 
-But if necessary, you can independently register the ID of already
-existing test cases from TMS before the executing tests. You can decorate your scenarios with Qase TMS case IDs in format `Q-<case id>` or `Q123`, also `q` can be in any case:
+For example:
 
 ```gherkin
 Feature: Cucumber documentation
-    As a user of cucumber.js
-    I want to have documentation on cucumber
-    So I can write better applications
-
-    @sections @Q-2
-    Scenario: Usage documentation
-        Given I am on the cucumber.js GitHub repository
-        When I go to the README file
-        Then I should see a "Cool" section
-        When I go to the README file
-
-    @ignore @q4
-    Scenario: Status badges 2
-        Given I am on the cucumber.js GitHub repository
-        When I go to the README file
-        Then I should see a "Build Status" badge
-        And I should see a "Dependencies" badge
+  As a user of cucumber.js
+  I want to have documentation on cucumber
+  So I can write better applications
+
+  @QaseID=1
+  Scenario: Usage documentation
+    Given I am on the cucumber.js GitHub repository
+    When I go to the README file
+    Then I should see a "Cool" section
+
+  @QaseID=2
+  @QaseFields={'severity':'high'}
+  Scenario: Status badges 2
+    Given I am on the cucumber.js GitHub repository
+    When I go to the README file
+    Then I should see a "Build Status" badge
+    And I should see a "Dependencies" badge
 ```
----
-To run tests and create a test run, execute the command (for example from folder examples/cucumberjs):
+
+To execute Cucumber JS tests and report them to Qase.io, run the command:
+
 ```bash
-QASE_MODE=testops cucumber-js -f cucumberjs-qase-reporter:/dev/null features -r zombie/support -r zombie/steps --publish-quiet
+QASE_MODE=testops cucumber-js -f cucumberjs-qase-reporter features -r step_definitions --publish-quiet
 ```
+
 or
+
 ```bash
 npm test
 ```
+
+You can try it with the example project at [`examples/cucumberjs`](../examples/cucumberjs/).
+
 <p align="center">
   <img width="65%" src="./screenshots/screenshot.png">
 </p>
@@ -61,34 +80,28 @@ https://app.qase.io/run/QASE_PROJECT_CODE
 
 ## Configuration
 
-Qase reporter supports passing parameters using two ways:
-using `.qaserc`/`qase.config.json` file and using ENV variables.
-
-`.qaserc` parameters, (* - required):
-- `mode` - `testops`/`off` Enables reporter, default - `off`
-- `debug` - Enables debug logging, defaule - `false`
-- `environment` - To execute with the sending of the envinroment information
-- *`testops.api.token` - Token for API access, you can find more information
-  [here](https://developers.qase.io/#authentication)
-- *`testops.project` - Code of your project (can be extracted from main
-  page of your project: `https://app.qase.io/project/DEMOTR` -
-  `DEMOTR` is project code here)
-- `testops.run.id` - Pass Run ID
-- `testops.run.title` - Set custom Run name, when new run is created
-- `testops.run.description` - Set custom Run description, when new run is created
-- `testops.run.complete` - Whether the run should be completed
-
-Example configuration file:
+Qase Cucumber JS reporter can be configured in multiple ways:
+
+- using a separate config file `qase.config.json`,
+- using environment variables (they override the values from the configuration files).
+
+For a full list of configuration options, see
+the [Configuration reference](../qase-javascript-commons/README.md#configuration).
+
+Example `qase.config.json` file:
 
 ```json
 {
+  "mode": "testops",
   "debug": true,
-  "environment": 1,
   "testops": {
     "api": {
       "token": "api_key"
     },
-    "project": "project_code"
+    "project": "project_code",
+    "run": {
+      "complete": true
+    }
   }
 }
 ```
@@ -105,41 +118,17 @@ Supported ENV variables:
 - `QASE_TESTOPS_RUN_DESCRIPTION` - Same as `testops.run.description`
 
 To run using ENV you have to execute:
-```bash
-cucumber-js -f cucumberjs-qase-reporter features
-```
-
-## Setup with Protractor
 
-Due to different configurations of protractor and cucumber itself you should install a bit more libraries:
 ```bash
-npm install cucumberjs-qase-reporter @cucumber/cucumber @cucumber/messages
-```
-
-After that you will be able to use reporter like this (`protractor.conf.js`):
-```js
-exports.config = {
-  ...
-  cucumberOpts: {
-    require: [
-      './tests/e2e/specs/*.js',
-    ],  // require step definition files before executing features
-    tags: [],
-    'dry-run': false,
-    compiler: [],  
-    format: ["node_modules/cucumberjs-qase-reporter"],
-  },
-  ...
-}
+cucumber-js -f cucumberjs-qase-reporter features -r step_definitions --publish-quiet
 ```
 
-**Do not forget to add `.qaserc`/`qase.config.json` file!**
-
 ## Requirements
 
-We maintain the reporter on LTS versions of Node. You can find the current versions by following the [link](https://nodejs.org/en/about/releases/)
-<!-- references -->
+We maintain the reporter on [LTS versions of Node](https://nodejs.org/en/about/releases/).
 
 `@cucumber/cucumber >= 7.0.0`
 
+<!-- references -->
+
 [auth]: https://developers.qase.io/#authentication

package/changelog.md

@@ -0,0 +1,44 @@
+# qase-cucumberjs@2.0.0
+
+## What's new
+
+This is the first release in the 2.x series of the Cucumber JS reporter.
+It brings a new annotation syntax with field values,
+new and more flexible configs, uploading results in parallel with running tests,
+and other powerful features.
+
+This changelog entry will be updated soon.
+For more information about the new features and a guide for migration from v1, refer to the
+[reporter documentation](https://github.com/qase-tms/qase-javascript/tree/main/qase-cucumberjs#readme)
+
+# qase-cucumberjs@2.0.0-beta.3
+
+## What's new
+
+Added support new Qase tags.
+
+```diff
+-  @Q-1
++  @QaseID=2
++  @QaseTitle=Scenario_with_Qase_title_tag
++  @QaseFields={"description":"Description","severity":"high"}
+  Scenario: simple test
+```
+
+QaseID - is a unique identifier of the test case in the Qase TMS.
+QaseTitle - is a title of the test case in the Qase TMS.
+QaseFields - is a JSON object with additional fields for the test case in the Qase TMS.
+
+# qase-cucumberjs@2.0.0-beta.2
+
+## What's new
+
+Added support gherkin steps.
+Before this version, the reporter was not able to parse the steps from the feature files.
+Now, the reporter can parse the steps and send them to the Qase TMS.
+
+# qase-cucumberjs@2.0.0-beta.1
+
+## What's new
+
+First major beta release for the version 2 series of the Qase Cypress reporter.

package/dist/models.d.ts

@@ -0,0 +1,5 @@
+interface TestMetadata {
+    ids: number[];
+    fields: Record<string, string>;
+    title: string | null;
+}

package/dist/models.js

@@ -0,0 +1 @@
+"use strict";

package/dist/reporter.d.ts

@@ -1,6 +1,5 @@
-import { Formatter, IFormatterOptions, Status } from '@cucumber/cucumber';
-import { ConfigLoader, ConfigType, StepStatusEnum, TestStatusEnum } from 'qase-javascript-commons';
-type TestStepResultStatus = (typeof Status)[keyof typeof Status];
+import { Formatter, IFormatterOptions } from '@cucumber/cucumber';
+import { ConfigLoader, ConfigType } from 'qase-javascript-commons';
 export type CucumberQaseOptionsType = IFormatterOptions & {
     qase?: ConfigType;
 };
@@ -9,64 +8,11 @@ export type CucumberQaseOptionsType = IFormatterOptions & {
  * @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;
+    private storage;
     /**
      * @type {ReporterInterface}
      * @private
@@ -86,7 +32,6 @@ export declare class CucumberQaseReporter extends Formatter {
      * @private
      */
     private bindEventListeners;
-    private convertSteps;
     /**
      * @returns {Promise<void>}
      * @private
@@ -98,4 +43,3 @@ export declare class CucumberQaseReporter extends Formatter {
      */
     private startTestRun;
 }
-export {};

package/dist/reporter.js

@@ -3,25 +3,12 @@ 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");
+const storage_1 = require("./storage");
 /**
  * @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
@@ -30,46 +17,6 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
         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',
@@ -77,6 +24,7 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
             reporterName: 'cucumberjs-qase-reporter',
         });
         this.eventBroadcaster = formatterOptions.eventBroadcaster;
+        this.storage = new storage_1.Storage();
         this.bindEventListeners();
     }
     /**
@@ -85,29 +33,13 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
     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;
-                        }
-                    });
-                }
+                this.storage.addScenario(envelope.gherkinDocument);
             }
             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,
-                };
+                this.storage.addPickle(envelope.pickle);
             }
             else if (envelope.attachment) {
-                if (envelope.attachment.testCaseStartedId &&
-                    envelope.attachment.fileName) {
-                    this.attachments[envelope.attachment.testCaseStartedId] =
-                        envelope.attachment.fileName;
-                }
+                this.storage.addAttachment(envelope.attachment);
             }
             else if (envelope.testRunStarted) {
                 this.startTestRun();
@@ -116,131 +48,23 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
                 void this.publishResults();
             }
             else if (envelope.testCase) {
-                this.testCaseScenarioId[envelope.testCase.id] =
-                    envelope.testCase;
+                this.storage.addTestCase(envelope.testCase);
             }
             else if (envelope.testCaseStarted) {
-                this.testCaseStarts[envelope.testCaseStarted.id] =
-                    envelope.testCaseStarted;
-                this.testCaseStartedResult[envelope.testCaseStarted.id] =
-                    qase_javascript_commons_1.TestStatusEnum.passed;
+                this.storage.addTestCaseStarted(envelope.testCaseStarted);
             }
             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;
-                    }
-                }
+                this.storage.addTestCaseStep(envelope.testStepFinished);
             }
             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) {
+                const result = this.storage.convertTestCase(envelope.testCaseFinished);
+                if (!result) {
                     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],
-                });
+                void this.reporter.addTestResult(result);
             }
         });
     }
-    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
@@ -257,31 +81,3 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
     }
 }
 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/dist/storage.d.ts

@@ -0,0 +1,101 @@
+import { Attachment as Attach, GherkinDocument, Pickle, TestCaseFinished, TestCaseStarted, TestStepFinished } from '@cucumber/messages';
+import { StepStatusEnum, TestResultType, TestStatusEnum } from 'qase-javascript-commons';
+import { TestCase } from '@cucumber/messages/dist/esm/src/messages';
+import { Status } from '@cucumber/cucumber';
+type TestStepResultStatus = (typeof Status)[keyof typeof Status];
+export declare class Storage {
+    /**
+     * @type {Record<string, Pickle>}
+     * @private
+     */
+    private pickles;
+    /**
+     * @type {Record<string, TestCaseStarted>}
+     * @private
+     */
+    private testCaseStarts;
+    /**
+     * @type {Record<string, TestStepFinished>}
+     * @private
+     */
+    private testCaseSteps;
+    /**
+     * @type {Record<string, TestStatusEnum>}
+     * @private
+     */
+    private testCaseStartedResult;
+    /**
+     * @type {Record<string, string[]>}
+     * @private
+     */
+    private testCaseStartedErrors;
+    /**
+     * @type {Record<string, string>}
+     * @private
+     */
+    private testCases;
+    /**
+     * @type {Record<string, string>}
+     * @private
+     */
+    private scenarios;
+    /**
+     * @type {Record<string, string>}
+     * @private
+     */
+    private attachments;
+    /**
+     * Add pickle to storage
+     * @param {Pickle} pickle
+     */
+    addPickle(pickle: Pickle): void;
+    /**
+     * Add scenario to storage
+     * @param {GherkinDocument} document
+     */
+    addScenario(document: GherkinDocument): void;
+    /**
+     * Add attachment to storage
+     * @param {Attach} attachment
+     */
+    addAttachment(attachment: Attach): void;
+    /**
+     * Add test case to storage
+     * @param {TestCase} testCase
+     */
+    addTestCase(testCase: TestCase): void;
+    /**
+     * Get all test cases
+     * @param {TestCaseStarted} testCaseStarted
+     */
+    addTestCaseStarted(testCaseStarted: TestCaseStarted): void;
+    /**
+     * Add test case step to storage
+     * @param {TestStepFinished} testCaseStep
+     */
+    addTestCaseStep(testCaseStep: TestStepFinished): void;
+    /**
+     * Convert test case to test result
+     * @param {TestCaseFinished} testCase
+     * @returns {undefined | TestResultType}
+     */
+    convertTestCase(testCase: TestCaseFinished): undefined | TestResultType;
+    /**
+     * Convert test steps to test result steps
+     * @param {readonly PickleStep[]} steps
+     * @param {TestCase} testCase
+     * @returns {TestStepType[]}
+     * @private
+     */
+    private convertSteps;
+    /**
+     * @type {Record<TestStepResultStatus, TestStatusEnum>}
+     */
+    static statusMap: Record<TestStepResultStatus, TestStatusEnum>;
+    /**
+     * @type {Record<TestStepResultStatus, StepStatusEnum>}
+     */
+    static stepStatusMap: Record<TestStepResultStatus, StepStatusEnum>;
+    private parseTags;
+}
+export {};

package/dist/storage.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = void 0;
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+const cucumber_1 = require("@cucumber/cucumber");
+const qaseIdRegExp = /^@[Qq]-?(\d+)$/g;
+const newQaseIdRegExp = /^@[Qq]ase[Ii][Dd]=(\d+)$/g;
+const qaseTitleRegExp = /^@[Qq]ase[Tt]itle=(.+)$/g;
+const qaseFieldsRegExp = /^@[Qq]ase[Ff]ields:(.+?)=(.+)$/g;
+class Storage {
+    constructor() {
+        /**
+         * @type {Record<string, Pickle>}
+         * @private
+         */
+        this.pickles = {};
+        /**
+         * @type {Record<string, TestCaseStarted>}
+         * @private
+         */
+        this.testCaseStarts = {};
+        /**
+         * @type {Record<string, TestStepFinished>}
+         * @private
+         */
+        this.testCaseSteps = {};
+        /**
+         * @type {Record<string, TestStatusEnum>}
+         * @private
+         */
+        this.testCaseStartedResult = {};
+        /**
+         * @type {Record<string, string[]>}
+         * @private
+         */
+        this.testCaseStartedErrors = {};
+        /**
+         * @type {Record<string, string>}
+         * @private
+         */
+        this.testCases = {};
+        /**
+         * @type {Record<string, string>}
+         * @private
+         */
+        this.scenarios = {};
+        /**
+         * @type {Record<string, string>}
+         * @private
+         */
+        this.attachments = {};
+    }
+    /**
+     * Add pickle to storage
+     * @param {Pickle} pickle
+     */
+    addPickle(pickle) {
+        this.pickles[pickle.id] = pickle;
+    }
+    /**
+     * Add scenario to storage
+     * @param {GherkinDocument} document
+     */
+    addScenario(document) {
+        if (document.feature) {
+            const { children, name } = document.feature;
+            children.forEach(({ scenario }) => {
+                if (scenario) {
+                    this.scenarios[scenario.id] = name;
+                }
+            });
+        }
+    }
+    /**
+     * Add attachment to storage
+     * @param {Attach} attachment
+     */
+    addAttachment(attachment) {
+        if (attachment.testCaseStartedId && attachment.fileName) {
+            if (!this.attachments[attachment.testCaseStartedId]) {
+                this.attachments[attachment.testCaseStartedId] = [];
+            }
+            this.attachments[attachment.testCaseStartedId]?.push({
+                file_name: attachment.fileName,
+                mime_type: attachment.mediaType,
+                file_path: null,
+                content: attachment.body,
+                size: 0,
+                id: attachment.fileName,
+            });
+        }
+    }
+    /**
+     * Add test case to storage
+     * @param {TestCase} testCase
+     */
+    addTestCase(testCase) {
+        this.testCases[testCase.id] = testCase;
+    }
+    /**
+     * Get all test cases
+     * @param {TestCaseStarted} testCaseStarted
+     */
+    addTestCaseStarted(testCaseStarted) {
+        this.testCaseStarts[testCaseStarted.id] =
+            testCaseStarted;
+        this.testCaseStartedResult[testCaseStarted.id] =
+            qase_javascript_commons_1.TestStatusEnum.passed;
+    }
+    /**
+     * Add test case step to storage
+     * @param {TestStepFinished} testCaseStep
+     */
+    addTestCaseStep(testCaseStep) {
+        const oldStatus = this.testCaseStartedResult[testCaseStep.testCaseStartedId];
+        const newStatus = Storage.statusMap[testCaseStep.testStepResult.status];
+        this.testCaseSteps[testCaseStep.testStepId] = testCaseStep;
+        if (newStatus !== qase_javascript_commons_1.TestStatusEnum.passed) {
+            if (testCaseStep.testStepResult.message) {
+                if (!this.testCaseStartedErrors[testCaseStep.testCaseStartedId]) {
+                    this.testCaseStartedErrors[testCaseStep.testCaseStartedId] = [];
+                }
+                this.testCaseStartedErrors[testCaseStep.testCaseStartedId]?.push(testCaseStep.testStepResult.message);
+            }
+            if (oldStatus) {
+                if (oldStatus !== qase_javascript_commons_1.TestStatusEnum.failed) {
+                    this.testCaseStartedResult[testCaseStep.testCaseStartedId] = newStatus;
+                }
+            }
+            else {
+                this.testCaseStartedResult[testCaseStep.testCaseStartedId] = newStatus;
+            }
+        }
+    }
+    /**
+     * Convert test case to test result
+     * @param {TestCaseFinished} testCase
+     * @returns {undefined | TestResultType}
+     */
+    convertTestCase(testCase) {
+        const tcs = this.testCaseStarts[testCase.testCaseStartedId];
+        if (!tcs) {
+            return undefined;
+        }
+        const tc = this.testCases[tcs.testCaseId];
+        if (!tc) {
+            return undefined;
+        }
+        const pickle = this.pickles[tc.pickleId];
+        if (!pickle) {
+            return undefined;
+        }
+        let error;
+        if (this.testCaseStartedErrors[tcs.id]?.length) {
+            error = new Error(this.testCaseStartedErrors[tcs.id]?.join('\n\n'));
+        }
+        let relations = null;
+        const nodeId = pickle.astNodeIds[pickle.astNodeIds.length - 1];
+        if (nodeId != undefined && this.scenarios[nodeId] != undefined) {
+            relations = {
+                suite: {
+                    data: [
+                        {
+                            title: this.scenarios[nodeId] ?? '',
+                            public_id: null,
+                        },
+                    ],
+                },
+            };
+        }
+        const metadata = this.parseTags(pickle.tags);
+        return {
+            attachments: [],
+            author: null,
+            execution: {
+                status: this.testCaseStartedResult[testCase.testCaseStartedId] ?? qase_javascript_commons_1.TestStatusEnum.passed,
+                start_time: null,
+                end_time: null,
+                duration: Math.abs(testCase.timestamp.seconds - tcs.timestamp.seconds),
+                stacktrace: error?.stack ?? null,
+                thread: null,
+            },
+            fields: metadata.fields,
+            message: null,
+            muted: false,
+            params: {},
+            relations: relations,
+            run_id: null,
+            signature: '',
+            steps: this.convertSteps(pickle.steps, tc),
+            testops_id: metadata.ids.length > 0 ? metadata.ids : null,
+            id: tcs.id,
+            title: metadata.title ?? pickle.name,
+        };
+    }
+    /**
+     * Convert test steps to test result steps
+     * @param {readonly PickleStep[]} steps
+     * @param {TestCase} testCase
+     * @returns {TestStepType[]}
+     * @private
+     */
+    convertSteps(steps, testCase) {
+        const results = [];
+        for (const s of testCase.testSteps) {
+            const finished = this.testCaseSteps[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: Storage.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;
+    }
+    parseTags(tags) {
+        const metadata = {
+            ids: [],
+            fields: {},
+            title: null,
+        };
+        for (const tag of tags) {
+            if (qaseIdRegExp.test(tag.name)) {
+                metadata.ids.push(Number(tag.name.replace(/^@[Qq]-?/, '')));
+                continue;
+            }
+            if (newQaseIdRegExp.test(tag.name)) {
+                metadata.ids.push(Number(tag.name.replace(/^@[Qq]ase[Ii][Dd]=/, '')));
+                continue;
+            }
+            if (qaseTitleRegExp.test(tag.name)) {
+                metadata.title = tag.name.replace(/^@[Qq]ase[Tt]itle=/, '');
+                continue;
+            }
+            if (qaseFieldsRegExp.test(tag.name)) {
+                const value = tag.name.replace(/^@[Qq]ase[Ff]ields:/, '');
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    const record = JSON.parse(value);
+                    metadata.fields = { ...metadata.fields, ...record };
+                }
+                catch (e) {
+                    // do nothing
+                }
+            }
+        }
+        return metadata;
+    }
+}
+exports.Storage = Storage;
+/**
+ * @type {Record<TestStepResultStatus, TestStatusEnum>}
+ */
+Storage.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]: qase_javascript_commons_1.TestStatusEnum.failed,
+    [cucumber_1.Status.PENDING]: qase_javascript_commons_1.TestStatusEnum.skipped,
+    [cucumber_1.Status.UNDEFINED]: qase_javascript_commons_1.TestStatusEnum.skipped,
+    [cucumber_1.Status.UNKNOWN]: qase_javascript_commons_1.TestStatusEnum.skipped,
+};
+/**
+ * @type {Record<TestStepResultStatus, StepStatusEnum>}
+ */
+Storage.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.skipped,
+    [cucumber_1.Status.AMBIGUOUS]: qase_javascript_commons_1.StepStatusEnum.failed,
+    [cucumber_1.Status.PENDING]: qase_javascript_commons_1.StepStatusEnum.skipped,
+    [cucumber_1.Status.UNDEFINED]: qase_javascript_commons_1.StepStatusEnum.skipped,
+    [cucumber_1.Status.UNKNOWN]: qase_javascript_commons_1.StepStatusEnum.skipped,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cucumberjs-qase-reporter",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0",
   "description": "Qase TMS CucumberJS Reporter",
   "homepage": "https://github.com/qase-tms/qase-javascript",
   "main": "./dist/index.js",