qase-javascript-commons 2.5.0 → 2.5.2

package/changelog.md

@@ -1,3 +1,24 @@
+# qase-javascript-commons@2.5.2
+
+## What's new
+
+Aligned report output with the cross-language Qase Report specification:
+
+- Report file renamed from `report.json` to `run.json`, title changed to `"Test run"`.
+- Stats model: replaced `broken` field with `blocked` and `invalid`, fixed status enum mapping.
+- Result serialization: `testops_id` serializes as `testops_ids` (array), `group_params` as `param_groups` (array of arrays).
+- Step serialization: `data` field serializes as `input_data`, attachments moved to `execution.attachments`.
+- Gherkin-type steps automatically convert to TEXT format during serialization (`keyword + name` → `action`).
+- Attachment `size` and `content` fields excluded from serialized output.
+
+All changes are serialization-only — internal model interfaces are unchanged, no breaking changes for framework reporters.
+
+# qase-javascript-commons@2.5.1
+
+## What's new
+
+Fixed issue with incorrect test status determination.
+
 # qase-javascript-commons@2.5.0
 
 ## What's new

package/dist/models/stats.d.ts

@@ -2,7 +2,8 @@ export interface Stats {
     passed: number;
     failed: number;
     skipped: number;
-    broken: number;
+    blocked: number;
+    invalid: number;
     muted: number;
     total: number;
 }

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

@@ -41,4 +41,38 @@ export declare class ReportReporter extends AbstractReporter {
      * @returns {TestStepType[]}
      */
     private copyStepAttachments;
+    /**
+     * Serialize a test result to spec-compliant JSON format.
+     * Transforms internal model fields to match the Qase Report specification.
+     * @private
+     */
+    private serializeResultForReport;
+    /**
+     * Transform group_params Record to param_groups array of arrays.
+     * Same logic as clientV2.ts transformGroupParams.
+     * @private
+     */
+    private transformGroupParams;
+    /**
+     * Serialize attachment for report output (exclude size and content fields).
+     * @private
+     */
+    private serializeAttachment;
+    /**
+     * Serialize steps recursively, transforming:
+     * - data.data -> data.input_data (STEP-01)
+     * - attachments -> execution.attachments (STEP-02)
+     * @private
+     */
+    private serializeSteps;
+    /**
+     * Serialize a single step to spec-compliant format.
+     * @private
+     */
+    private serializeStep;
+    /**
+     * Serialize step data, transforming data.data -> data.input_data for text steps.
+     * @private
+     */
+    private serializeStepData;
 }

package/dist/reporters/report-reporter.js

@@ -76,12 +76,14 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
                     },
                 };
             }
-            await this.writer.writeTestResult(result);
+            // Serialize to spec-compliant format before writing
+            const serialized = this.serializeResultForReport(result);
+            await this.writer.writeTestResult(serialized);
         }
     }
     async complete() {
         const report = {
-            title: 'Test report',
+            title: 'Test run',
             execution: {
                 start_time: this.startTime,
                 end_time: Date.now(),
@@ -93,7 +95,8 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
                 passed: 0,
                 failed: 0,
                 skipped: 0,
-                broken: 0,
+                blocked: 0,
+                invalid: 0,
                 muted: 0,
             },
             results: [],
@@ -115,10 +118,10 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
                     report.stats.skipped++;
                     break;
                 case models_1.TestStatusEnum.invalid:
-                    report.stats.broken++;
+                    report.stats.invalid++;
                     break;
                 case models_1.TestStatusEnum.blocked:
-                    report.stats.muted++;
+                    report.stats.blocked++;
                     break;
             }
             report.execution.cumulative_duration += result.execution.duration ?? 0;
@@ -152,5 +155,128 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
         }
         return steps;
     }
