chore: bump version to 2.1.7 and add support for QaseParameters and QaseGroupParameters

- Updated package version from 2.1.6 to 2.1.7 in package.json.
- Added support for QaseParameters and QaseGroupParameters tags in the storage logic.
- Enhanced test cases to validate the inclusion of parameters from these tags in test results.
- Updated changelog to reflect the new version and features.

These changes improve the functionality of the reporter by allowing users to specify parameters directly in their test tags.

Author: gibiw

qase-cucumberjs/changelog.md

@@ -1,3 +1,9 @@
+# [email protected]
+
+## What's new
+
+- Added support for QaseParameters and QaseGroupParameters tags.
+
 # [email protected]
 
 ## Bug fixes

qase-cucumberjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cucumberjs-qase-reporter",
-  "version": "2.1.6",
+  "version": "2.1.7",
   "description": "Qase TMS CucumberJS Reporter",
   "homepage": "https://github.com/qase-tms/qase-javascript",
   "main": "./dist/index.js",
@@ -40,7 +40,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@cucumber/messages": "^22.0.0",
-    "qase-javascript-commons": "~2.4.10"
+    "qase-javascript-commons": "~2.4.16"
   },
   "peerDependencies": {
     "@cucumber/cucumber": ">=7.0.0"

qase-cucumberjs/src/models.ts

@@ -3,6 +3,8 @@ export interface TestMetadata {
   fields: Record<string, string>;
   title: string | null;
   isIgnore: boolean;
+  parameters: Record<string, string>;
+  group_params: Record<string, string>;
 }
 
 export interface ScenarioData {

qase-cucumberjs/src/storage.ts

@@ -31,6 +31,8 @@ const qaseIdRegExp = /^@[Qq]-?(\d+)$/;
 const newQaseIdRegExp = /^@[Qq]ase[Ii][Dd]=(\d+(?:,\s*\d+)*)$/;
 const qaseTitleRegExp = /^@[Qq]ase[Tt]itle=(.+)$/;
 const qaseFieldsRegExp = /^@[Qq]ase[Ff]ields=(.+)$/;
+const qaseParametersRegExp = /^@[Qq]ase[Pp]arameters=(.+)$/;
+const qaseGroupParametersRegExp = /^@[Qq]ase[Gg]roup[Pp]arameters=(.+)$/;
 const qaseIgnoreRegExp = /^@[Qq]ase[Ii][Gg][Nn][Oo][Rr][Ee]$/;
 
 export class Storage {
@@ -278,6 +280,10 @@ export class Storage {
       }
     }
 
+    // Merge parameters from tags with parameters from Gherkin examples
+    // Parameters from tags take precedence over Gherkin examples
+    params = { ...params, ...metadata.parameters };
+
     const steps = this.convertSteps(pickle.steps, tc);
 
     return {
@@ -295,10 +301,10 @@ export class Storage {
       message: error?.message ?? null,
       muted: false,
       params: params,
-      group_params: {},
+      group_params: metadata.group_params,
       relations: relations,
       run_id: null,
-      signature: this.getSignature(pickle, metadata.ids),
+      signature: this.getSignature(pickle, metadata.ids, params),
       steps: steps,
       testops_id: metadata.ids.length > 0 ? metadata.ids : null,
       id: tcs.id,
@@ -386,6 +392,8 @@ export class Storage {
       fields: {},
       title: null,
       isIgnore: false,
+      parameters: {},
+      group_params: {},
     };
 
     for (const tag of tags) {
@@ -415,6 +423,28 @@ export class Storage {
         }
       }
 
+      if (qaseParametersRegExp.test(tag.name)) {
+        const value = tag.name.replace(/^@[Qq]ase[Pp]arameters=/, '');
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          const record: Record<string, string> = JSON.parse(value);
+          metadata.parameters = { ...metadata.parameters, ...record };
+        } catch (e) {
+          // do nothing
+        }
+      }
+
+      if (qaseGroupParametersRegExp.test(tag.name)) {
+        const value = tag.name.replace(/^@[Qq]ase[Gg]roup[Pp]arameters=/, '');
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          const record: Record<string, string> = JSON.parse(value);
+          metadata.group_params = { ...metadata.group_params, ...record };
+        } catch (e) {
+          // do nothing
+        }
+      }
+
       if (qaseIgnoreRegExp.test(tag.name)) {
         metadata.isIgnore = true;
       }
@@ -426,10 +456,11 @@ export class Storage {
   /**
    * @param {Pickle} pickle
    * @param {number[]} ids
+   * @param {Record<string, string>} parameters
    * @private
    */
-  private getSignature(pickle: Pickle, ids: number[]): string {
-    return generateSignature(ids, [...pickle.uri.split('/'), pickle.name], {});
+  private getSignature(pickle: Pickle, ids: number[], parameters: Record<string, string> = {}): string {
+    return generateSignature(ids, [...pickle.uri.split('/'), pickle.name], parameters);
   }
 
   private getError(testCaseId: string): CompoundError | undefined {

qase-cucumberjs/test/storage.test.ts

@@ -343,6 +343,185 @@ describe('Storage', () => {
       const result = storage.convertTestCase(testCaseFinished);
       expect(result).toBeUndefined();
     });
+
+    it('should include parameters from QaseParameters tag in test result', () => {
+      const pickle: Pickle = { 
+        id: 'pickle-1', 
+        name: 'Test Pickle',
+        language: 'en',
+        steps: [],
+        tags: [
+          { name: '@QaseParameters={"browser":"chrome","environment":"staging"}' },
+        ],
+        astNodeIds: [],
+        uri: 'test.feature'
+      };
+      storage.addPickle(pickle);
+
+      const testCase: TestCase = { 
+        id: 'case-1', 
+        testSteps: [],
+        pickleId: 'pickle-1'
+      };
+      storage.addTestCase(testCase);
+
+      const testCaseStarted: TestCaseStarted = { 
+        id: 'started-1', 
+        testCaseId: 'case-1',
+        timestamp: { seconds: 0, nanos: 0 },
+        attempt: 1
+      };
+      storage.addTestCaseStarted(testCaseStarted);
+
+      const testCaseFinished: TestCaseFinished = {
+        testCaseStartedId: 'started-1',
+        timestamp: { seconds: 1, nanos: 0 },
+        willBeRetried: false,
+      };
+
+      const result = storage.convertTestCase(testCaseFinished);
+
+      expect(result).toBeDefined();
+      if (result) {
+        expect(result.params).toEqual({ browser: 'chrome', environment: 'staging' });
+      }
+    });
+
+    it('should include group_params from QaseGroupParameters tag in test result', () => {
+      const pickle: Pickle = { 
+        id: 'pickle-1', 
+        name: 'Test Pickle',
+        language: 'en',
+        steps: [],
+        tags: [
+          { name: '@QaseGroupParameters={"test_group":"authentication","test_type":"smoke"}' },
+        ],
+        astNodeIds: [],
+        uri: 'test.feature'
+      };
+      storage.addPickle(pickle);
+
+      const testCase: TestCase = { 
+        id: 'case-1', 
+        testSteps: [],
+        pickleId: 'pickle-1'
+      };
+      storage.addTestCase(testCase);
+
+      const testCaseStarted: TestCaseStarted = { 
+        id: 'started-1', 
+        testCaseId: 'case-1',
+        timestamp: { seconds: 0, nanos: 0 },
+        attempt: 1
+      };
+      storage.addTestCaseStarted(testCaseStarted);
+
+      const testCaseFinished: TestCaseFinished = {
+        testCaseStartedId: 'started-1',
+        timestamp: { seconds: 1, nanos: 0 },
+        willBeRetried: false,
+      };
+
+      const result = storage.convertTestCase(testCaseFinished);
+
+      expect(result).toBeDefined();
+      if (result) {
+        expect(result.group_params).toEqual({ test_group: 'authentication', test_type: 'smoke' });
+      }
+    });
+
+    it('should merge parameters from tags with parameters from Gherkin examples', () => {
+      const document: GherkinDocument = {
+        uri: 'test.feature',
+        feature: {
+          location: { line: 1, column: 1 },
+          language: 'en',
+          keyword: 'Feature',
+          name: 'Test Feature',
+          description: '',
+          children: [
+            {
+              scenario: {
+                id: 'scenario-1',
+                location: { line: 2, column: 1 },
+                keyword: 'Scenario',
+                name: 'Test Scenario',
+                description: '',
+                steps: [],
+                tags: [],
+                examples: [
+                  {
+                    id: 'examples-1',
+                    location: { line: 3, column: 1 },
+                    keyword: 'Examples',
+                    name: '',
+                    description: '',
+                    tags: [],
+                    tableHeader: {
+                      id: 'header-1',
+                      location: { line: 4, column: 1 },
+                      cells: [{ location: { line: 4, column: 1 }, value: 'param1' }],
+                    },
+                    tableBody: [
+                      {
+                        id: 'row-1',
+                        location: { line: 5, column: 1 },
+                        cells: [{ location: { line: 5, column: 1 }, value: 'value1' }],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+          tags: [],
+        },
+        comments: [],
+      };
+      storage.addScenario(document);
+
+      const pickle: Pickle = { 
+        id: 'pickle-1', 
+        name: 'Test Pickle',
+        language: 'en',
+        steps: [],
+        tags: [
+          { name: '@QaseParameters={"param2":"value2"}' },
+        ],
+        astNodeIds: ['scenario-1', 'row-1'],
+        uri: 'test.feature'
+      };
+      storage.addPickle(pickle);
+
+      const testCase: TestCase = { 
+        id: 'case-1', 
+        testSteps: [],
+        pickleId: 'pickle-1'
+      };
+      storage.addTestCase(testCase);
+
+      const testCaseStarted: TestCaseStarted = { 
+        id: 'started-1', 
+        testCaseId: 'case-1',
+        timestamp: { seconds: 0, nanos: 0 },
+        attempt: 1
+      };
+      storage.addTestCaseStarted(testCaseStarted);
+
+      const testCaseFinished: TestCaseFinished = {
+        testCaseStartedId: 'started-1',
+        timestamp: { seconds: 1, nanos: 0 },
+        willBeRetried: false,
+      };
+
+      const result = storage.convertTestCase(testCaseFinished);
+
+      expect(result).toBeDefined();
+      if (result) {
+        // Parameters from tags should merge with parameters from Gherkin examples
+        expect(result.params).toEqual({ param1: 'value1', param2: 'value2' });
+      }
+    });
   });
 
   describe('private methods', () => {
@@ -382,6 +561,69 @@ describe('Storage', () => {
       expect(result.fields).toEqual({});
     });
 
+    it('should parse QaseParameters tag', () => {
+      const tags = [
+        { name: '@QaseParameters={"browser":"chrome","environment":"staging"}' },
+      ];
+
+      const result = (storage as any).parseTags(tags);
+
+      expect(result.parameters).toEqual({ browser: 'chrome', environment: 'staging' });
+    });
+
+    it('should parse QaseGroupParameters tag', () => {
+      const tags = [
+        { name: '@QaseGroupParameters={"test_group":"authentication","test_type":"smoke"}' },
+      ];
+
+      const result = (storage as any).parseTags(tags);
+
+      expect(result.group_params).toEqual({ test_group: 'authentication', test_type: 'smoke' });
+    });
+
+    it('should parse both QaseParameters and QaseGroupParameters', () => {
+      const tags = [
+        { name: '@QaseParameters={"browser":"chrome"}' },
+        { name: '@QaseGroupParameters={"test_group":"authentication"}' },
+      ];
+
+      const result = (storage as any).parseTags(tags);
+
+      expect(result.parameters).toEqual({ browser: 'chrome' });
+      expect(result.group_params).toEqual({ test_group: 'authentication' });
+    });
+
+    it('should handle invalid JSON in parameters', () => {
+      const tags = [
+        { name: '@QaseParameters=invalid json' },
+      ];
+
+      const result = (storage as any).parseTags(tags);
+
+      expect(result.parameters).toEqual({});
+    });
+
+    it('should handle invalid JSON in group parameters', () => {
+      const tags = [
+        { name: '@QaseGroupParameters=invalid json' },
+      ];
+
+      const result = (storage as any).parseTags(tags);
+
+      expect(result.group_params).toEqual({});
+    });
+
+    it('should merge multiple QaseParameters tags', () => {
+      const tags = [
+        { name: '@QaseParameters={"browser":"chrome"}' },
+        { name: '@QaseParameters={"environment":"staging"}' },
+      ];
+
+      const result = (storage as any).parseTags(tags);
+
+      expect(result.parameters).toEqual({ browser: 'chrome', environment: 'staging' });
+    });
+
     it('should get file name from media type', () => {
       expect((storage as any).getFileNameFromMediaType('text/plain')).toBe('file.txt');
       expect((storage as any).getFileNameFromMediaType('application/json')).toBe('file.json');