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

package/changelog.md

@@ -1,3 +1,25 @@
+# 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,4 +1,4 @@
-import { AbstractReporter, LoggerInterface } from './reporters';
+import { AbstractReporter } from './reporters';
 import { OptionsType } from './options';
 import { TestResultType } from './models';
 /**
@@ -36,9 +36,8 @@ export declare class QaseReporter extends AbstractReporter {
     private useFallback;
     /**
      * @param {OptionsType} options
-     * @param {LoggerInterface} logger
      */
-    constructor(options: OptionsType, logger?: LoggerInterface);
+    constructor(options: OptionsType);
     /**
      * @returns {Promise<void>}
      */
@@ -64,7 +63,6 @@ export declare class QaseReporter extends AbstractReporter {
      * @todo implement mode registry
      * @param {ModeEnum} mode
      * @param {OptionsType} options
-     * @param {LoggerInterface} logger
      * @returns {ReporterInterface}
      * @private
      */

package/dist/qase.js

@@ -66,12 +66,11 @@ class QaseReporter extends reporters_1.AbstractReporter {
     }
     /**
      * @param {OptionsType} options
-     * @param {LoggerInterface} logger
      */
-    constructor(options, logger) {
+    constructor(options) {
         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);
+        super({ debug: composedOptions.debug, captureLogs: composedOptions.captureLogs });
         /**
          * @type {boolean}
          * @private
@@ -82,17 +81,18 @@ class QaseReporter extends reporters_1.AbstractReporter {
          * @private
          */
         this.useFallback = false;
+        this.logger.logDebug(`Config: ${JSON.stringify(composedOptions)}`);
         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 +103,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 +112,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;
                 }
@@ -124,11 +124,12 @@ class QaseReporter extends reporters_1.AbstractReporter {
      */
     async startTestRun() {
         if (!this.disabled) {
+            this.logger.logDebug('Starting test run');
             try {
                 await 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;
@@ -137,7 +138,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
                     await 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;
                 }
             }
@@ -157,7 +158,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,7 +180,7 @@ 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;
         }
     }
@@ -188,6 +189,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
      */
     async publish() {
         if (!this.disabled) {
+            this.logger.logDebug('Publishing test run results');
             if (this.useFallback) {
                 await this.publishFallback();
             }
@@ -195,7 +197,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 +218,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,11 +226,10 @@ class QaseReporter extends reporters_1.AbstractReporter {
      * @todo implement mode registry
      * @param {ModeEnum} mode
      * @param {OptionsType} options
-     * @param {LoggerInterface} logger
      * @returns {ReporterInterface}
      * @private
      */
-    createReporter(mode, options, logger) {
+    createReporter(mode, options) {
         const { frameworkPackage, frameworkName, reporterName, environment, report = {}, testops = {}, ...commonOptions } = options;
         switch (mode) {
             case options_1.ModeEnum.testops: {
@@ -259,7 +260,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
                     batch,
                     debug: commonOptions.debug,
                     captureLogs: commonOptions.captureLogs,
-                }, apiClient, logger, typeof environment === 'number' ? environment : undefined);
+                }, apiClient, typeof environment === 'number' ? environment : undefined);
             }
             case options_1.ModeEnum.report: {
                 const localOptions = report.connections?.[writer_1.DriverEnum.local];
@@ -267,7 +268,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
                 return new reporters_1.ReportReporter({
                     debug: commonOptions.debug,
                     captureLogs: commonOptions.captureLogs,
-                }, writer, logger, typeof environment === 'number' ? environment.toString() : environment, testops.run?.id);
+                }, writer, typeof environment === 'number' ? environment.toString() : environment, testops.run?.id);
             }
             case options_1.ModeEnum.off:
                 throw new disabled_exception_1.DisabledException();
@@ -280,7 +281,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,8 +1,8 @@
 import { TestResultType } from '../models';
 export interface LoggerInterface {
     log(message: string): void;
-    group(): void;
-    groupEnd(): void;
+    logError(message: string, error?: unknown): void;
+    logDebug(message: string): void;
 }
 export interface ReporterOptionsType {
     debug?: boolean | undefined;
@@ -22,17 +22,16 @@ export interface ReporterInterface {
  * @implements ReporterInterface
  */
 export declare abstract class AbstractReporter implements ReporterInterface {
-    private logger;
     /**
      * @type {boolean | undefined}
      * @private
      */
-    private readonly debug;
+    private readonly captureLogs;
     /**
-     * @type {boolean | undefined}
+     * @type {LoggerInterface}
      * @private
      */
-    private readonly captureLogs;
+    protected readonly logger: LoggerInterface;
     /**
      * @type {TestResultType[]}
      * @protected
@@ -48,10 +47,9 @@ export declare abstract class AbstractReporter implements ReporterInterface {
     abstract startTestRun(): Promise<void>;
     /**
      * @param {ReporterOptionsType} options
-     * @param {LoggerInterface} logger
      * @protected
      */
-    protected constructor(options: ReporterOptionsType | undefined, logger?: LoggerInterface);
+    protected constructor(options: ReporterOptionsType | undefined);
     /**
      * @returns {TestResultType[]}
      */
@@ -68,32 +66,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,13 +1,8 @@
 "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");
+const logger_1 = require("../utils/logger");
 /**
  * @abstract
  * @class AbstractReporter
@@ -16,19 +11,17 @@ const uuid_1 = require("uuid");
 class AbstractReporter {
     /**
      * @param {ReporterOptionsType} options
-     * @param {LoggerInterface} logger
      * @protected
      */
-    constructor(options, logger = console) {
-        this.logger = logger;
+    constructor(options) {
         /**
          * @type {TestResultType[]}
          * @protected
          */
         this.results = [];
         const { debug, captureLogs } = options ?? {};
-        this.debug = debug;
         this.captureLogs = captureLogs;
+        this.logger = new logger_1.Logger({ debug });
     }
     /**
      * @returns {TestResultType[]}
@@ -47,6 +40,7 @@ class AbstractReporter {
      */
     // 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 +64,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/report-reporter.d.ts

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

package/dist/reporters/report-reporter.js

@@ -37,12 +37,11 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
     /**
      * @param {ReporterOptionsType} options
      * @param {WriterInterface} writer
-     * @param {LoggerInterface} logger
      * @param {string | undefined} environment
      * @param {number | undefined} runId
      */
-    constructor(options, writer, logger, environment, runId) {
-        super(options, logger);
+    constructor(options, writer, environment, runId) {
+        super(options);
         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,5 +1,5 @@
 import { QaseApiInterface, ResultStepStatus, TestStepResultCreateStatusEnum } from 'qaseio';
-import { AbstractReporter, LoggerInterface, ReporterOptionsType } from './abstract-reporter';
+import { AbstractReporter, ReporterOptionsType } from './abstract-reporter';
 import { StepStatusEnum, TestResultType, TestStatusEnum } from '../models';
 export type TestOpsRunType = {
     id?: number | undefined;
@@ -93,10 +93,9 @@ export declare class TestOpsReporter extends AbstractReporter {
     /**
      * @param {ReporterOptionsType & TestOpsOptionsType} options
      * @param {QaseApiInterface} api
-     * @param {LoggerInterface} logger
      * @param {number} environment
      */
-    constructor(options: ReporterOptionsType & TestOpsOptionsType, api: QaseApiInterface, logger?: LoggerInterface, environment?: number);
+    constructor(options: ReporterOptionsType & TestOpsOptionsType, api: QaseApiInterface, environment?: number);
     /**
      * @returns {Promise<void>}
      */

package/dist/reporters/testops-reporter.js

@@ -19,12 +19,11 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
     /**
      * @param {ReporterOptionsType & TestOpsOptionsType} options
      * @param {QaseApiInterface} api
-     * @param {LoggerInterface} logger
      * @param {number} environment
      */
-    constructor(options, api, logger, environment) {
+    constructor(options, api, environment) {
         const { project, uploadAttachments, run, ...restOptions } = options;
-        super(restOptions, logger);
+        super(restOptions);
         this.api = api;
         /**
          * @type {number}
@@ -72,15 +71,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 +112,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 +130,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
@@ -143,7 +146,7 @@ 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 model = {
             title: result.title,
             execution: this.getExecution(result.execution),
             testops_id: Array.isArray(result.testops_id) ? null : result.testops_id,
@@ -153,6 +156,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
@@ -183,6 +188,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;
     }
     /**
@@ -233,13 +239,23 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
             const attachmentHashes = await this.uploadAttachments(step.attachments);
             const resultStep = {
                 data: {
-                    action: step.data.action,
+                    action: '',
                     attachments: attachmentHashes,
                 },
                 execution: {
                     status: TestOpsReporter.stepStatusMap[step.execution.status],
                 },
             };
+            if (step.step_type === models_1.StepType.TEXT) {
+                if ('action' in step.data && resultStep.data != undefined) {
+                    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);
             }
@@ -258,9 +274,18 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
             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) {
+                    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);
             }
@@ -276,7 +301,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 +361,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,24 @@
+export declare class Logger {
+    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-beta.9",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",