qase-javascript-commons 2.0.0-beta.8 → 2.0.0

package/README.md

@@ -1,11 +1,25 @@
 # Qase JavaScript Commons
 
-This package contains common classes and functions for working with Qase TMS API.
+This module is an SDK for developing test reporters for Qase TMS.
+It's using `qaseio` as an API client, and all Qase reporters are, in turn,
+using this package.
+You should use it if you're developing your own test reporter for a special-purpose framework.
+
+To report results from tests using a popular framework or test runner,
+don't install this module directly and
+use the corresponding reporter module instead:
+
+* [CucumberJS](https://github.com/qase-tms/qase-javascript/tree/main/qase-cucumberjs#readme)
+* [Cypress](https://github.com/qase-tms/qase-javascript/tree/main/qase-cypress#readme)
+* [Jest](https://github.com/qase-tms/qase-javascript/tree/main/qase-jest#readme)
+* [Newman](https://github.com/qase-tms/qase-javascript/tree/main/qase-newman#readme)
+* [Playwright](https://github.com/qase-tms/qase-javascript/tree/main/qase-playwright#readme)
+* [TestCafe](https://github.com/qase-tms/qase-javascript/tree/main/qase-testcafe#readme)
 
 ## Installation
 
 ```bash
-npm install qase-javascript-commons@beta
+npm install qase-javascript-commons
 ```
 
 ## Configuration

package/changelog.md

@@ -1,3 +1,101 @@
+# qase-javascript-commons@2.0.0
+
+## What's new
+
+This is the first release version of the Qase JavaScript SDK.
+It is numbered `2.0.0` (and not `1.0.0`) to match the release series of 
+test reporters for Playwright, Cypress, Jest and other frameworks.
+
+### Annotating test with field data
+
+Tests can now be annotated with data for system and custom fields in Qase.
+This feature is already implemented in the Playwright reporter:
+
+```js
+test('Test with annotated fields', () => {
+    qase.id(1);
+    qase.fields({ 'severity': 'high', 'priority': 'medium' })
+    // ...
+});
+```
+
+### Parametrized tests
+
+Qase JavaScript SDK enables annotating tests with parameters, and passing parameter values to Qase.
+Parameterized tests can report to a single test case, but each parameter variation is registered as
+a standalone result, with its own run history.
+
+### Attachments from files and variables
+
+Reporters can now upload attachments of various data types to Qase,
+both from files and from variables.
+It enables flexible and meticulous logging, such as collecting full HTTP request data,
+including URL, headers, and payload.
+
+### Uploading results in flexible batches, asynchronously
+
+Test reporters can now upload results in batches, while tests are still running.
+It helps bring test results faster and enables acting on them long before the test run is complete.
+
+### Uniform configuration
+
+Qase JavaScript SDK brings configuration with config files and environment variables
+to a common standard, used with Qase reporters in all languages and frameworks.
+
+For details, see the Configuration section in the README.
+
+### Latest API
+
+Qase JavaScript SDK is using the latest Qase API client,
+employing the full power of the stable v1 API version,
+and enabling the use of experimental v2 API, tailored for uploading
+huge amounts of test results.
+
+# qase-javascript-commons@2.0.0-beta.12
+
+## What's new
+
+Fixed an issue when the result has empty step action. Now the reporter will mark such steps as "Unnamed step" and will
+log a warning message.
+
+# qase-javascript-commons@2.0.0-beta.11
+
+## What's new
+
+* The `useV2` option in the reporter's configuration will now enable using the experimental v2 API.
+  Before this fix, v1 API was used despite the configuration.
+
+* Attachments from test steps will now be uploaded to Qase.
+  Before this fix, the reporter uploaded only the attachments made outside of any step scope.
+
+# qase-javascript-commons@2.0.0-beta.10
+
+## What's new
+
+Fixed an issue when the results published before the test run creation.
+
+# qase-javascript-commons@2.0.0-beta.9
+
+## What's new
+
+Improved debug logging for better testing and reporting errors.
+
+-   Separate `logger` class for use in reporters, supporting logging to console and files.
+-   Extra debug logs in both reporter modes: TestOps and Local.
+
+Fixed an issue with duplicate test runs created when the testing framework
+(such as Cypress) uses more than one instance of the Qase reporter.
+Now reporter handles Qase test runs in the following way:
+
+1.  The first instance of the reporter creates a Qase test run and stores the run ID 
+    in the ENV variable `QASE_TESTOPS_RUN_ID`.
+2.  Other instances of the reporter read this variable and report test results 
+    to the existing test run.
+
+Nothing has changed in cases when there is a single instance of a reporter or
+when it is using a test run, created with other tools, such as with an API request
+or manually in the Qase app.
+
 # qase-javascript-commons@2.0.0-beta.8
 
 ## What's new

package/dist/models/index.d.ts

@@ -1,6 +1,6 @@
 export { type TestResultType, Relation, Suite, SuiteData } from './test-result';
 export { TestExecution, TestStatusEnum } from './test-execution';
-export { type TestStepType } from './test-step';
+export { type TestStepType, StepType } from './test-step';
 export { StepStatusEnum } from './step-execution';
 export { Attachment } from './attachment';
 export { Report } from './report';

package/dist/models/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StepStatusEnum = exports.TestStatusEnum = void 0;
+exports.StepStatusEnum = exports.StepType = exports.TestStatusEnum = void 0;
 var test_execution_1 = require("./test-execution");
 Object.defineProperty(exports, "TestStatusEnum", { enumerable: true, get: function () { return test_execution_1.TestStatusEnum; } });
+var test_step_1 = require("./test-step");
+Object.defineProperty(exports, "StepType", { enumerable: true, get: function () { return test_step_1.StepType; } });
 var step_execution_1 = require("./step-execution");
 Object.defineProperty(exports, "StepStatusEnum", { enumerable: true, get: function () { return step_execution_1.StepStatusEnum; } });

package/dist/models/step-data.d.ts

@@ -1,4 +1,9 @@
-export interface StepData {
+export interface StepTextData {
     action: string;
     expected_result: string | null;
 }
+export interface StepGherkinData {
+    keyword: string;
+    name: string;
+    line: number;
+}

package/dist/models/test-step.d.ts

@@ -1,10 +1,14 @@
-import { StepData } from './step-data';
+import { StepGherkinData, StepTextData } from './step-data';
 import { StepExecution } from './step-execution';
 import { Attachment } from './attachment';
+export declare enum StepType {
+    TEXT = "text",
+    GHERKIN = "gherkin"
+}
 export type TestStepType = {
     id: string;
-    step_type: string;
-    data: StepData;
+    step_type: StepType;
+    data: StepTextData | StepGherkinData;
     parent_id: string | null;
     execution: StepExecution;
     attachments: Attachment[];

package/dist/models/test-step.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepType = void 0;
+var StepType;
+(function (StepType) {
+    StepType["TEXT"] = "text";
+    StepType["GHERKIN"] = "gherkin";
+})(StepType || (exports.StepType = StepType = {}));

package/dist/qase.d.ts

@@ -1,11 +1,17 @@
-import { AbstractReporter, LoggerInterface } from './reporters';
 import { OptionsType } from './options';
 import { TestResultType } from './models';
+export interface ReporterInterface {
+    addTestResult(result: TestResultType): Promise<void>;
+    publish(): Promise<void>;
+    startTestRun(): void;
+    isCaptureLogs(): boolean;
+}
 /**
  * @class QaseReporter
  * @implements AbstractReporter
  */
-export declare class QaseReporter extends AbstractReporter {
+export declare class QaseReporter implements ReporterInterface {
+    private static instance;
     /**
      * @param {string} frameworkPackage
      * @param {string} frameworkName
@@ -15,15 +21,20 @@ export declare class QaseReporter extends AbstractReporter {
      */
     private static createHeaders;
     /**
-     * @type {ReporterInterface}
+     * @type {InternalReporterInterface}
      * @private
      */
     private readonly upstreamReporter?;
     /**
-     * @type {ReporterInterface}
+     * @type {InternalReporterInterface}
      * @private
      */
     private readonly fallbackReporter?;
+    /**
+     * @type {boolean | undefined}
+     * @private
+     */
+    private readonly captureLogs;
     /**
      * @type {boolean}
      * @private
@@ -34,15 +45,21 @@ export declare class QaseReporter extends AbstractReporter {
      * @private
      */
     private useFallback;
+    private readonly logger;
+    private startTestRunOperation?;
     /**
      * @param {OptionsType} options
-     * @param {LoggerInterface} logger
      */
-    constructor(options: OptionsType, logger?: LoggerInterface);
+    private constructor();
     /**
-     * @returns {Promise<void>}
+     * @returns {void}
+     */
+    startTestRun(): void;
+    /**
+     * @param {OptionsType} options
+     * @returns {QaseReporter}
      */
-    startTestRun(): Promise<void>;
+    static getInstance(options: OptionsType): QaseReporter;
     /**
      * @param {TestResultType} result
      */
@@ -52,6 +69,10 @@ export declare class QaseReporter extends AbstractReporter {
      * @private
      */
     private addTestResultToFallback;
+    /**
+     * @returns {boolean}
+     */
+    isCaptureLogs(): boolean;
     /**
      * @returns {Promise<void>}
      */
@@ -64,8 +85,7 @@ export declare class QaseReporter extends AbstractReporter {
      * @todo implement mode registry
      * @param {ModeEnum} mode
      * @param {OptionsType} options
-     * @param {LoggerInterface} logger
-     * @returns {ReporterInterface}
+     * @returns {InternalReporterInterface}
      * @private
      */
     private createReporter;

package/dist/qase.js

@@ -16,6 +16,7 @@ const writer_1 = require("./writer");
 const get_package_version_1 = require("./utils/get-package-version");
 const custom_boundary_1 = require("./utils/custom-boundary");
 const disabled_exception_1 = require("./utils/disabled-exception");
+const logger_1 = require("./utils/logger");
 /**
  * @type {Record<TestStatusEnum, (test: TestResultType) => string>}
  */
@@ -31,7 +32,7 @@ const resultLogMap = {
  * @class QaseReporter
  * @implements AbstractReporter
  */
-class QaseReporter extends reporters_1.AbstractReporter {
+class QaseReporter {
     /**
      * @param {string} frameworkPackage
      * @param {string} frameworkName
@@ -66,12 +67,8 @@ class QaseReporter extends reporters_1.AbstractReporter {
     }
     /**
      * @param {OptionsType} options
-     * @param {LoggerInterface} logger
      */
-    constructor(options, logger) {
-        const env = (0, env_1.envToConfig)((0, env_schema_1.default)({ schema: env_1.envValidationSchema }));
-        const composedOptions = (0, options_1.composeOptions)(options, env);
-        super({ debug: composedOptions.debug, captureLogs: composedOptions.captureLogs }, logger);
+    constructor(options) {
         /**
          * @type {boolean}
          * @private
@@ -82,17 +79,22 @@ class QaseReporter extends reporters_1.AbstractReporter {
          * @private
          */
         this.useFallback = false;
+        const env = (0, env_1.envToConfig)((0, env_schema_1.default)({ schema: env_1.envValidationSchema }));
+        const composedOptions = (0, options_1.composeOptions)(options, env);
+        this.logger = new logger_1.Logger({ debug: composedOptions.debug });
+        this.logger.logDebug(`Config: ${JSON.stringify(composedOptions)}`);
+        this.captureLogs = composedOptions.captureLogs;
         try {
             this.upstreamReporter = this.createReporter(
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            composedOptions.mode || options_1.ModeEnum.off, composedOptions, logger);
+            composedOptions.mode || options_1.ModeEnum.off, composedOptions);
         }
         catch (error) {
             if (error instanceof disabled_exception_1.DisabledException) {
                 this.disabled = true;
             }
             else {
-                this.logError('Unable to create upstream reporter:', error);
+                this.logger.logError('Unable to create upstream reporter:', error);
                 if (composedOptions.fallback != undefined) {
                     this.disabled = true;
                     return;
@@ -103,7 +105,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
         try {
             this.fallbackReporter = this.createReporter(
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            composedOptions.fallback || options_1.ModeEnum.off, composedOptions, logger);
+            composedOptions.fallback || options_1.ModeEnum.off, composedOptions);
         }
         catch (error) {
             if (error instanceof disabled_exception_1.DisabledException) {
@@ -112,7 +114,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
                 }
             }
             else {
-                this.logError('Unable to create fallback reporter:', error);
+                this.logger.logError('Unable to create fallback reporter:', error);
                 if (this.useFallback && this.upstreamReporter === undefined) {
                     this.disabled = true;
                 }
@@ -120,29 +122,40 @@ class QaseReporter extends reporters_1.AbstractReporter {
         }
     }
     /**
-     * @returns {Promise<void>}
+     * @returns {void}
      */
-    async startTestRun() {
+    startTestRun() {
         if (!this.disabled) {
+            this.logger.logDebug('Starting test run');
             try {
-                await this.upstreamReporter?.startTestRun();
+                this.startTestRunOperation = this.upstreamReporter?.startTestRun();
             }
             catch (error) {
-                this.logError('Unable to start test run in the upstream reporter: ', error);
+                this.logger.logError('Unable to start test run in the upstream reporter: ', error);
                 if (this.fallbackReporter == undefined) {
                     this.disabled = true;
                     return;
                 }
                 try {
-                    await this.fallbackReporter?.startTestRun();
+                    this.startTestRunOperation = this.fallbackReporter?.startTestRun();
                 }
                 catch (error) {
-                    this.logError('Unable to start test run in the fallback reporter: ', error);
+                    this.logger.logError('Unable to start test run in the fallback reporter: ', error);
                     this.disabled = true;
                 }
             }
         }
     }
+    /**
+     * @param {OptionsType} options
+     * @returns {QaseReporter}
+     */
+    static getInstance(options) {
+        if (!QaseReporter.instance) {
+            QaseReporter.instance = new QaseReporter(options);
+        }
+        return QaseReporter.instance;
+    }
     /**
      * @param {TestResultType} result
      */
@@ -157,7 +170,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
                 await this.upstreamReporter?.addTestResult(result);
             }
             catch (error) {
-                this.logError('Unable to add the result to the upstream reporter:', error);
+                this.logger.logError('Unable to add the result to the upstream reporter:', error);
                 if (this.fallbackReporter == undefined) {
                     this.disabled = true;
                     return;
@@ -179,15 +192,23 @@ class QaseReporter extends reporters_1.AbstractReporter {
             await this.fallbackReporter?.addTestResult(result);
         }
         catch (error) {
-            this.logError('Unable to add the result to the fallback reporter:', error);
+            this.logger.logError('Unable to add the result to the fallback reporter:', error);
             this.disabled = true;
         }
     }
+    /**
+     * @returns {boolean}
+     */
+    isCaptureLogs() {
+        return this.captureLogs ?? false;
+    }
     /**
      * @returns {Promise<void>}
      */
     async publish() {
         if (!this.disabled) {
+            await this.startTestRunOperation;
+            this.logger.logDebug('Publishing test run results');
             if (this.useFallback) {
                 await this.publishFallback();
             }
@@ -195,7 +216,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
                 await this.upstreamReporter?.publish();
             }
             catch (error) {
-                this.logError('Unable to publish the run results to the upstream reporter:', error);
+                this.logger.logError('Unable to publish the run results to the upstream reporter:', error);
                 if (this.fallbackReporter == undefined) {
                     this.disabled = true;
                     return;
@@ -216,7 +237,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
             await this.fallbackReporter?.publish();
         }
         catch (error) {
-            this.logError('Unable to publish the run results to the fallback reporter:', error);
+            this.logger.logError('Unable to publish the run results to the fallback reporter:', error);
             this.disabled = true;
         }
     }
@@ -224,15 +245,14 @@ class QaseReporter extends reporters_1.AbstractReporter {
      * @todo implement mode registry
      * @param {ModeEnum} mode
      * @param {OptionsType} options
-     * @param {LoggerInterface} logger
-     * @returns {ReporterInterface}
+     * @returns {InternalReporterInterface}
      * @private
      */
-    createReporter(mode, options, logger) {
-        const { frameworkPackage, frameworkName, reporterName, environment, report = {}, testops = {}, ...commonOptions } = options;
+    createReporter(mode, options) {
+        const { frameworkPackage, frameworkName, reporterName, environment, report = {}, testops = {}, } = options;
         switch (mode) {
             case options_1.ModeEnum.testops: {
-                const { api: { token, headers, ...api } = {}, project, run: { title, description, ...run } = {}, plan = {}, batch = {}, uploadAttachments, } = testops;
+                const { api: { token, headers, ...api } = {}, project, run: { title, description, ...run } = {}, plan = {}, batch = {}, useV2, uploadAttachments, } = testops;
                 if (!token) {
                     throw new Error(`Either "testops.api.token" parameter or "${env_1.EnvApiEnum.token}" environment variable is required in "testops" mode`);
                 }
@@ -247,7 +267,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
                     },
                     ...api,
                 }, custom_boundary_1.CustomBoundaryFormData);
-                return new reporters_1.TestOpsReporter({
+                return new reporters_1.TestOpsReporter(this.logger, {
                     project,
                     uploadAttachments,
                     run: {
@@ -257,17 +277,13 @@ class QaseReporter extends reporters_1.AbstractReporter {
                     },
                     plan,
                     batch,
-                    debug: commonOptions.debug,
-                    captureLogs: commonOptions.captureLogs,
-                }, apiClient, logger, typeof environment === 'number' ? environment : undefined);
+                    useV2,
+                }, apiClient, typeof environment === 'number' ? environment : undefined);
             }
             case options_1.ModeEnum.report: {
                 const localOptions = report.connections?.[writer_1.DriverEnum.local];
                 const writer = new writer_1.FsWriter(localOptions);
-                return new reporters_1.ReportReporter({
-                    debug: commonOptions.debug,
-                    captureLogs: commonOptions.captureLogs,
-                }, writer, logger, typeof environment === 'number' ? environment.toString() : environment, testops.run?.id);
+                return new reporters_1.ReportReporter(this.logger, writer, typeof environment === 'number' ? environment.toString() : environment, testops.run?.id);
             }
             case options_1.ModeEnum.off:
                 throw new disabled_exception_1.DisabledException();
@@ -280,7 +296,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
      * @private
      */
     logTestItem(test) {
-        this.log(resultLogMap[test.execution.status](test));
+        this.logger.log(resultLogMap[test.execution.status](test));
     }
 }
 exports.QaseReporter = QaseReporter;

package/dist/reporters/abstract-reporter.d.ts

@@ -1,38 +1,23 @@
 import { TestResultType } from '../models';
-export interface LoggerInterface {
-    log(message: string): void;
-    group(): void;
-    groupEnd(): void;
-}
-export interface ReporterOptionsType {
-    debug?: boolean | undefined;
-    captureLogs?: boolean | undefined;
-}
-export interface ReporterInterface {
+import { LoggerInterface } from '../utils/logger';
+export interface InternalReporterInterface {
     addTestResult(result: TestResultType): Promise<void>;
     publish(): Promise<void>;
     startTestRun(): Promise<void>;
     getTestResults(): TestResultType[];
     setTestResults(results: TestResultType[]): void;
-    isCaptureLogs(): boolean;
 }
 /**
  * @abstract
  * @class AbstractReporter
- * @implements ReporterInterface
+ * @implements InternalReporterInterface
  */
-export declare abstract class AbstractReporter implements ReporterInterface {
-    private logger;
-    /**
-     * @type {boolean | undefined}
-     * @private
-     */
-    private readonly debug;
+export declare abstract class AbstractReporter implements InternalReporterInterface {
     /**
-     * @type {boolean | undefined}
+     * @type {LoggerInterface}
      * @private
      */
-    private readonly captureLogs;
+    protected readonly logger: LoggerInterface;
     /**
      * @type {TestResultType[]}
      * @protected
@@ -47,19 +32,14 @@ export declare abstract class AbstractReporter implements ReporterInterface {
      */
     abstract startTestRun(): Promise<void>;
     /**
-     * @param {ReporterOptionsType} options
-     * @param {LoggerInterface} logger
      * @protected
+     * @param {LoggerInterface} logger
      */
-    protected constructor(options: ReporterOptionsType | undefined, logger?: LoggerInterface);
+    protected constructor(logger: LoggerInterface);
     /**
      * @returns {TestResultType[]}
      */
     getTestResults(): TestResultType[];
-    /**
-     * @returns {boolean}
-     */
-    isCaptureLogs(): boolean;
     /**
      * @param {TestResultType} result
      */
@@ -68,32 +48,4 @@ export declare abstract class AbstractReporter implements ReporterInterface {
      * @param {TestResultType[]} results
      */
     setTestResults(results: TestResultType[]): void;
-    /**
-     * @param {string} message
-     * @protected
-     */
-    protected log(message: string): void;
-    /**
-     * @param {string} message
-     * @param error
-     * @protected
-     */
-    protected logError(message: string, error?: unknown): void;
-    /**
-     * @param {string} message
-     * @param error
-     * @private
-     */
-    private doLogError;
-    /**
-     * @param {AxiosError} error
-     * @private
-     */
-    private logApiError;
-    /**
-     * @param errorFields
-     * @returns {string | undefined}
-     * @private
-     */
-    private formatErrorFields;
 }

package/dist/reporters/abstract-reporter.js

@@ -1,34 +1,24 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractReporter = void 0;
-const lodash_get_1 = __importDefault(require("lodash.get"));
-const qase_error_1 = require("../utils/qase-error");
-const is_axios_error_1 = require("../utils/is-axios-error");
 const uuid_1 = require("uuid");
 /**
  * @abstract
  * @class AbstractReporter
- * @implements ReporterInterface
+ * @implements InternalReporterInterface
  */
 class AbstractReporter {
     /**
-     * @param {ReporterOptionsType} options
-     * @param {LoggerInterface} logger
      * @protected
+     * @param {LoggerInterface} logger
      */
-    constructor(options, logger = console) {
-        this.logger = logger;
+    constructor(logger) {
         /**
          * @type {TestResultType[]}
          * @protected
          */
         this.results = [];
-        const { debug, captureLogs } = options ?? {};
-        this.debug = debug;
-        this.captureLogs = captureLogs;
+        this.logger = logger;
     }
     /**
      * @returns {TestResultType[]}
@@ -36,17 +26,12 @@ class AbstractReporter {
     getTestResults() {
         return this.results;
     }
-    /**
-     * @returns {boolean}
-     */
-    isCaptureLogs() {
-        return this.captureLogs ?? false;
-    }
     /**
      * @param {TestResultType} result
      */
     // eslint-disable-next-line @typescript-eslint/require-await
     async addTestResult(result) {
+        this.logger.logDebug(`Adding test result: ${JSON.stringify(result)}`);
         if (result.testops_id === null || !Array.isArray(result.testops_id)) {
             this.results.push(result);
             return;
@@ -70,79 +55,5 @@ class AbstractReporter {
     setTestResults(results) {
         this.results = results;
     }
-    /**
-     * @param {string} message
-     * @protected
-     */
-    log(message) {
-        if (this.debug) {
-            this.logger.log(`qase: ${message}`);
-        }
-    }
-    /**
-     * @param {string} message
-     * @param error
-     * @protected
-     */
-    logError(message, error) {
-        this.doLogError(`qase: ${message}`, error);
-    }
-    /**
-     * @param {string} message
-     * @param error
-     * @private
-     */
-    doLogError(message, error) {
-        this.logger.log(message);
-        this.logger.group();
-        if (error instanceof Error) {
-            if ((0, is_axios_error_1.isAxiosError)(error)) {
-                this.logApiError(error);
-            }
-            else if (error instanceof qase_error_1.QaseError && error.cause) {
-                this.doLogError('Caused by:', error.cause);
-            }
-            this.logger.log(`${error.stack || `${error.name}: ${error.message}`}`);
-        }
-        else {
-            this.logger.log(String(error));
-        }
-        this.logger.groupEnd();
-    }
-    /**
-     * @param {AxiosError} error
-     * @private
-     */
-    logApiError(error) {
-        const errorMessage = (0, lodash_get_1.default)(error, 'response.data.errorMessage')
-            ?? (0, lodash_get_1.default)(error, 'response.data.error')
-            ?? (0, lodash_get_1.default)(error, 'response.statusText')
-            ?? 'Unknown error';
-        const errorFields = this.formatErrorFields((0, lodash_get_1.default)(error, 'response.data.errorFields'));
-        this.logger.log(`Message: ${String(errorMessage)}`);
-        if (errorFields) {
-            this.logger.group();
-            this.logger.log(errorFields);
-            this.logger.groupEnd();
-        }
-    }
-    /**
-     * @param errorFields
-     * @returns {string | undefined}
-     * @private
-     */
-    formatErrorFields(errorFields) {
-        if (Array.isArray(errorFields)) {
-            return errorFields.reduce((acc, item) => {
-                const field = (0, lodash_get_1.default)(item, 'field');
-                const error = (0, lodash_get_1.default)(item, 'error');
-                if (field && error) {
-                    return acc + `${String(field)}: ${String(error)}\n`;
-                }
-                return acc;
-            }, '');
-        }
-        return undefined;
-    }
 }
 exports.AbstractReporter = AbstractReporter;

package/dist/reporters/index.d.ts

@@ -1,3 +1,3 @@
-export { AbstractReporter, type ReporterInterface, type ReporterOptionsType, type LoggerInterface, } from './abstract-reporter';
+export { AbstractReporter, type InternalReporterInterface, } from './abstract-reporter';
 export { ReportReporter } from './report-reporter';
 export { TestOpsReporter, type TestOpsOptionsType } from './testops-reporter';

package/dist/reporters/report-reporter.d.ts

@@ -1,5 +1,6 @@
-import { AbstractReporter, LoggerInterface, ReporterOptionsType } from './abstract-reporter';
+import { AbstractReporter } from './abstract-reporter';
 import { WriterInterface } from '../writer';
+import { LoggerInterface } from '../utils/logger';
 /**
  * @class ReportReporter
  * @extends AbstractReporter
@@ -10,13 +11,12 @@ export declare class ReportReporter extends AbstractReporter {
     private readonly runId;
     private startTime;
     /**
-     * @param {ReporterOptionsType} options
-     * @param {WriterInterface} writer
      * @param {LoggerInterface} logger
+     * @param {WriterInterface} writer
      * @param {string | undefined} environment
      * @param {number | undefined} runId
      */
-    constructor(options: ReporterOptionsType | undefined, writer: WriterInterface, logger?: LoggerInterface, environment?: string, runId?: number);
+    constructor(logger: LoggerInterface, writer: WriterInterface, environment?: string, runId?: number);
     /**
      * @returns {Promise<void>}
      */

package/dist/reporters/report-reporter.js

@@ -35,14 +35,13 @@ const process = __importStar(require("process"));
  */
 class ReportReporter extends abstract_reporter_1.AbstractReporter {
     /**
-     * @param {ReporterOptionsType} options
-     * @param {WriterInterface} writer
      * @param {LoggerInterface} logger
+     * @param {WriterInterface} writer
      * @param {string | undefined} environment
      * @param {number | undefined} runId
      */
-    constructor(options, writer, logger, environment, runId) {
-        super(options, logger);
+    constructor(logger, writer, environment, runId) {
+        super(logger);
         this.writer = writer;
         this.startTime = Date.now();
         this.environment = environment;
@@ -60,6 +59,7 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
      *
      */
     async publish() {
+        this.writer.clearPreviousResults();
         const report = {
             title: 'Test report',
             execution: {
@@ -120,7 +120,7 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
             await this.writer.writeTestResult(result);
         }
         const path = await this.writer.writeReport(report);
-        this.log(`Report saved to ${path}`);
+        this.logger.log(`Report saved to ${path}`);
     }
     /**
      * @param {TestStepType[]} steps

package/dist/reporters/testops-reporter.d.ts

@@ -1,6 +1,7 @@
 import { QaseApiInterface, ResultStepStatus, TestStepResultCreateStatusEnum } from 'qaseio';
-import { AbstractReporter, LoggerInterface, ReporterOptionsType } from './abstract-reporter';
+import { AbstractReporter } from './abstract-reporter';
 import { StepStatusEnum, TestResultType, TestStatusEnum } from '../models';
+import { LoggerInterface } from '../utils/logger';
 export type TestOpsRunType = {
     id?: number | undefined;
     title: string;
@@ -91,12 +92,12 @@ export declare class TestOpsReporter extends AbstractReporter {
      */
     private isTestRunReady;
     /**
+     * @param {LoggerInterface} logger
      * @param {ReporterOptionsType & TestOpsOptionsType} options
      * @param {QaseApiInterface} api
-     * @param {LoggerInterface} logger
      * @param {number} environment
      */
-    constructor(options: ReporterOptionsType & TestOpsOptionsType, api: QaseApiInterface, logger?: LoggerInterface, environment?: number);
+    constructor(logger: LoggerInterface, options: TestOpsOptionsType, api: QaseApiInterface, environment?: number);
     /**
      * @returns {Promise<void>}
      */
@@ -146,16 +147,19 @@ export declare class TestOpsReporter extends AbstractReporter {
     private getRelation;
     /**
      * @param {TestStepType[]} steps
+     * @param testTitle
      * @returns Promise<ResultStep[]>
      * @private
      */
     private transformSteps;
     /**
      * @param {TestStepType[]} steps
+     * @param testTitle
      * @returns Promise<TestStepResultCreate[]>
      * @private
      */
     private transformStepsV1;
+    private logEmptyStep;
     /**
      * @param {number} runId
      * @returns {Promise<void>}

package/dist/reporters/testops-reporter.js

@@ -17,14 +17,14 @@ const defaultChunkSize = 200;
  */
 class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
     /**
+     * @param {LoggerInterface} logger
      * @param {ReporterOptionsType & TestOpsOptionsType} options
      * @param {QaseApiInterface} api
-     * @param {LoggerInterface} logger
      * @param {number} environment
      */
-    constructor(options, api, logger, environment) {
-        const { project, uploadAttachments, run, ...restOptions } = options;
-        super(restOptions, logger);
+    constructor(logger, options, api, environment) {
+        const { project, uploadAttachments, run, } = options;
+        super(logger);
         this.api = api;
         /**
          * @type {number}
@@ -72,15 +72,19 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
      */
     async checkOrCreateTestRun() {
         if (this.run.id !== undefined) {
+            this.logger.logDebug('Check test run');
             await this.checkRun(this.run.id);
             this.isTestRunReady = true;
             return;
         }
+        this.logger.logDebug('Create test run');
         const { result } = await this.createRun(this.run.title, this.run.description, this.environment);
         if (!result?.id) {
             throw new Error('Cannot create run.');
         }
+        this.logger.logDebug(`Test run created: ${result.id}`);
         this.run.id = result.id;
+        process.env['QASE_TESTOPS_RUN_ID'] = String(result.id);
         this.isTestRunReady = true;
     }
     /**
@@ -109,14 +113,14 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
                 results: results,
             });
         }
-        this.log((0, chalk_1.default) `{green ${testResults.length} result(s) sent to Qase}`);
+        this.logger.logDebug(`Results sent to Qase: ${testResults.length}`);
     }
     /**
      * @returns {Promise<void>}
      */
     async publish() {
         if (this.results.length === 0) {
-            this.log((0, chalk_1.default) `{yellow No results to send to Qase}`);
+            this.logger.log((0, chalk_1.default) `{yellow No results to send to Qase}`);
             return;
         }
         if (this.firstIndex < this.results.length) {
@@ -127,13 +131,13 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         }
         try {
             await this.api.runs.completeRun(this.projectCode, this.run.id);
-            this.log((0, chalk_1.default) `{green Run ${this.run.id} completed}`);
+            this.logger.log((0, chalk_1.default) `{green Run ${this.run.id} completed}`);
         }
         catch (error) {
             throw new qase_error_1.QaseError('Error on completing run', { cause: error });
         }
         const runUrl = `${this.baseUrl}/run/${this.projectCode}/dashboard/${this.run.id}`;
-        this.log((0, chalk_1.default) `{blue Test run link: ${runUrl}}`);
+        this.logger.log((0, chalk_1.default) `{blue Test run link: ${runUrl}}`);
     }
     /**
      * @param {TestResultType} result
@@ -142,8 +146,8 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
      */
     async transformTestResult(result) {
         const attachments = await this.uploadAttachments(result.attachments);
-        const steps = await this.transformSteps(result.steps);
-        return {
+        const steps = await this.transformSteps(result.steps, result.title);
+        const model = {
             title: result.title,
             execution: this.getExecution(result.execution),
             testops_id: Array.isArray(result.testops_id) ? null : result.testops_id,
@@ -153,6 +157,8 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
             relations: this.getRelation(result.relations),
             message: result.message,
         };
+        this.logger.logDebug(`Transformed result: ${JSON.stringify(model)}`);
+        return model;
     }
     /**
      * @param {TestResultType} result
@@ -161,7 +167,7 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
      */
     async transformTestResultV1(result) {
         const attachments = await this.uploadAttachments(result.attachments);
-        const steps = await this.transformStepsV1(result.steps);
+        const steps = await this.transformStepsV1(result.steps, result.title);
         const resultCreate = {
             attachments: attachments,
             comment: result.message,
@@ -183,6 +189,7 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
             title: result.title,
             suite_title: result.relations?.suite ? result.relations?.suite?.data.map((suite) => suite.title).join('\t') : null,
         };
+        this.logger.logDebug(`Transformed result: ${JSON.stringify(resultCreate)}`);
         return resultCreate;
     }
     /**
@@ -224,24 +231,41 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
     }
     /**
      * @param {TestStepType[]} steps
+     * @param testTitle
      * @returns Promise<ResultStep[]>
      * @private
      */
-    async transformSteps(steps) {
+    async transformSteps(steps, testTitle) {
         const resultsSteps = [];
         for (const step of steps) {
             const attachmentHashes = await this.uploadAttachments(step.attachments);
             const resultStep = {
                 data: {
-                    action: step.data.action,
-                    attachments: attachmentHashes,
+                    action: '',
                 },
                 execution: {
                     status: TestOpsReporter.stepStatusMap[step.execution.status],
+                    attachments: attachmentHashes,
                 },
             };
+            if (step.step_type === models_1.StepType.TEXT) {
+                if ('action' in step.data && resultStep.data != undefined) {
+                    if (step.data.action === '') {
+                        this.logEmptyStep(testTitle);
+                        resultStep.data.action = 'Unnamed step';
+                    }
+                    else {
+                        resultStep.data.action = step.data.action;
+                    }
+                }
+            }
+            if (step.step_type === models_1.StepType.GHERKIN) {
+                if ('keyword' in step.data && resultStep.data != undefined) {
+                    resultStep.data.action = step.data.keyword;
+                }
+            }
             if (step.steps.length > 0) {
-                resultStep.steps = await this.transformSteps(step.steps);
+                resultStep.steps = await this.transformSteps(step.steps, testTitle);
             }
             resultsSteps.push(resultStep);
         }
@@ -249,25 +273,44 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
     }
     /**
      * @param {TestStepType[]} steps
+     * @param testTitle
      * @returns Promise<TestStepResultCreate[]>
      * @private
      */
-    async transformStepsV1(steps) {
+    async transformStepsV1(steps, testTitle) {
         const resultsSteps = [];
         for (const step of steps) {
             const attachmentHashes = await this.uploadAttachments(step.attachments);
             const resultStep = {
                 status: TestOpsReporter.stepStatusMapV1[step.execution.status],
-                action: step.data.action,
                 attachments: attachmentHashes,
             };
+            if (step.step_type === models_1.StepType.TEXT) {
+                if ('action' in step.data) {
+                    if (step.data.action === '') {
+                        this.logEmptyStep(testTitle);
+                        resultStep.action = 'Unnamed step';
+                    }
+                    else {
+                        resultStep.action = step.data.action;
+                    }
+                }
+            }
+            if (step.step_type === models_1.StepType.GHERKIN) {
+                if ('keyword' in step.data) {
+                    resultStep.action = step.data.keyword;
+                }
+            }
             if (step.steps.length > 0) {
-                resultStep.steps = await this.transformStepsV1(step.steps);
+                resultStep.steps = await this.transformStepsV1(step.steps, testTitle);
             }
             resultsSteps.push(resultStep);
         }
         return resultsSteps;
     }
+    logEmptyStep(testTitle) {
+        this.logger.log((0, chalk_1.default) `{magenta Test '${testTitle}' has empty action in step. The reporter will mark this step as unnamed step.}`);
+    }
     /**
      * @param {number} runId
      * @returns {Promise<void>}
@@ -276,7 +319,7 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
     async checkRun(runId) {
         try {
             const resp = await this.api.runs.getRun(this.projectCode, runId);
-            this.log(`Get run result on checking run "${String(resp.data.result?.id)}"`);
+            this.logger.log(`Get run result on checking run "${String(resp.data.result?.id)}"`);
         }
         catch (error) {
             throw new qase_error_1.QaseError('Error on checking run', { cause: error });
@@ -336,7 +379,7 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
                 }
             }
             catch (error) {
-                this.logError('Cannot upload attachment:', error);
+                this.logger.logError('Cannot upload attachment:', error);
             }
         }
         return acc;

package/dist/utils/logger.d.ts

@@ -0,0 +1,29 @@
+export interface LoggerInterface {
+    log(message: string): void;
+    logError(message: string, error?: unknown): void;
+    logDebug(message: string): void;
+}
+export declare class Logger implements LoggerInterface {
+    private readonly debug;
+    private readonly filePath;
+    constructor(options: {
+        debug?: boolean | undefined;
+        dir?: string;
+    });
+    log(message: string): void;
+    logError(message: string, error?: unknown): void;
+    logDebug(message: string): void;
+    private logToFile;
+    private doLogError;
+    /**
+     * @param {AxiosError} error
+     * @private
+     */
+    private logApiError;
+    /**
+     * @param errorFields
+     * @returns {string | undefined}
+     * @private
+     */
+    private formatErrorFields;
+}

package/dist/utils/logger.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const is_axios_error_1 = require("./is-axios-error");
+const qase_error_1 = require("./qase-error");
+const lodash_get_1 = __importDefault(require("lodash.get"));
+class Logger {
+    constructor(options) {
+        this.debug = options.debug;
+        const dir = options.dir ?? './logs';
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir);
+        }
+        this.filePath = path.join(dir, 'log.txt');
+    }
+    log(message) {
+        const logMessage = `[INFO] qase: ${message}`;
+        console.log(logMessage);
+        if (this.debug) {
+            this.logToFile(logMessage);
+        }
+    }
+    logError(message, error) {
+        const logMessage = `[ERROR] qase: ${this.doLogError(message, error)}`;
+        console.error(logMessage);
+        if (this.debug) {
+            this.logToFile(logMessage);
+        }
+    }
+    logDebug(message) {
+        if (this.debug) {
+            const logMessage = `[DEBUG] qase: ${message}`;
+            console.log(logMessage);
+            this.logToFile(logMessage);
+        }
+    }
+    logToFile(message) {
+        const formattedMessage = `[${new Date().toISOString()}] ${message}\n`;
+        fs.appendFileSync(this.filePath, formattedMessage);
+    }
+    doLogError(message, error) {
+        let logMessage = message;
+        if (error instanceof Error) {
+            if ((0, is_axios_error_1.isAxiosError)(error)) {
+                logMessage += this.logApiError(error);
+            }
+            else if (error instanceof qase_error_1.QaseError && error.cause) {
+                logMessage += this.doLogError('\n Caused by:', error.cause);
+            }
+            logMessage += `\n ${error.stack || `${error.name}: ${error.message}`}`;
+        }
+        else {
+            logMessage += `\n ${String(error)}`;
+        }
+        return logMessage;
+    }
+    /**
+     * @param {AxiosError} error
+     * @private
+     */
+    logApiError(error) {
+        let logMessage = '\n';
+        const errorMessage = (0, lodash_get_1.default)(error, 'response.data.errorMessage')
+            ?? (0, lodash_get_1.default)(error, 'response.data.error')
+            ?? (0, lodash_get_1.default)(error, 'response.statusText')
+            ?? 'Unknown error';
+        const errorFields = this.formatErrorFields((0, lodash_get_1.default)(error, 'response.data.errorFields'));
+        logMessage += `Message: ${String(errorMessage)}`;
+        if (errorFields) {
+            logMessage += `\n ${errorFields}`;
+        }
+        return logMessage;
+    }
+    /**
+     * @param errorFields
+     * @returns {string | undefined}
+     * @private
+     */
+    formatErrorFields(errorFields) {
+        if (Array.isArray(errorFields)) {
+            return errorFields.reduce((acc, item) => {
+                const field = (0, lodash_get_1.default)(item, 'field');
+                const error = (0, lodash_get_1.default)(item, 'error');
+                if (field && error) {
+                    return acc + `${String(field)}: ${String(error)}\n`;
+                }
+                return acc;
+            }, '');
+        }
+        return undefined;
+    }
+}
+exports.Logger = Logger;

package/dist/writer/fs-writer.d.ts

@@ -17,6 +17,10 @@ export declare class FsWriter implements WriterInterface {
      * @param {FsWriterOptionsType | undefined} options
      */
     constructor(options: FsWriterOptionsType | undefined);
+    /**
+     * @returns {void}
+     */
+    clearPreviousResults(): void;
     /**
      * @param {Attachment[]} attachments
      * @returns {Attachment[]}
@@ -32,4 +36,5 @@ export declare class FsWriter implements WriterInterface {
      * @param {TestResultType} result
      */
     writeTestResult(result: TestResultType): Promise<void>;
+    private deleteFolderRecursive;
 }

package/dist/writer/fs-writer.js

@@ -47,6 +47,12 @@ class FsWriter {
             this.formatter = new formatter_1.JsonpFormatter();
         }
     }
+    /**
+     * @returns {void}
+     */
+    clearPreviousResults() {
+        this.deleteFolderRecursive(this.path);
+    }
     /**
      * @param {Attachment[]} attachments
      * @returns {Attachment[]}
@@ -102,5 +108,19 @@ class FsWriter {
         const filePath = path.join(resultsPath, `${result.id}.${this.format}`);
         (0, fs_1.writeFileSync)(filePath, await this.formatter.format(result));
     }
+    deleteFolderRecursive(directoryPath) {
+        if ((0, fs_1.existsSync)(directoryPath)) {
+            (0, fs_1.readdirSync)(directoryPath).forEach((file) => {
+                const curPath = path.join(directoryPath, file);
+                if ((0, fs_1.lstatSync)(curPath).isDirectory()) { // recurse
+                    this.deleteFolderRecursive(curPath);
+                }
+                else { // delete file
+                    (0, fs_1.unlinkSync)(curPath);
+                }
+            });
+            (0, fs_1.rmdirSync)(directoryPath);
+        }
+    }
 }
 exports.FsWriter = FsWriter;

package/dist/writer/writer-interface.d.ts

@@ -3,4 +3,5 @@ export interface WriterInterface {
     writeReport(results: Report): Promise<string>;
     writeTestResult(result: TestResultType): Promise<void>;
     writeAttachment(attachments: Attachment[]): Attachment[];
+    clearPreviousResults(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.0.0-beta.8",
+  "version": "2.0.0",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -21,7 +21,7 @@
     "test": "jest --passWithNoTests",
     "clean": "rm -rf dist"
   },
-  "author": "Dimitri Harding <dharding@dimitriharding.com>",
+  "author": "Qase Team <dharding@dimitriharding.com>",
   "license": "Apache-2.0",
   "dependencies": {
     "ajv": "^8.12.0",
@@ -33,7 +33,7 @@
     "lodash.merge": "^4.6.2",
     "lodash.mergewith": "^4.6.2",
     "mime-types": "^2.1.33",
-    "qaseio": "^2.1.0-beta.1",
+    "qaseio": "^2.1.0",
     "strip-ansi": "^6.0.1",
     "uuid": "^9.0.0"
   },