jest-qase-reporter 2.2.0 → 2.2.1

package/README.md

@@ -1,42 +1,109 @@
-# Qase TestOps Jest reporter
+# [Qase TestOps](https://qase.io) Jest Reporter
 
-Qase Jest reporter sends test results and metadata to Qase.io.
-It can work in different test automation scenarios:
+[![License](https://lxgaming.github.io/badges/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+[![npm downloads](https://img.shields.io/npm/dm/jest-qase-reporter.svg)](https://www.npmjs.com/package/jest-qase-reporter)
 
-* Create new test cases in Qase from existing autotests.
-* Report Jest test results to existing test cases in Qase.
+Qase Jest Reporter enables seamless integration between your Jest tests and [Qase TestOps](https://qase.io), providing automatic test result reporting, test case management, and comprehensive test analytics.
 
-Testing frameworks that use Jest as a test runner, such as Puppeteer, Appium, and Detox,
-can also be used with Jest reporter.
+## Features
 
-To install the latest version, run:
+- Link automated tests to Qase test cases by ID
+- Auto-create test cases from your test code
+- Report test results with rich metadata (fields, attachments, steps)
+- Support for parameterized tests
+- Multi-project reporting support
+- Flexible configuration (file, environment variables, Jest config)
+- Network Profiler for automatic HTTP request capture
 
-```shell
+## Installation
+
+```sh
 npm install --save-dev jest-qase-reporter
 ```
 
-# Contents
+## Quick Start
+
+**1. Create `qase.config.json` in your project root:**
+
+```json
+{
+  "mode": "testops",
+  "testops": {
+    "project": "YOUR_PROJECT_CODE",
+    "api": {
+      "token": "YOUR_API_TOKEN"
+    }
+  }
+}
+```
+
+**2. Add Qase ID to your test:**
+
+```javascript
+const { qase } = require('jest-qase-reporter/jest');
 
-<!-- START doctoc generated TOC please keep comment here to allow auto update -->
-<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+describe('User Authentication', () => {
+  test(qase(1, 'User can login with valid credentials'), () => {
+    expect(true).toBe(true);
+  });
+});
+```
 
-- [Getting started](#getting-started)
-- [Using Reporter](#using-reporter)
-- [Configuration](#configuration)
-- [Requirements](#requirements)
+**3. Run your tests:**
 
-<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+```sh
+npx jest
+```
 
-## Getting started
+## Configuration
 
-To report your tests results to Qase, install `jest-qase-reporter`,
-and add a reporter config in the `jest.config.ts` file.
-A minimal configuration needs just two things:
+The reporter is configured via (in order of priority):
+
+1. **jest.config.js** (Jest-specific, highest priority)
+2. **Environment variables** (`QASE_*`)
+3. **Config file** (`qase.config.json`)
+
+### Minimal Configuration
+
+| Option | Environment Variable | Description |
+|--------|---------------------|-------------|
+| `mode` | `QASE_MODE` | Set to `testops` to enable reporting |
+| `testops.project` | `QASE_TESTOPS_PROJECT` | Your Qase project code |
+| `testops.api.token` | `QASE_TESTOPS_API_TOKEN` | Your Qase API token |
+
+### Example `qase.config.json`
+
+```json
+{
+  "mode": "testops",
+  "fallback": "report",
+  "testops": {
+    "project": "YOUR_PROJECT_CODE",
+    "api": {
+      "token": "YOUR_API_TOKEN"
+    },
+    "run": {
+      "title": "Jest Automated Run"
+    },
+    "batch": {
+      "size": 100
+    }
+  },
+  "report": {
+    "driver": "local",
+    "connection": {
+      "local": {
+        "path": "./build/qase-report",
+        "format": "json"
+      }
+    }
+  }
+}
+```
 
-* Qase project code, for example, in https://app.qase.io/project/DEMO the code is `DEMO`.
-* Qase API token, created on the [Apps page](https://app.qase.io/apps?app=jest-reporter).
+### Example `jest.config.js`
 
-```js
+```javascript
 module.exports = {
   reporters: [
     'default',
@@ -46,9 +113,12 @@ module.exports = {
         mode: 'testops',
         testops: {
           api: {
-            token: 'api_token'
+            token: process.env.QASE_API_TOKEN,
+          },
+          project: 'YOUR_PROJECT_CODE',
+          run: {
+            complete: true,
           },
-          project: 'project_code',
         },
       },
     ],
@@ -56,152 +126,135 @@ module.exports = {
 };
 ```
 
-Now, run the Jest tests as usual.
-Test results will be reported to a new test run in Qase.
-
-```console
-$ npx jest
-Determining test suites to run...
-...
-qase: Project DEMO exists
-qase: Using run 42 to publish test results
-...
-
-Ran all test suites.
-```
-
-## Using Reporter
-
-The Jest reporter has the ability to auto-generate test cases
-and suites from your test data.
+> **Full configuration reference:** See [qase-javascript-commons](../qase-javascript-commons/README.md) for all available options including logging, status mapping, execution plans, and more.
 
-But if necessary, you can independently register the ID of already
-existing test cases from TMS before the executing tests. For example:
+## Usage
 
-### Metadata
+### Link Tests with Test Cases
 
-- `qase.title` - set the title of the test case
-- `qase.fields` - set the fields of the test case
-- `qase.suite` - set the suite of the test case
-- `qase.comment` - set the comment of the test case
-- `qase.parameters` - set the parameters of the test case
-- `qase.groupParameters` - set the group parameters of the test case
-- `qase.ignore` - ignore the test case in Qase. The test will be executed, but the results will not be sent to Qase.
-- `qase.step` - create a step in the test case
-- `qase.attach` - attach a file to the test case
+Associate your tests with Qase test cases using test case IDs:
 
-```typescript
+```javascript
 const { qase } = require('jest-qase-reporter/jest');
 
-describe('My First Test', () => {
-  test(qase([1, 2], 'Several ids'), () => {
+describe('Test suite', () => {
+  // Single test case ID
+  test(qase(1, 'Test name'), () => {
     expect(true).toBe(true);
   });
 
-  test(qase(3, 'Correct test'), () => {
-    qase.title('Title');
+  // Multiple test case IDs
+  test(qase([1, 2, 3], 'Test covering multiple cases'), () => {
     expect(true).toBe(true);
   });
+});
+```
 
-  test.skip(qase('4', 'Skipped test'), () => {
-    expect(true).toBe(true);
-  });
+### Add Metadata
+
+Enhance your tests with additional information:
+
+```javascript
+const { qase } = require('jest-qase-reporter/jest');
 
-  test(qase(['5', '6'], 'Failed test'), () => {
-    expect(true).toBe(false);
+test(qase(1, 'Test with metadata'), () => {
+  qase.title('User can successfully login');
+  qase.fields({
+    severity: 'critical',
+    priority: 'high',
+    layer: 'api',
   });
+  qase.suite('Authentication / Login');
+
+  // Test logic
+  expect(true).toBe(true);
 });
 ```
 
-To run tests and create a test run, execute the command (for example from folder examples):
+### Ignore Tests
 
-```bash
-QASE_MODE=testops npx jest --runInBand
-```
+Exclude specific tests from Qase reporting (test still runs, but results are not sent):
 
-or
+```javascript
+const { qase } = require('jest-qase-reporter/jest');
 
-```bash
-npm test
+test('This test runs but is not reported to Qase', () => {
+  qase.ignore();
+  expect(true).toBe(true);
+});
 ```
 
-<p align="center">
-  <img width="65%" src="./screenshots/screenshot.png">
-</p>
+### Test Result Statuses
 
-A test run will be performed and available at:
+| Jest Result | Qase Status |
+|-------------|-------------|
+| passed      | passed      |
+| failed      | failed      |
+| skipped     | skipped     |
 
-```
-https://app.qase.io/run/QASE_PROJECT_CODE
-```
+> For more usage examples, see the [Usage Guide](docs/usage.md).
 
-### Multi-Project Support
+## Running Tests
 
-Qase Jest Reporter supports sending test results to multiple Qase projects simultaneously. You can specify different test case IDs for each project using `qase.projects(mapping, name)`.
+```bash
+# Run all tests with Qase reporting
+QASE_MODE=testops npx jest
 
-For detailed information, configuration, and examples, see the [Multi-Project Support Guide](docs/MULTI_PROJECT.md).
+# Run specific test file
+QASE_MODE=testops npx jest path/to/test.spec.js
 
-## Configuration
+# Run tests matching pattern
+QASE_MODE=testops npx jest --testPathPattern="auth"
 
-Reporter options (* - required):
+# Run with custom test run title
+QASE_MODE=testops QASE_TESTOPS_RUN_TITLE="Nightly Regression" npx jest
+```
 
-- `mode` - `testops`/`off` Enables reporter, default - `off`
-- `debug` - Enables debug logging, default - `false`
-- `environment` - To execute with the sending of the envinroment information
-- *`testops.api.token` - Token for API access, you can generate it [here](https://developers.qase.io/#authentication).
-- *`testops.project` - [Your project's code](https://help.qase.io/en/articles/9787250-how-do-i-find-my-project-code)
-- `testops.run.id` - Qase test run ID, used when the test run was created earlier using CLI or API call.
-- `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
+## Network Profiler
 
-Example `jest.config.js` config:
+The Network Profiler automatically captures outgoing HTTP requests made during test execution and reports them as REQUEST-type steps in Qase TestOps.
 
-```js
-module.exports = {
-  reporters: [
-    'default',
-    [
-      'jest-qase-reporter',
-      {
-        mode: 'testops',
-        testops: {
-          api: {
-            token: 'api_key'
-          },
-          project: 'project_code',
-          run: {
-            complete: true,
-          },
-        },
-        debug: true,
-      },
-    ],
-  ],
-  ...
-};
-```
+**Enable in `qase.config.json`:**
 
-You can check example configuration with multiple reporters in [example project](../examples/jest/jest.config.js).
+```json
+{
+  "profilers": ["network"],
+  "networkProfiler": {
+    "skip_domains": ["analytics.example.com"],
+    "track_on_fail": true
+  }
+}
+```
 
-Supported ENV variables:
+| Option | Description | Default |
+|--------|-------------|---------|
+| `profilers` | Array of profilers to enable. Use `["network"]` for HTTP capture | `[]` |
+| `networkProfiler.skip_domains` | Domains to exclude from profiling | `[]` |
+| `networkProfiler.track_on_fail` | Capture response body for failed requests (status >= 400) | `true` |
 
-- `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`
+> Requests to `qase.io` are always excluded automatically.
 
 ## 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/)
+- Node.js >= 14
+- Jest >= 27.0.0
+
+> **Note:** Testing frameworks that use Jest as a test runner, such as Puppeteer, Appium, and Detox, can also be used with Jest reporter.
+
+## Documentation
+
+| Guide | Description |
+|-------|-------------|
+| [Usage Guide](docs/usage.md) | Complete usage reference with all methods and options |
+| [Attachments](docs/ATTACHMENTS.md) | Adding screenshots, logs, and files to test results |
+| [Steps](docs/STEPS.md) | Defining test steps for detailed reporting |
+| [Multi-Project Support](docs/MULTI_PROJECT.md) | Reporting to multiple Qase projects |
+| [Upgrade Guide](docs/UPGRADE.md) | Migration guide for breaking changes |
+
+## Examples
 
-`jest >= 28.0.0`
+See the [examples directory](../examples/) for complete working examples.
 
-<!-- references -->
+## License
 
-[auth]: https://developers.qase.io/#authentication
+Apache License 2.0. See [LICENSE](LICENSE) for details.

package/changelog.md

@@ -1,3 +1,10 @@
+# jest-qase-reporter@2.2.1
+
+## What's new
+
+- Added Network Profiler integration for automatic HTTP request capture during test execution.
+- Updated `qase-javascript-commons` dependency to `~2.5.6`.
+
 # jest-qase-reporter@2.2.0
 
 ## What's new

package/dist/reporter.d.ts

@@ -26,6 +26,16 @@ export declare class JestQaseReporter implements Reporter {
      * @private
      */
     private reporter;
+    /**
+     * @type {NetworkProfiler | null}
+     * @private
+     */
+    private profiler;
+    /**
+     * Snapshot of fallback accumulator length — used for per-test step delta in --runInBand mode.
+     * @private
+     */
+    private _profilerStepSnapshot;
     /**
      * @type {Metadata}
      * @private

package/dist/reporter.js

@@ -44,6 +44,16 @@ class JestQaseReporter {
      * @private
      */
     reporter;
+    /**
+     * @type {NetworkProfiler | null}
+     * @private
+     */
+    profiler = null;
+    /**
+     * Snapshot of fallback accumulator length — used for per-test step delta in --runInBand mode.
+     * @private
+     */
+    _profilerStepSnapshot = 0;
     /**
      * @type {Metadata}
      * @private
@@ -57,12 +67,19 @@ class JestQaseReporter {
      */
     constructor(_, options, _state, configLoader = new qase_javascript_commons_1.ConfigLoader()) {
         const config = configLoader.load();
+        const composedOptions = (0, qase_javascript_commons_1.composeOptions)(options, config);
         this.reporter = qase_javascript_commons_1.QaseReporter.getInstance({
-            ...(0, qase_javascript_commons_1.composeOptions)(options, config),
+            ...composedOptions,
             frameworkPackage: 'jest',
             frameworkName: 'jest',
             reporterName: 'jest-qase-reporter',
         });
+        if (composedOptions.profilers?.includes('network')) {
+            this.profiler = new qase_javascript_commons_1.NetworkProfiler({
+                skipDomains: composedOptions.networkProfiler?.skip_domains,
+                trackOnFail: composedOptions.networkProfiler?.track_on_fail,
+            });
+        }
         // @ts-expect-error - global.Qase is dynamically added at runtime
         global.Qase = new global_1.Qase(this);
         this.metadata = this.createEmptyMetadata();
@@ -72,6 +89,8 @@ class JestQaseReporter {
      */
     onRunStart() {
         this.reporter.startTestRun();
+        // Enable profiler in main process for --runInBand mode
+        this.profiler?.enable();
     }
     onTestCaseResult(test, testCaseResult) {
         if (this.metadata.ignore) {
@@ -116,6 +135,16 @@ class JestQaseReporter {
         const ids = JestQaseReporter.getCaseId(testCaseResult.title);
         result.signature = this.getSignature(test.path, testCaseResult.fullName, ids, this.metadata.parameters);
         this.cleanMetadata();
+        // Collect profiler steps for --runInBand mode (reporter and tests share same process)
+        // In multi-worker mode, the reporter's profiler has no captured steps (different process).
+        if (this.profiler) {
+            const allSteps = this.profiler.getAllSteps();
+            const newSteps = allSteps.slice(this._profilerStepSnapshot);
+            this._profilerStepSnapshot = allSteps.length;
+            if (newSteps.length > 0) {
+                result.steps = [...result.steps, ...newSteps];
+            }
+        }
         void this.reporter.addTestResult(result);
     }
     /**
@@ -140,6 +169,7 @@ class JestQaseReporter {
      * @see {Reporter.onRunComplete}
      */
     onRunComplete() {
+        this.profiler?.restore();
         void this.reporter.publish();
     }
     /**