+    /**
+     * Serialize a test result to spec-compliant JSON format.
+     * Transforms internal model fields to match the Qase Report specification.
+     * @private
+     */
+    serializeResultForReport(result) {
+        // Transform testops_id -> testops_ids (RSLT-01)
+        let testopsIds = null;
+        if (result.testops_id !== null) {
+            testopsIds = Array.isArray(result.testops_id)
+                ? result.testops_id
+                : [result.testops_id];
+        }
+        // Transform group_params -> param_groups (RSLT-02)
+        const paramGroups = this.transformGroupParams(result.group_params);
+        // Serialize attachments (exclude size and content fields)
+        const attachments = result.attachments.map(att => this.serializeAttachment(att));
+        // Serialize steps (handle data.data -> data.input_data and attachments -> execution.attachments)
+        const steps = this.serializeSteps(result.steps);
+        // Build spec-compliant result object
+        const serialized = {
+            id: result.id,
+            title: result.title,
+            signature: result.signature,
+            execution: result.execution,
+            fields: result.fields,
+            attachments: attachments,
+            steps: steps,
+            params: result.params,
+            param_groups: paramGroups,
+            testops_ids: testopsIds,
+            relations: result.relations,
+            muted: result.muted,
+            message: result.message,
+        };
+        // Internal-only fields are excluded: testops_id, group_params, run_id, author, testops_project_mapping, preparedAttachments
+        return serialized;
+    }
+    /**
+     * Transform group_params Record to param_groups array of arrays.
+     * Same logic as clientV2.ts transformGroupParams.
+     * @private
+     */
+    transformGroupParams(groupParams) {
+        const keys = Object.keys(groupParams);
+        if (keys.length === 0) {
+            return [];
+        }
+        return [keys];
+    }
+    /**
+     * Serialize attachment for report output (exclude size and content fields).
+     * @private
+     */
+    serializeAttachment(att) {
+        return {
+            id: att.id,
+            file_name: att.file_name,
+            mime_type: att.mime_type,
+            file_path: att.file_path,
+        };
+    }
+    /**
+     * Serialize steps recursively, transforming:
+     * - data.data -> data.input_data (STEP-01)
+     * - attachments -> execution.attachments (STEP-02)
+     * @private
+     */
+    serializeSteps(steps) {
+        return steps.map(step => this.serializeStep(step));
+    }
+    /**
+     * Serialize a single step to spec-compliant format.
+     * @private
+     */
+    serializeStep(step) {
+        // Transform step data (handle data.data -> data.input_data for text steps)
+        const data = this.serializeStepData(step);
+        // Serialize step attachments
+        const attachments = step.attachments.map(att => this.serializeAttachment(att));
+        // Move attachments into execution.attachments (STEP-02)
+        const execution = {
+            ...step.execution,
+            attachments: attachments,
+        };
+        // Recursively serialize nested steps
+        const nestedSteps = this.serializeSteps(step.steps);
+        return {
+            id: step.id,
+            step_type: step.step_type,
+            data: data,
+            parent_id: step.parent_id,
+            execution: execution,
+            steps: nestedSteps,
+            // Note: attachments field is NOT at top-level in serialized output
+        };
+    }
+    /**
+     * Serialize step data, transforming data.data -> data.input_data for text steps.
+     * @private
+     */
+    serializeStepData(step) {
+        const data = { ...step.data };
+        // For text steps, rename data.data to data.input_data (STEP-01)
+        if (step.step_type === models_1.StepType.TEXT && 'data' in data) {
+            const textData = data;
+            return {
+                action: textData.action,
+                expected_result: textData.expected_result,
+                input_data: textData.data, // Rename: data -> input_data
+            };
+        }
+        // For gherkin steps, convert to text format (STEP-03)
+        if (step.step_type === models_1.StepType.GHERKIN && 'keyword' in data && 'name' in data) {
+            const gherkinData = data;
+            return {
+                action: `${gherkinData.keyword} ${gherkinData.name}`,
+                expected_result: null,
+                input_data: null, // JS GherkinData has no data field
+            };
+        }
+        return data;
+    }
 }
 exports.ReportReporter = ReportReporter;

package/dist/utils/test-status-utils.js

