cucumberjs-qase-reporter 0.2.5 → 0.2.8-alpha.1

package/README.md

@@ -1,17 +1,20 @@
-# [Qase TMS](https://qase.io) Cucumber JS Reporter
+> # Qase TMS Cucumber JS reporter
+>
+> Publish results simple and easy.
 
-[![License](https://lxgaming.github.io/badges/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
-
-## Installation
+## How to integrate
 
 ```
 npm install cucumberjs-qase-reporter
 ```
 
+## Example of usage
 
-## Usage
+The Cucumber JS reporter has the ability to auto-generate test cases
+and suites from your test data.
 
-Decorate your scenarios with Qase TMS case IDs in format `Q-<case id>` or `Q123`, also `q` can be in any case:
+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:
 
 ```gherkin
 Feature: Cucumber documentation
@@ -34,12 +37,45 @@ Feature: Cucumber documentation
         And I should see a "Dependencies" badge
 ```
 
-After that you can use `cucumberjs-qase-reporter` as formatter:
+You should also have an active item in the project settings at
+
+```
+https://app.qase.io/project/QASE_PROJECT_CODE/settings/options
+```
+
+options in the `Test Runs` block:
+
+```
+Auto create test cases
+```
+and
 
+```
+Allow submitting results in bulk
+```
+---
+To run tests and create a test run, execute the command (for example from folder examples):
 ```bash
-cucumber-js -f cucumberjs-qase-reporter features
+cucumber-js -f cucumberjs-qase-reporter --format-options='{\"qaseConfig\": \"./.qaserc\"}' features -r examples/zombie/support -r examples/zombie/steps
+```
+or
+```bash
+npm test
+```
+<p align="center">
+  <img width="65%" src="./examples/screenshots/screenshot.png">
+</p>
+
+A test run will be performed and available at:
+
+```
+https://app.qase.io/run/QASE_PROJECT_CODE
 ```
 
+<p align="center">
+  <img src="./examples/screenshots/demo.gif">
+</p>
+
 ## Configuration
 
 Qase reporter supports passing parameters using two ways:
@@ -47,6 +83,8 @@ using `.qaserc` file and using ENV variables.
 
 `.qaserc` parameters:
 - `enabled` - Enable reporter
+- `basePath` - URL Qase.io
+- `environmentId` - To execute with the sending of the envinroment information
 - `apiToken` - Token for API access, you can find more information
   [here](https://developers.qase.io/#authentication)
 - `projectCode` - Code of your project (can be extracted from main
@@ -58,27 +96,38 @@ using `.qaserc` file and using ENV variables.
     - `%DATE%`
 - `runDescription` - Set custom Run description, when new run is created
 - `logging` - Enabled debug logging from reporter or not
+- `rootSuiteTitle` - A parent suite for your autocreated tests
 
 Example configuration file:
 ```json
 {
-    "enabled": true,
-    "logging": true,
-    "apiToken": "a786b45e371e1097c4c78a3211e3a1d23018ceb9",
-    "projectCode": "PROJECTCODE",
-    "runName": "CucumberJS run %DATE%"
+  "enabled": true,
+  "logging": true,
+  "apiToken": "api_key",
+  "projectCode": "project_code",
+  "runName": "CucumberJS run %DATE%",
+  "environmentId": 1,
+  "basePath": "https://api.qase.io/v1"
 }
 ```
 
 Supported ENV variables:
 
 - `QASE_ENABLED` - Same as `enabled`
+- `QASE_API_BASE_URL` - Same as `basePath`
 - `QASE_API_TOKEN` - Same as `apiToken`
 - `QASE_PROJECT` - Same as `projectCode`
 - `QASE_RUN_ID` - Pass Run ID from ENV and override reporter options
 - `QASE_RUN_NAME` - Same as `runName`
 - `QASE_RUN_DESCRIPTION` - Same as `runDescription`
+- `QASE_ENVIRONMENT_ID` - Same as `environmentId`
 - `QASE_LOGGING` - Same as `logging`
+- `QASE_ROOT_SUITE_TITLE` - Same as `rootSuiteTitle`
+
+To run using ENV you have to execute:
+```bash
+cucumber-js -f cucumberjs-qase-reporter features
+```
 
 ## Setup with Protractor
 
@@ -105,3 +154,7 @@ exports.config = {
 ```
 
 **Do not forget to add .qaserc file!**
+
+<!-- references -->
+
+[auth]: https://developers.qase.io/#authentication

package/dist/index.d.ts

@@ -1,26 +1,36 @@
 import { Formatter } from '@cucumber/cucumber';
 import { IFormatterOptions } from '@cucumber/cucumber/lib/formatter';
 declare class QaseReporter extends Formatter {
-    private config;
+    private readonly config;
     private api;
     private enabled;
     private pickleInfo;
     private testCaseStarts;
     private testCaseStartedResult;
+    private testCaseStartedAttachment;
     private testCaseStartedErrors;
     private testCaseScenarioId;
     private pending;
     private results;
-    private shouldPublish;
+    private scenarios;
+    private uploadsInQueueCount;
     constructor(options: IFormatterOptions);
+    private waitUploads;
+    private upload;
+    private publishResults;
     private addErrorMessage;
     private _log;
     private checkProject;
     private createRun;
+    private createRunObject;
     private checkRun;
     private saveRunId;
     private logTestItem;
-    private publishCaseResult;
+    private addForSending;
+    private addKnownCasesForSending;
+    private addNewCasesForSending;
     private extractIds;
+    private createHeaders;
+    private getPackageVersion;
 }
 export = QaseReporter;

package/dist/index.js

@@ -2,25 +2,45 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+/* eslint-disable camelcase */
+/* eslint-disable max-len */
 /* eslint-disable no-console,no-underscore-dangle,@typescript-eslint/no-non-null-assertion */
-const models_1 = require("qaseio/dist/src/models");
+const src_1 = require("qaseio/dist/src");
+const form_data_1 = __importDefault(require("form-data"));
 const cucumber_1 = require("@cucumber/cucumber");
 const qaseio_1 = require("qaseio");
 const chalk_1 = __importDefault(require("chalk"));
+const crypto_1 = __importDefault(require("crypto"));
+const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const messages_1 = require("@cucumber/messages/dist/src/messages");
+const mime_types_1 = __importDefault(require("mime-types"));
 const moment_1 = __importDefault(require("moment"));
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 var Status = messages_1.io.cucumber.messages.TestStepFinished.TestStepResult.Status;
 const StatusMapping = {
-    [Status.PASSED]: models_1.ResultStatus.PASSED,
-    [Status.FAILED]: models_1.ResultStatus.FAILED,
-    [Status.SKIPPED]: models_1.ResultStatus.SKIPPED,
+    [Status.PASSED]: src_1.ResultCreateStatusEnum.PASSED,
+    [Status.FAILED]: src_1.ResultCreateStatusEnum.FAILED,
+    [Status.SKIPPED]: src_1.ResultCreateStatusEnum.SKIPPED,
     [Status.AMBIGUOUS]: null,
     [Status.PENDING]: null,
     [Status.UNDEFINED]: null,
     [Status.UNKNOWN]: null,
 };
+let customBoundary = '----------------------------';
+crypto_1.default.randomBytes(24).forEach((value) => {
+    customBoundary += Math.floor(value * 10).toString(16);
+});
+class CustomBoundaryFormData extends form_data_1.default {
+    constructor() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        super();
+    }
+    getBoundary() {
+        return customBoundary;
+    }
+}
 const loadJSON = (file) => {
     try {
         const data = fs_1.default.readFileSync(file, { encoding: 'utf8' });
@@ -42,12 +62,13 @@ const prepareConfig = (options = {}, configFile = '.qaserc') => {
     const config = Object.assign(loaded || {}, options);
     return {
         enabled: process.env.QASE_ENABLED === 'true' || config.enabled || false,
-        apiToken: process.env.QASE_API_TOKEN || config.apiToken,
+        basePath: process.env.QASE_API_BASE_URL || config.basePath,
+        apiToken: process.env.QASE_API_TOKEN || config.apiToken || '',
+        rootSuiteTitle: process.env.QASE_ROOT_SUITE_TITLE || config.rootSuiteTitle,
+        environmentId: Number.parseInt(process.env.QASE_ENVIRONMENT_ID, 10) || config.environmentId,
         projectCode: process.env.QASE_PROJECT || config.projectCode || '',
         runId: process.env.QASE_RUN_ID || config.runId || '',
-        runName: process.env.QASE_RUN_NAME ||
-            config.runName ||
-            'Automated Run %DATE%',
+        runName: process.env.QASE_RUN_NAME || config.runName || 'Automated Run %DATE%',
         runDescription: process.env.QASE_RUN_DESCRIPTION || config.runDescription,
         logging: process.env.QASE_LOGGING !== '' || config.logging,
     };
@@ -76,34 +97,49 @@ class QaseReporter extends cucumber_1.Formatter {
         this.pickleInfo = {};
         this.testCaseStarts = {};
         this.testCaseStartedResult = {};
+        this.testCaseStartedAttachment = {};
         this.testCaseStartedErrors = {};
         this.testCaseScenarioId = {};
         this.pending = [];
-        this.results = [];
-        this.shouldPublish = 0;
+        this.results = {};
+        this.scenarios = {};
+        this.uploadsInQueueCount = 0;
         this.config = prepareConfig(options.parsedArgvOptions, (_a = options.parsedArgvOptions) === null || _a === void 0 ? void 0 : _a.qaseConfig);
         this.enabled = verifyConfig(this.config);
-        this.api = new qaseio_1.QaseApi(this.config.apiToken);
+        this.api = new qaseio_1.QaseApi(this.config.apiToken, this.config.basePath, this.createHeaders(), CustomBoundaryFormData);
         if (!this.enabled) {
             return;
         }
         this.config.runName = prepareReportName(this.config);
         options.eventBroadcaster
             .on('envelope', (envelope) => {
-            var _a, _b;
-            if (envelope.pickle) {
+            var _a, _b, _c, _d;
+            if (envelope.gherkinDocument) {
+                (_b = (_a = envelope.gherkinDocument.feature) === null || _a === void 0 ? void 0 : _a.children) === null || _b === void 0 ? void 0 : _b.forEach((featureChild) => {
+                    var _a, _b, _c, _d, _e, _f, _g;
+                    if (((_b = (_a = envelope.gherkinDocument) === null || _a === void 0 ? void 0 : _a.feature) === null || _b === void 0 ? void 0 : _b.name) != null && ((_c = featureChild.scenario) === null || _c === void 0 ? void 0 : _c.id) !== undefined && ((_d = featureChild.scenario) === null || _d === void 0 ? void 0 : _d.id) !== null) {
+                        this.scenarios[(_e = featureChild.scenario) === null || _e === void 0 ? void 0 : _e.id] = (_g = (_f = envelope.gherkinDocument) === null || _f === void 0 ? void 0 : _f.feature) === null || _g === void 0 ? void 0 : _g.name;
+                    }
+                });
+            }
+            else if (envelope.pickle) {
                 this.pickleInfo[envelope.pickle.id] = {
-                    tags: this.extractIds(envelope.pickle.tags), name: envelope.pickle.name,
+                    caseIds: this.extractIds(envelope.pickle.tags),
+                    name: envelope.pickle.name,
+                    lastAstNodeId: envelope.pickle.astNodeIds ? envelope.pickle.astNodeIds[envelope.pickle.astNodeIds.length - 1] : null,
                 };
             }
+            else if (envelope.attachment) {
+                void this.upload(envelope.attachment);
+            }
             else if (envelope.testRunStarted) {
-                this.checkProject(this.config.projectCode, (prjExists) => {
+                void this.checkProject(this.config.projectCode, async (prjExists) => {
                     if (prjExists) {
                         this._log(chalk_1.default `{green Project ${this.config.projectCode} exists}`);
                         const willRun = Object.keys(this.pickleInfo).length !== 0;
                         if (this.config.runId && willRun) {
                             this.saveRunId(this.config.runId);
-                            this.checkRun(this.config.runId, (runExists) => {
+                            return this.checkRun(this.config.runId, (runExists) => {
                                 const run = this.config.runId;
                                 if (runExists) {
                                     this._log(chalk_1.default `{green Using run ${run} to publish test results}`);
@@ -114,17 +150,14 @@ class QaseReporter extends cucumber_1.Formatter {
                             });
                         }
                         else if (!this.config.runId && willRun) {
-                            this.createRun(this.config.runName, this.config.runDescription, (created) => {
+                            return this.createRun(this.config.runName, this.config.runDescription, (created) => {
+                                var _a;
                                 if (created) {
-                                    this.saveRunId(created.id);
-                                    this._log(
-                                    // eslint-disable-next-line max-len
-                                    chalk_1.default `{green Using run ${this.config.runId} to publish test results}`);
+                                    this.saveRunId((_a = created.result) === null || _a === void 0 ? void 0 : _a.id);
+                                    this._log(chalk_1.default `{green Using run ${this.config.runId} to publish test results}`);
                                 }
                                 else {
-                                    this._log(
-                                    // eslint-disable-next-line max-len
-                                    chalk_1.default `{red Could not create run in project ${this.config.projectCode}}`);
+                                    this._log(chalk_1.default `{red Could not create run in project ${this.config.projectCode}}`);
                                 }
                             });
                         }
@@ -138,22 +171,18 @@ class QaseReporter extends cucumber_1.Formatter {
                 });
             }
             else if (envelope.testRunFinished) {
-                if (this.results.length === 0 && this.shouldPublish === 0) {
+                if (Object.keys(this.results).length === 0) {
                     this._log('No testcases were matched. Ensure that your tests are declared correctly.');
+                    return;
                 }
-                if (envelope.testRunFinished.success) {
-                    this._log('Finished success');
-                }
-                else {
-                    this._log('Finished with errors');
-                }
+                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] = models_1.ResultStatus.PASSED;
+                this.testCaseStartedResult[envelope.testCaseStarted.id] = src_1.ResultCreateStatusEnum.PASSED;
             }
             else if (envelope.testStepFinished) {
                 const stepFin = envelope.testStepFinished;
@@ -162,15 +191,13 @@ class QaseReporter extends cucumber_1.Formatter {
                 const oldStatus = this.testCaseStartedResult[stepFin.testCaseStartedId];
                 const newStatus = StatusMapping[stepFin.testStepResult.status];
                 if (newStatus === null) {
-                    this._log(
-                    // eslint-disable-next-line max-len
-                    chalk_1.default `{redBright Unexpected finish status ${stepStatus} received for step ${stepMessage}}`);
+                    this._log(chalk_1.default `{redBright Unexpected finish status ${stepStatus} received for step ${stepMessage}}`);
                     return;
                 }
-                if (newStatus !== models_1.ResultStatus.PASSED) {
-                    this.addErrorMessage(stepFin.testCaseStartedId, (_a = stepFin.testStepResult) === null || _a === void 0 ? void 0 : _a.message);
+                if (newStatus !== src_1.ResultCreateStatusEnum.PASSED) {
+                    this.addErrorMessage(stepFin.testCaseStartedId, (_c = stepFin.testStepResult) === null || _c === void 0 ? void 0 : _c.message);
                     if (oldStatus) {
-                        if (oldStatus !== models_1.ResultStatus.FAILED && newStatus) {
+                        if (oldStatus !== src_1.ResultCreateStatusEnum.FAILED && newStatus) {
                             this.testCaseStartedResult[stepFin.testCaseStartedId] = newStatus;
                         }
                     }
@@ -190,18 +217,67 @@ class QaseReporter extends cucumber_1.Formatter {
                     name: info.name,
                     started: tcs,
                     finished: envelope.testCaseFinished,
-                    tags: info.tags,
-                    // eslint-disable-next-line max-len, @typescript-eslint/no-unnecessary-type-assertion
+                    caseIds: info.caseIds,
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
                     duration: Math.abs((envelope.testCaseFinished.timestamp.seconds - tcs.timestamp.seconds)),
-                    error: (_b = this.testCaseStartedErrors[tcs.id]) === null || _b === void 0 ? void 0 : _b.join('\n\n'),
+                    error: (_d = this.testCaseStartedErrors[tcs.id]) === null || _d === void 0 ? void 0 : _d.join('\n\n'),
+                    lastAstNodeId: info.lastAstNodeId,
                 };
-                this.publishCaseResult(test, status);
+                this.addForSending(test, status);
             }
             else if (envelope.parseError) {
                 console.log('Error:', envelope.parseError);
             }
         });
     }
+    async waitUploads() {
+        while (this.uploadsInQueueCount > 0) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    async upload(attachment) {
+        const randomString = crypto_1.default.randomBytes(20).toString('hex');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
+        const tmpFilePath = os_1.default.tmpdir().concat(randomString, '.', mime_types_1.default.extension(attachment.mediaType));
+        fs_1.default.writeFile(tmpFilePath, attachment.body, 'base64', (err) => {
+            if (err !== null) {
+                this._log(err.message);
+            }
+        });
+        this.uploadsInQueueCount++;
+        await this.api.attachments.uploadAttachment(this.config.projectCode, [fs_1.default.createReadStream(tmpFilePath)], {
+            headers: {
+                'Content-Type': 'multipart/form-data; boundary=' + customBoundary,
+            },
+        }).then((response) => {
+            var _a;
+            const fileHash = (_a = response.data.result) === null || _a === void 0 ? void 0 : _a[0].hash;
+            const caseAttachments = this.testCaseStartedAttachment[attachment.testCaseStartedId] || [];
+            caseAttachments.push(fileHash);
+            this.testCaseStartedAttachment[attachment.testCaseStartedId] = caseAttachments;
+            this.uploadsInQueueCount--;
+        }).catch((err) => {
+            this.log(`Error on uploading file ${err}`);
+            this.uploadsInQueueCount--;
+        });
+    }
+    async publishResults() {
+        await this.waitUploads();
+        const res = [];
+        Object.keys(this.results).forEach((testCaseStartedId) => {
+            var _a;
+            const result = this.results[testCaseStartedId];
+            result.attachments = (_a = this.testCaseStartedAttachment[testCaseStartedId]) !== null && _a !== void 0 ? _a : [];
+            res.push(result);
+        });
+        this.api.results.createResultBulk(this.config.projectCode, Number(this.config.runId), {
+            results: res,
+        }).then(() => {
+            this._log(chalk_1.default `{gray Results sent}`);
+        }).catch((err) => {
+            this._log(err);
+        });
+    }
     addErrorMessage(tcsid, error) {
         if (error) {
             if (tcsid in this.testCaseStartedErrors) {
@@ -217,34 +293,50 @@ class QaseReporter extends cucumber_1.Formatter {
             console.log(chalk_1.default `{bold {blue qase:}} ${message}`, ...optionalParams);
         }
     }
-    checkProject(projectCode, cb) {
-        this.api.projects.exists(projectCode)
-            .then(cb)
-            .catch((err) => {
+    async checkProject(projectCode, cb) {
+        var _a;
+        try {
+            const resp = await this.api.projects.getProject(projectCode);
+            await cb(Boolean((_a = resp.data.result) === null || _a === void 0 ? void 0 : _a.code));
+        }
+        catch (err) {
             this._log(err);
-        });
-    }
-    createRun(name, description, cb) {
-        this.api.runs.create(this.config.projectCode, new models_1.RunCreate(name || `Automated run ${new Date().toISOString()}`, [], 
-        // eslint-disable-next-line camelcase
-        { description: description || 'Cypress automated run', is_autotest: true }))
-            .then((res) => res.data)
-            .then(cb)
-            .catch((err) => {
-            this._log(`Error on creating run ${err}`);
-        });
+            this.enabled = false;
+        }
     }
-    checkRun(runId, cb) {
-        if (runId !== undefined) {
-            this.api.runs.exists(this.config.projectCode, runId)
-                .then(cb)
-                .catch((err) => {
-                this._log(`Error on checking run ${err}`);
+    async createRun(name, description, cb) {
+        try {
+            const runObject = this.createRunObject(name || `Automated run ${new Date().toISOString()}`, [], {
+                description: description || 'CucumberJS automated run',
+                environment_id: this.config.environmentId,
+                is_autotest: true,
             });
+            const res = await this.api.runs.createRun(this.config.projectCode, runObject);
+            cb(res.data);
         }
-        else {
+        catch (err) {
+            this._log(`Error on creating run ${err}`);
+            this.enabled = false;
+        }
+    }
+    createRunObject(name, cases, args) {
+        return Object.assign({ title: name, cases }, args);
+    }
+    async checkRun(runId, cb) {
+        if (runId === undefined) {
             cb(false);
+            return;
         }
+        return this.api.runs.getRun(this.config.projectCode, Number(runId))
+            .then((resp) => {
+            var _a, _b;
+            this._log(`Get run result on checking run ${(_a = resp.data.result) === null || _a === void 0 ? void 0 : _a.id}`);
+            cb(Boolean((_b = resp.data.result) === null || _b === void 0 ? void 0 : _b.id));
+        })
+            .catch((err) => {
+            this._log(`Error on checking run ${err}`);
+            this.enabled = false;
+        });
     }
     saveRunId(runId) {
         this.config.runId = runId;
@@ -263,50 +355,93 @@ class QaseReporter extends cucumber_1.Formatter {
             failed: chalk_1.default `{red Test ${name} ${status}}`,
             passed: chalk_1.default `{green Test ${name} ${status}}`,
             pending: chalk_1.default `{blueBright Test ${name} ${status}}`,
+            skipped: chalk_1.default `{bgGray Test ${name} ${status}}`,
         };
         if (status) {
             this._log(map[status]);
         }
     }
-    publishCaseResult(test, status) {
+    addForSending(test, status) {
         this.logTestItem(test.name, status);
-        const caseIds = test.tags;
-        caseIds.forEach((caseId) => {
-            this.shouldPublish++;
-            const publishTest = (runId) => {
-                if (caseId) {
-                    const add = caseIds.length > 1 ? chalk_1.default ` {white For case ${caseId}}` : '';
-                    this._log(chalk_1.default `{gray Start publishing: ${test.name}}${add}`);
-                    const result = new models_1.ResultCreate(parseInt(caseId, 10), status, {
-                        // eslint-disable-next-line camelcase
-                        time_ms: test.duration,
-                        stacktrace: test.error,
-                        comment: test.error ? test.error.split('\n')[0] : undefined,
-                    });
-                    this.api.results.create(this.config.projectCode, runId, result)
-                        .then((res) => {
-                        this.results.push({ test, result: res.data });
-                        this._log(chalk_1.default `{gray Result published: ${test.name} ${res.data.hash}}${add}`);
-                        this.shouldPublish--;
-                    })
-                        .catch((err) => {
-                        this._log(err);
-                        this.shouldPublish--;
-                    });
-                }
-            };
-            if (this.config.runId) {
-                publishTest(this.config.runId);
-            }
-            else {
-                this.pending.push(publishTest);
+        if (test.caseIds.length) {
+            this.addKnownCasesForSending(test, status);
+        }
+        else {
+            this.addNewCasesForSending(test, status);
+        }
+    }
+    addKnownCasesForSending(test, status) {
+        test.caseIds.forEach((caseId) => {
+            if (!caseId) {
+                return;
             }
+            const add = test.caseIds.length > 1 ? chalk_1.default ` {white For case ${caseId}}` : '';
+            this._log(chalk_1.default `{gray Added for publishing: ${test.name}}${add}`);
+            this.results[test.finished.testCaseStartedId] = {
+                status,
+                case_id: parseInt(caseId, 10),
+                time: test.duration,
+                stacktrace: test.error,
+                comment: test.error ? test.error.split('\n')[0] : undefined,
+            };
         });
     }
+    addNewCasesForSending(test, status) {
+        const suiteTitle = [test.lastAstNodeId ? this.scenarios[test.lastAstNodeId] : ''];
+        if (this.config.rootSuiteTitle) {
+            suiteTitle.unshift(this.config.rootSuiteTitle);
+        }
+        this._log(chalk_1.default `{gray Added for publishing: ${suiteTitle.join('/')}/${test.name}}`);
+        this.results[test.finished.testCaseStartedId] = {
+            case: {
+                title: test.name,
+                suite_title: suiteTitle.join('\t'),
+            },
+            status,
+            time: test.duration,
+            stacktrace: test.error,
+            comment: test.error ? test.error.split('\n')[0] : undefined,
+        };
+    }
     extractIds(tagsList) {
         const regex = /[Qq]-*(\d+)/;
         return tagsList.filter((tagInfo) => regex.test(tagInfo.name)).map((tagInfo) => regex.exec(tagInfo.name)[1]);
     }
+    createHeaders() {
+        const { version: nodeVersion } = process;
+        const npmVersion = child_process_1.execSync('npm -v', { encoding: 'utf8' }).replace(/['"\n]+/g, '');
+        const qaseapiVersion = this.getPackageVersion('qaseio');
+        const frameworkVersion = this.getPackageVersion('@cucumber/cucumber');
+        const reporterVersion = this.getPackageVersion('cucumberjs-qase-reporter');
+        const xPlatformHeader = `node=${nodeVersion};npm=${npmVersion};os=${os_1.default.platform()};arch=${os_1.default.arch()}`;
+        const xClientHeader = `cucumberjs=${frameworkVersion};qase-cucumberjs=${reporterVersion};qaseapi=${qaseapiVersion}`;
+        return {
+            'X-Client': xClientHeader,
+            'X-Platform': xPlatformHeader,
+        };
+    }
+    getPackageVersion(name) {
+        const UNDEFINED = 'undefined';
+        try {
+            const pathToPackageJson = require.resolve(`${name}/package.json`, { paths: [process.cwd()] });
+            if (pathToPackageJson) {
+                try {
+                    const packageString = fs_1.default.readFileSync(pathToPackageJson, { encoding: 'utf8' });
+                    if (packageString) {
+                        const packageObject = JSON.parse(packageString);
+                        return packageObject.version;
+                    }
+                    return UNDEFINED;
+                }
+                catch (error) {
+                    return UNDEFINED;
+                }
+            }
+        }
+        catch (error) {
+            return UNDEFINED;
+        }
+    }
 }
 module.exports = QaseReporter;
 //# sourceMappingURL=index.js.map