newman-reporter-qase 2.0.1 → 2.0.3

package/README.md

@@ -23,11 +23,13 @@ Example:
 //qase: 10
 // Qase: 1, 2, 3
 // qase: 4 5 6 14
-pm.test('expect response be 200', function () {
-    pm.response.to.be.info
+pm.test('expect response be 200', function() {
+  pm.response.to.be.info
 })
 ```
+
 ### Execute rom CLI:
+
 ```
 QASE_MODE=testops newman run ./sample-collection.json -r qase
 ```
@@ -46,55 +48,40 @@ https://app.qase.io/run/QASE_PROJECT_CODE
   <img src="./screenshots/demo.gif">
 </p>
 
+You can find more information about using the reporter [here](./docs/usage.md).
+
 ## Configuration
 
-Qase reporter supports passing parameters using two ways:
-using `.qaserc`/`qase.config.json` file and using ENV variables.
-
-`.qaserc` parameters, (* - required):
-- `mode` - `testops`/`off` Enables reporter, default - `off`
-- `debug` - Enables debug logging, defaule - `false`
-- `environment` - To execute with the sending of the envinroment information 
-- *`testops.api.token` - Token for API access, you can find more information
-  [here](https://developers.qase.io/#authentication)
-- *`testops.project` - Code of your project (can be extracted from main
-  page of your project: `https://app.qase.io/project/DEMOTR` -
-  `DEMOTR` is project code here)
-- `testops.run.id` - Pass Run ID
-- `testops.run.title` - Set custom Run name, when new run is created
-- `testops.run.description` - Set custom Run description, when new run is created
-- `testops.run.complete` - Whether the run should be completed
-
-Example configuration file:
+Qase Newman reporter can be configured in multiple ways:
+
+- using a separate config file `qase.config.json`,
+- using environment variables (they override the values from the configuration files).
+
+For a full list of configuration options, see
+the [Configuration reference](../qase-javascript-commons/README.md#configuration).
+
+Example `qase.config.json` config:
 
 ```json
 {
   "mode": "testops",
   "debug": true,
-  "environment": 1,
   "testops": {
     "api": {
       "token": "api_key"
     },
-    "projectCode": "project_code"
+    "project": "project_code",
+    "run": {
+      "complete": true
+    }
   }
 }
 ```
 
-Supported ENV variables:
-
-- `QASE_MODE` - Same as `mode`
-- `QASE_DEBUG` - Same as `debug`
-- `QASE_ENVIRONMENT` - Same as `environment` 
-- `QASE_TESTOPS_API_TOKEN` - Same as `testops.api.token`
-- `QASE_TESTOPS_PROJECT` - Same as `testops.project`
-- `QASE_TESTOPS_RUN_ID` - Pass Run ID from ENV and override reporter option `testops.run.id`
-- `QASE_TESTOPS_RUN_TITLE` - Same as `testops.run.title`
-- `QASE_TESTOPS_RUN_DESCRIPTION` - Same as `testops.run.description`
-
 ## Requirements
 
-We maintain the reporter on LTS versions of Node. You can find the current versions by following the [link](https://nodejs.org/en/about/releases/)
+We maintain the reporter on LTS versions of Node. You can find the current versions by following
+the [link](https://nodejs.org/en/about/releases/)
 
 `newman >= 5.3.0`
 

package/changelog.md

@@ -1,3 +1,16 @@
+# qase-newman@2.0.3
+
+## What's new
+
+Added support parameters from data files in Newman on collection and folder levels.
+
+# qase-newman@2.0.2
+
+## What's new
+
+Added support parameters from data files in Newman.
+How to use parameters from data files in Newman, see [here](./docs/usage.md).
+
 # qase-newman@2.0.0
 
 ## What's new

package/dist/configSchema.d.ts

@@ -0,0 +1,4 @@
+import { JSONSchemaType } from 'ajv';
+import { FrameworkOptionsType } from 'qase-javascript-commons';
+import { ReporterOptionsType } from './options';
+export declare const configSchema: JSONSchemaType<FrameworkOptionsType<'newman', ReporterOptionsType>>;

package/dist/configSchema.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configSchema = void 0;
+exports.configSchema = {
+    type: 'object',
+    nullable: true,
+    properties: {
+        framework: {
+            type: 'object',
+            nullable: true,
+            properties: {
+                newman: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        autoCollectParams: {
+                            type: 'boolean',
+                            nullable: true,
+                        },
+                    },
+                },
+            },
+        },
+    },
+};

package/dist/options.d.ts

@@ -0,0 +1,3 @@
+export interface ReporterOptionsType {
+    autoCollectParams?: boolean;
+}

package/dist/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/reporter.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
+import { NewmanRunOptions } from 'newman';
 import { ConfigType, ConfigLoader } from 'qase-javascript-commons';
 export type NewmanQaseOptionsType = ConfigType;
 /**
@@ -10,15 +11,24 @@ export declare class NewmanQaseReporter {
      * @type {RegExp}
      */
     static qaseIdRegExp: RegExp;
+    /**
+     * @type {RegExp}
+     */
+    static qaseParamRegExp: RegExp;
     /**
      * @param {EventList} eventList
      * @returns {number[]}
      * @private
      */
     private static getCaseIds;
+    /**
+     * @param {Item} item
+     * @returns {string[]}
+     * @private
+     */
+    private static getParameters;
     /**
      * @param {PropertyBase<PropertyBaseDefinition>} item
-     * @param {string[]} titles
      * @returns {string[]}
      * @private
      */
@@ -38,13 +48,23 @@ export declare class NewmanQaseReporter {
      * @private
      */
     private timerMap;
+    /**
+     * @type {Record<string, string>[]}
+     * @private
+     */
+    private readonly parameters;
+    /**
+     * @type {boolean}
+     * @private
+     */
+    private autoCollectParams;
     /**
      * @param {EventEmitter} emitter
      * @param {NewmanQaseOptionsType} options
-     * @param {unknown} _
+     * @param {NewmanRunOptions} collectionOptions
      * @param {ConfigLoaderInterface} configLoader
      */
-    constructor(emitter: EventEmitter, options: NewmanQaseOptionsType, _: unknown, configLoader?: ConfigLoader<Partial<ConfigType> & Record<string, unknown>>);
+    constructor(emitter: EventEmitter, options: NewmanQaseOptionsType, collectionOptions: NewmanRunOptions, configLoader?: ConfigLoader<import("qase-javascript-commons").FrameworkOptionsType<"newman", import("./options").ReporterOptionsType>>);
     /**
      * @param {EventEmitter} runner
      * @private
@@ -61,4 +81,28 @@ export declare class NewmanQaseReporter {
      * @private
      */
     private getSignature;
+    /**
+     * @param {Item} item
+     * @param {number} iteration
+     * @returns {Record<string, string>}
+     * @private
+     */
+    private prepareParameters;
+    /**
+     * @param {any} iterationData
+     * @private
+     */
+    private getParameters;
+    /**
+     * @param {unknown} obj
+     * @param parentKey
+     * @returns {Record<string, string>}
+     * @private
+     */
+    private convertToRecord;
+    /**
+     * @param {unknown} obj
+     * @private
+     */
+    private isRecord;
 }

package/dist/reporter.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NewmanQaseReporter = void 0;
+const configSchema_1 = require("./configSchema");
 const semver_1 = __importDefault(require("semver"));
 const qase_javascript_commons_1 = require("qase-javascript-commons");
 /**
@@ -29,9 +30,32 @@ class NewmanQaseReporter {
         });
         return ids;
     }
+    /**
+     * @param {Item} item
+     * @returns {string[]}
+     * @private
+     */
+    static getParameters(item) {
+        const params = [];
+        item.events.each((event) => {
+            if (event.listen === 'test' && event.script.exec) {
+                event.script.exec.forEach((line) => {
+                    const match = line.match(NewmanQaseReporter.qaseParamRegExp);
+                    if (match) {
+                        const parameters = match[1]?.split(/\s*,\s*/) ?? [];
+                        params.push(...parameters);
+                    }
+                });
+            }
+        });
+        const parent = item.parent();
+        if (parent && 'events' in parent) {
+            params.push(...NewmanQaseReporter.getParameters(parent));
+        }
+        return params;
+    }
     /**
      * @param {PropertyBase<PropertyBaseDefinition>} item
-     * @param {string[]} titles
      * @returns {string[]}
      * @private
      */
@@ -49,10 +73,10 @@ class NewmanQaseReporter {
     /**
      * @param {EventEmitter} emitter
      * @param {NewmanQaseOptionsType} options
-     * @param {unknown} _
+     * @param {NewmanRunOptions} collectionOptions
      * @param {ConfigLoaderInterface} configLoader
      */
-    constructor(emitter, options, _, configLoader = new qase_javascript_commons_1.ConfigLoader()) {
+    constructor(emitter, options, collectionOptions, configLoader = new qase_javascript_commons_1.ConfigLoader(configSchema_1.configSchema)) {
         /**
          * @type {Map<string, TestResultType>}
          * @private
@@ -63,6 +87,11 @@ class NewmanQaseReporter {
          * @private
          */
         this.timerMap = new Map();
+        /**
+         * @type {Record<string, string>[]}
+         * @private
+         */
+        this.parameters = [];
         const config = configLoader.load();
         this.reporter = qase_javascript_commons_1.QaseReporter.getInstance({
             ...(0, qase_javascript_commons_1.composeOptions)(options, config),
@@ -70,6 +99,8 @@ class NewmanQaseReporter {
             frameworkName: 'newman',
             reporterName: 'newman-reporter-qase',
         });
+        this.autoCollectParams = config?.framework?.newman?.autoCollectParams ?? false;
+        this.parameters = this.getParameters(collectionOptions.iterationData);
         this.addRunnerListeners(emitter);
     }
     /**
@@ -143,6 +174,7 @@ class NewmanQaseReporter {
                     const now = Date.now();
                     pendingResult.execution.duration = now - timer;
                 }
+                pendingResult.params = this.prepareParameters(item, exec.cursor.iteration);
                 void this.reporter.addTestResult(pendingResult);
             }
         });
@@ -185,9 +217,83 @@ class NewmanQaseReporter {
         }
         return signature;
     }
+    /**
+     * @param {Item} item
+     * @param {number} iteration
+     * @returns {Record<string, string>}
+     * @private
+     */
+    prepareParameters(item, iteration) {
+        if (this.parameters.length === 0) {
+            return {};
+        }
+        const availableParameters = this.parameters[iteration] ?? {};
+        const params = NewmanQaseReporter.getParameters(item);
+        if (params.length === 0) {
+            if (this.autoCollectParams) {
+                return availableParameters;
+            }
+            return {};
+        }
+        return params.reduce((filteredParams, param) => {
+            const value = availableParameters[param.toLowerCase()];
+            if (value) {
+                filteredParams[param.toLowerCase()] = value;
+            }
+            return filteredParams;
+        }, {});
+    }
+    /**
+     * @param {any} iterationData
+     * @private
+     */
+    getParameters(iterationData) {
+        if (!iterationData) {
+            return [];
+        }
+        if (Array.isArray(iterationData) && iterationData.every(item => typeof item === 'object' && item !== null)) {
+            return iterationData.map((item) => this.convertToRecord(item));
+        }
+        return [];
+    }
+    /**
+     * @param {unknown} obj
+     * @param parentKey
+     * @returns {Record<string, string>}
+     * @private
+     */
+    convertToRecord(obj, parentKey = '') {
+        const record = {};
+        if (this.isRecord(obj)) {
+            for (const key in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    const value = obj[key];
+                    const newKey = parentKey ? `${parentKey}.${key}` : key;
+                    if (this.isRecord(value)) {
+                        Object.assign(record, this.convertToRecord(value, newKey));
+                    }
+                    else {
+                        record[newKey.toLowerCase()] = String(value);
+                    }
+                }
+            }
+        }
+        return record;
+    }
+    /**
+     * @param {unknown} obj
+     * @private
+     */
+    isRecord(obj) {
+        return typeof obj === 'object' && obj !== null;
+    }
 }
 exports.NewmanQaseReporter = NewmanQaseReporter;
 /**
  * @type {RegExp}
  */
 NewmanQaseReporter.qaseIdRegExp = /\/\/\s*?[qQ]ase:\s?((?:[\d]+[\s,]{0,})+)/;
+/**
+ * @type {RegExp}
+ */
+NewmanQaseReporter.qaseParamRegExp = /qase\.parameters:\s*([\w.]+(?:\s*,\s*[\w.]+)*)/i;

package/docs/usage.md

@@ -0,0 +1,140 @@
+# How to Use Parameters from Data Files in Newman
+
+Newman allows you to leverage parameters from data files to make your API tests more dynamic and efficient. By utilizing
+the `--data` or `-d` option when running a collection, you can feed your tests with various input sets. The data files
+can be formatted as either JSON or CSV.
+
+### Example Data File
+
+Consider the following `data.json` file, which contains user data structured as complex objects:
+
+```json
+[
+  {
+    "userid": 1,
+    "user": {
+      "name": "John",
+      "age": 30
+    }
+  },
+  {
+    "userid": 2,
+    "user": {
+      "name": "Jane",
+      "age": 25
+    }
+  }
+]
+```
+
+### Example Tests
+
+Below are example tests that utilize the data parameters defined in the data file:
+
+```javascript
+// qase.parameters: userId, user.name
+pm.test("Status code is 201", function() {
+  pm.response.to.have.status(201);
+});
+
+// qase.parameters: userId
+pm.test("Response has correct userId", function() {
+  var jsonData = pm.response.json();
+  pm.expect(jsonData.userId).to.eql(pm.iterationData.get("userid"));
+});
+
+pm.test("Response has correct name", function() {
+  var jsonData = pm.response.json();
+  pm.expect(jsonData.user.name).to.eql(pm.iterationData.get("user.name"));
+});
+```
+
+You also can specify parameters on collection or folder level. In this case, all tests in collection or folder will have
+these parameters. If test has own parameters, they will be merged with collection or folder parameters.
+
+```json
+{
+  "info": {
+    "_postman_id": "collection_id",
+    "name": "Collection Name",
+    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+  },
+  "item": [
+    {
+      "name": "Folder Name",
+      "item": [
+        {
+          "name": "Test Name",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "type": "text/javascript",
+                "exec": [
+                  "pm.test('Status code is 200', function () {",
+                  "    pm.response.to.have.status(200);",
+                  "})"
+                ]
+              }
+            }
+          ],
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "https://api.example.com",
+              "host": [
+                "api",
+                "example",
+                "com"
+              ]
+            }
+          },
+          "response": []
+        }
+      ],
+      "event": [
+        {
+          "listen": "test",
+          "script": {
+            "exec": [
+              "// qase.parameters: userId, user.name"
+            ],
+            "type": "text/javascript"
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+### Expected Behavior
+
+When you run the tests, the following behavior is expected:
+
+- In the **`Status code is 201`** test, both `userId` and `user.name` will be passed as parameters.
+- In the **`Response has correct userId`** test, only the `userId` parameter will be passed.
+- In the **`Response has correct name`** test, by default, test will not have any parameters passed. But you can enable
+  specific option in config file to pass all parameters from data file if test have not commented `qase.parameters`
+  line.
+
+  ```json
+  {
+    "debug": true,
+    "testops": {
+      "api": {
+        "token": "api_key"
+      },
+      "project": "project_code",
+      "run": {
+        "complete": true
+      }
+    },
+    "framework": {
+      "newman": {
+        "autoCollectParams": true
+      }   
+    }
+  }
+  ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newman-reporter-qase",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Qase TMS Newman Reporter",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -45,8 +45,9 @@
   "devDependencies": {
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.2",
-    "@types/newman": "^5.3.3",
+    "@types/newman": "^5.3.6",
     "@types/postman-collection": "^3.5.7",
+    "ajv": "^8.17.1",
     "jest": "^29.5.0",
     "postman-collection": "^4.1.7",
     "ts-jest": "^29.1.0"