@@ -14,7 +14,7 @@ function determineTestStatus(error, originalStatus) {
         return mapOriginalStatus(originalStatus);
     }
     // Check if it's an assertion error
-    if (isAssertionError(error)) {
+    if (isAssertionError(error, originalStatus)) {
         return test_execution_1.TestStatusEnum.failed;
     }
     // For all other errors, return invalid
@@ -23,16 +23,19 @@ function determineTestStatus(error, originalStatus) {
 /**
  * Checks if error is an assertion error
  * @param error - Error object
+ * @param originalStatus - Original test status from test runner
  * @returns boolean - true if assertion error
  */
-function isAssertionError(error) {
+function isAssertionError(error, originalStatus) {
     const errorMessage = error.message.toLowerCase();
     const errorStack = error.stack?.toLowerCase() || '';
+    const normalizedOriginalStatus = originalStatus.toLowerCase();
     // Common assertion error patterns
     const assertionPatterns = [
         'expect',
         'assert',
         'matcher',
+        'objectcontaining',
         'assertion',
         'expected',
         'actual',
@@ -77,6 +80,14 @@ function isAssertionError(error) {
     const nonAssertionPatternsWithoutTimeout = nonAssertionPatterns.filter(pattern => pattern !== 'timeout');
     const hasNonAssertionPattern = nonAssertionPatternsWithoutTimeout.some(pattern => errorMessage.includes(pattern) || errorStack.includes(pattern));
     if (hasNonAssertionPattern) {
+        const hasAssertionContext = assertionPatterns.some(pattern => errorMessage.includes(pattern) || errorStack.includes(pattern));
+        const isRunnerFailed = normalizedOriginalStatus === 'failed' || normalizedOriginalStatus === 'timedout' || normalizedOriginalStatus === 'interrupted';
+        const isSyntaxError = errorMessage.includes('syntaxerror') || errorStack.includes('syntaxerror');
+        // When runner reported failure and error has assertion context (expect, ObjectContaining, diff),
+        // treat as Failed. Exception: SyntaxError (e.g. "Unexpected token") contains "expected" as false positive.
+        if (isRunnerFailed && hasAssertionContext && !isSyntaxError) {
+            return true;
+        }
         return false;
     }
     // For timeout errors without expect, treat as invalid
@@ -99,6 +110,7 @@ function isAssertionError(error) {
  * @returns TestStatusEnum
  */
 function mapOriginalStatus(originalStatus) {
+    // Keys must be lowercase to match normalizedStatus (case-insensitive matching)
     const statusMap = {
         'passed': test_execution_1.TestStatusEnum.passed,
         'failed': test_execution_1.TestStatusEnum.failed,
@@ -107,10 +119,9 @@ function mapOriginalStatus(originalStatus) {
         'pending': test_execution_1.TestStatusEnum.skipped,
         'todo': test_execution_1.TestStatusEnum.disabled,
         'focused': test_execution_1.TestStatusEnum.passed,
-        'timedOut': test_execution_1.TestStatusEnum.failed,
+        'timedout': test_execution_1.TestStatusEnum.failed,
         'interrupted': test_execution_1.TestStatusEnum.failed,
     };
-    // Convert to lowercase for case-insensitive matching
     const normalizedStatus = originalStatus.toLowerCase();
     return statusMap[normalizedStatus] || test_execution_1.TestStatusEnum.skipped;
 }

package/dist/writer/fs-writer.js

@@ -103,7 +103,7 @@ class FsWriter {
         }
         catch (error) { /* ignore */
         }
-        const filePath = path.join(this.path, `report.${this.format}`);
+        const filePath = path.join(this.path, `run.${this.format}`);
         (0, fs_1.writeFileSync)(filePath, await this.formatter.format(results));
         return filePath;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -48,7 +48,7 @@
     "@types/minimatch": "^6.0.0",
     "@types/node": "^20.19.25",
     "@types/uuid": "^9.0.8",
-    "axios": "^1.13.2",
+    "axios": "^1.13.5",
     "jest": "^29.7.0",
     "ts-jest": "^29.4.5"
   }