### Install qasectl via go install

Source: https://developers.qase.io/docs/qase-cli

Installs the Qase CLI using the go install command. Ensure your Go binary path is added to your system's PATH environment variable.

```bash
go install github.com/qase-tms/qasectl@latest
```

--------------------------------

### CI Integration Example (GitHub Actions)

Source: https://developers.qase.io/docs/public-run-report

Example of how to enable the public report link feature within a GitHub Actions workflow by setting the relevant environment variables during the test run step.

```yaml
# GitHub Actions example
- name: Run tests
  env:
    QASE_MODE: testops
    QASE_TESTOPS_SHOW_PUBLIC_REPORT_LINK: true
```

--------------------------------

### Set Environment Variables for Qase Reporting

Source: https://developers.qase.io/docs/connecting-to-qase

Export these three environment variables to enable Qase reporting and specify your project. This is the quickest way to get started.

```bash
export QASE_MODE=testops
export QASE_TESTOPS_API_TOKEN=your-token-here
export QASE_TESTOPS_PROJECT=DEMO
```

--------------------------------

### Basic qase.config.json Example

Source: https://developers.qase.io/docs/the-config-file

This configuration sets the reporter to 'testops' mode, with a fallback to 'report' if the API is unreachable. It specifies a project code 'DEMO', a run title 'Automated regression', and configures batching for results.

```json
{
  "mode": "testops",
  "fallback": "report",
  "debug": false,
  "testops": {
    "project": "DEMO",
    "run": {
      "title": "Automated regression",
      "complete": true
    },
    "batch": {
      "size": 200
    }
  }
}
```

--------------------------------

### Playwright Log File Example

Source: https://developers.qase.io/docs/log-file

Illustrates the content of a Qase log file, showing timestamps and log levels. The file format omits ANSI color codes present in console output.

```text
[2025-01-15T14:32:00.123Z] [INFO] qase: Test run 12345 started
[2025-01-15T14:32:00.125Z] [DEBUG] qase: Config: {"mode":"testops","testops":{"project":"DEMO","api":{"token":"abc***wxyz"},...}}
[2025-01-15T14:32:00.126Z] [DEBUG] qase: Host data: {"node":"20.11.0","os":"linux","package":"playwright-qase-reporter","version":"3.0.0"}
```

--------------------------------

### Set Qase Environment Variables

Source: https://developers.qase.io/docs/quick-start-1

Export your Qase API token and project code as environment variables before running tests. This is a common setup step for most integrations.

```bash
export QASE_TESTOPS_API_TOKEN=<your-token>
export QASE_TESTOPS_PROJECT=<your-project-code>
```

--------------------------------

### Java Log File Example

Source: https://developers.qase.io/docs/log-file

Shows the log file format for Java, which includes thread ID and caller class for better context in parallel execution environments.

```text
[2025-01-15 14:32:00.123] [INFO] [Thread-14] [io.qase.commons.reporters.TestopsReporter] Test run 12345 started
```

--------------------------------

### GitHub Actions Workflow for Qase Test Reporting

Source: https://developers.qase.io/docs/deploy

A minimal GitHub Actions workflow to run Playwright tests and report results to Qase. It checks out code, sets up Node.js, installs dependencies, installs Playwright, and runs tests with Qase reporting enabled via environment variables.

```yaml
name: Tests
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
      - run: npm ci
      - run: npx playwright install --with-deps
      - run: npx playwright test
        env:
          QASE_MODE: testops
          QASE_TESTOPS_API_TOKEN: ${{ secrets.QASE_API_TOKEN }}
          QASE_TESTOPS_PROJECT: DEMO
```

--------------------------------

### Rejected Batch Log Example

Source: https://developers.qase.io/docs/debug-mode

This log indicates an API rejection for a batch of results. It highlights the specific error message and fields that caused the rejection, useful for debugging data validation issues.

```log
[DEBUG] qase: Sending batch of 200 results to Qase API
[ERROR] qase: API request failed with error: 422 Unprocessable Entity
[DEBUG] qase: HTTP response body: {"errorMessage":"Invalid field value","errorFields":[{"field":"results.0.params.browser","error":"Value cannot be empty"}]}
[WARN]  qase: Batch upload failed, 200 results dropped
```

--------------------------------

### Create a test run from source build

Source: https://developers.qase.io/docs/qase-cli

Executes the qasectl binary built from source to create a test run. Requires project code, token, title, description, and environment.

```bash
./build/qasectl testops run create --project QD --token <your-token> --title "Run created from Qase-cli" --description "Hello, from qase-cli" --environment <env-slug> --verbose
```

--------------------------------

### Build qasectl binary

Source: https://developers.qase.io/docs/qase-cli

Builds the qasectl binary using the make build command after cloning the repository. The executable will be found in the build/ directory.

```bash
make build
```

--------------------------------

### Create Environment

Source: https://developers.qase.io/docs/qase-cli

Creates a new environment in a Qase project. Use --verbose for detailed output. The output can be redirected using --output.

```bash
qasectl testops env create  
--project <project_code>  
--token <token>  
--title <title>  
--slug <slug>  
--description <description>  
--host <host>  
--verbose
```

--------------------------------

### Create a test run with minimal options

Source: https://developers.qase.io/docs/qase-cli

Creates a test run with essential parameters: project code, token, and title. Verbose mode is enabled.

```bash
qasectl testops run create \
--project DEMO \
--token <token> \
--title "Example test run created using Qase CLI" \
--verbose
```

--------------------------------

### Apply multiple status mappings in JSON

Source: https://developers.qase.io/docs/status-mapping

Define multiple status mappings simultaneously in the JSON configuration. This example maps 'invalid' to 'failed' and 'blocked' to 'skipped'.

```json
{
  "statusMapping": {
    "invalid": "failed",
    "blocked": "skipped"
  }
}
```

--------------------------------

### Set mode to testops using CLI flag

Source: https://developers.qase.io/docs/configuration

Runtime overrides are the top layer and can be used for one-off changes. This example shows a CLI flag for Python/pytest.

```shell
# CLI flag (Python/pytest)
pytest --qase-mode=testops
```

--------------------------------

### Run qasectl Docker container

Source: https://developers.qase.io/docs/qase-cli

Runs the qasectl Docker container. Replace '<add-your-command-here>' with the desired qasectl command.

```bash
docker run --rm ghcr.io/qase-tms/qase-cli:latest <add-your-command-here>
```

--------------------------------

### Clone qasectl repository

Source: https://developers.qase.io/docs/qase-cli

Clones the qasectl repository from GitHub. This is the first step to building the CLI from source.

```bash
git clone <https://github.com/qase-tms/qase-cli.git> && cd qase-cli
```

--------------------------------

### Configure Enterprise Qase Instance with Environment Variables

Source: https://developers.qase.io/docs/connecting-to-qase

Alternatively, configure your dedicated Qase instance using environment variables. Set the API host and the enterprise flag to enable enterprise-specific behavior.

```bash
export QASE_TESTOPS_API_HOST=yourcompany.qase.io
export QASE_TESTOPS_API_ENTERPRISE=true
```

--------------------------------

### Search Log File for Configuration

Source: https://developers.qase.io/docs/log-file

Use grep to search the log file for specific configuration details. This is useful for quickly finding relevant information within large log files.

```bash
grep "Config:" logs/log.txt
```

--------------------------------

### Filter out 'skipped' and 'blocked' statuses via environment variable

Source: https://developers.qase.io/docs/status-mapping

Configure status filtering by setting the QASE_TESTOPS_STATUS_FILTER environment variable with a comma-separated list of statuses to exclude from reporting. This example filters out 'skipped' and 'blocked' tests.

```bash
QASE_TESTOPS_STATUS_FILTER="skipped,blocked"
```

--------------------------------

### Healthy Playwright Test Run Log

Source: https://developers.qase.io/docs/debug-mode

This log shows a successful Playwright test run with Qase. It includes configuration details, host information, test run start and completion messages, and individual test result statuses (passed/failed).

```log
[DEBUG] qase: Config: {"mode":"testops","testops":{"api":{"token":"0e5d...a]b4","host":"qase.io"},"project":"DEMO","run":{"complete":true},"batch":{"size":200}},"debug":true}
[DEBUG] qase: Host data: {"reporter":"playwright-qase-reporter@3.0.1","framework":"@playwright/test@1.40.0","node":"v20.11.0","os":"linux"}
[INFO]  qase: Test run 4521 started
[DEBUG] qase: Result: {"title":"User can log in","execution":{"status":"passed","duration":1230},"testops_id":42,"relations":{"suite":{"data":[{"title":"Auth"},{"title":"Login"}]}}}
[DEBUG] qase: Result: {"title":"User sees error on bad password","execution":{"status":"failed","duration":890,"stacktrace":"Expected: visible..."},"testops_id":43}
[INFO]  qase: See why this test failed: https://app.qase.io/run/DEMO/dashboard/4521?status=failed
[DEBUG] qase: Sending batch of 2 results to Qase API
[DEBUG] qase: Successfully sent batch: HTTP 200
[INFO]  qase: Run 4521 completed
```

--------------------------------

### Configure Qase Test Runs in CI

Source: https://developers.qase.io/docs/test-runs

Use this JSON configuration to set up test run parameters. Environment variables are used in CI to inject dynamic context.

```json
{
  "mode": "off",
  "testops": {
    "project": "PROJ",
    "run": {
      "title": "Regression",
      "complete": true
    }
  }
}
```

```bash
export QASE_MODE=testops
export QASE_TESTOPS_API_TOKEN=$QASE_TOKEN
export QASE_TESTOPS_RUN_TITLE="$CI_JOB_NAME – build #$CI_BUILD_NUMBER"
export QASE_TESTOPS_RUN_TAGS="nightly,staging"
```

--------------------------------

### Configure Test Run with Environment Variables

Source: https://developers.qase.io/docs/configurations

Set test run configurations and enable automatic creation of missing groups/values using environment variables, practical for CI environments.

```bash
export QASE_TESTOPS_CONFIGURATIONS_VALUES="Browser=Chrome,OS=Linux"
export QASE_TESTOPS_CONFIGURATIONS_CREATE_IF_NOT_EXISTS=true
```

--------------------------------

### Configure Qase Reporting with JSON File and Env Var

Source: https://developers.qase.io/docs/connecting-to-qase

Store non-secret configuration like mode and project in a `qase.config.json` file, and keep the API token in an environment variable for security. This method is suitable for long-term use.

```json
// qase.config.json
{
  "mode": "testops",
  "testops": {
    "project": "DEMO"
  }
}
```

```shell
export QASE_TESTOPS_API_TOKEN=your-token-here
```

--------------------------------

### Export Local Report as Static HTML

Source: https://developers.qase.io/docs/report-mode-as-a-fallback

Use the `qase-report generate` command to create a single static HTML file from a local JSON report.

```bash
npx qase-report generate ./build/qase-report -o ./report.html
```

--------------------------------

### Enable File Logging via JSON Config

Source: https://developers.qase.io/docs/log-file

Enable file logging by setting the 'file' property to true within the 'logging' section of your Qase configuration file.

```json
{
  "logging": {
    "file": true
  }
}
```

--------------------------------

### Enable File Logging via Environment Variable

Source: https://developers.qase.io/docs/log-file

Enable file logging by setting the QASE_LOGGING_FILE environment variable to 'true'. This is a common method for CI/CD environments.

```bash
QASE_LOGGING_FILE=true
```

--------------------------------

### Configure Enterprise Qase Instance with JSON File

Source: https://developers.qase.io/docs/connecting-to-qase

For Enterprise users with a dedicated Qase instance, specify the custom host and set the enterprise flag in the `qase.config.json` file. This ensures API calls are routed correctly.

```json
// qase.config.json
{
  "mode": "testops",
  "testops": {
    "api": {
      "host": "yourcompany.qase.io",
      "enterprise": true
    },
    "project": "DEMO"
  }
}
```

--------------------------------

### Upload Qase Logs in GitLab CI

Source: https://developers.qase.io/docs/log-file

Sets up GitLab CI to save the 'logs/' directory as an artifact. 'when: always' guarantees the artifact is preserved regardless of job success or failure.

```yaml
test:
  script:
    - npx playwright test
  artifacts:
    when: always
    paths:
      - logs/
```

--------------------------------

### Run Tests Individually with Batch Size 1

Source: https://developers.qase.io/docs/empty-test-run-or-missing-results

Use this command to test individual tests and determine if they are being rejected by the Qase API. This helps in isolating problematic tests by sending them one by one.

```bash
QASE_TESTOPS_BATCH_SIZE=1 pytest <test_file>::<test_name>
```

--------------------------------

### CI/CD Environment Configuration (GitHub Actions)

Source: https://developers.qase.io/docs/environments

In CI/CD workflows, set the QASE_ENVIRONMENT variable dynamically for different jobs targeting different deployment environments.

```yaml
# GitHub Actions example
jobs:
  test-staging:
    env:
      QASE_MODE: testops
      QASE_TESTOPS_API_TOKEN: ${{ secrets.QASE_API_TOKEN }}
      QASE_ENVIRONMENT: staging

test-production:
    env:
      QASE_MODE: testops
      QASE_TESTOPS_API_TOKEN: ${{ secrets.QASE_API_TOKEN }}
      QASE_ENVIRONMENT: production
```

--------------------------------

### Create Milestone

Source: https://developers.qase.io/docs/qase-cli

Creates a new milestone in a Qase project. Use --verbose for detailed output. The output can be redirected using --output.

```bash
qasectl testops milestone create  
--project <project_code>  
--token <token>  
--title <title>  
--description <description>  
--status <status>  
--due-date <due_date>  
--verbose
```

--------------------------------

### Enable reporting in CI

Source: https://developers.qase.io/docs/configuration

In CI environments, set the QASE_MODE environment variable to 'testops' to override the config file and enable reporting.

```shell
QASE_MODE=testops
```

--------------------------------

### CI Matrix Configuration with GitHub Actions

Source: https://developers.qase.io/docs/configurations

Dynamically set Qase test run configurations within a GitHub Actions CI matrix to tag runs with specific browser versions.

```yaml
strategy:
  matrix:
    browser: [chromium, firefox, webkit]
env:
  QASE_TESTOPS_CONFIGURATIONS_VALUES: "Browser=${{ matrix.browser }}"
  QASE_TESTOPS_CONFIGURATIONS_CREATE_IF_NOT_EXISTS: true
```

--------------------------------

### Configure Log Capture in qase.config.json

Source: https://developers.qase.io/docs/capture-logs

Set the `captureLogs` option to `true` in your `qase.config.json` file to enable log capture globally.

```json
{
  "captureLogs": true
}
```

--------------------------------

### Open Local Report as Interactive Dashboard

Source: https://developers.qase.io/docs/report-mode-as-a-fallback

Use the `qase-report open` command to view saved JSON reports as an interactive HTML dashboard in your browser.

```bash
npx qase-report open ./build/qase-report
```

--------------------------------

### Upload Local Report to Qase

Source: https://developers.qase.io/docs/report-mode-as-a-fallback

Use the `qase-report upload` command to send previously saved JSON reports to Qase. Requires project identifier and API token.

```bash
npx qase-report upload ./build/qase-report \
  --project PROJ \
  --token <your-token>
```

--------------------------------

### Complete a test run

Source: https://developers.qase.io/docs/qase-cli

Completes a specified test run in Qase. Requires project code, API token, and the test run ID. Verbose mode is enabled.

```bash
qasectl testops run complete --project DEMO --token <token> --id 1 --verbose
```

--------------------------------

### Enable Log Capture via Environment Variable

Source: https://developers.qase.io/docs/capture-logs

Use the `QASE_CAPTURE_LOGS` environment variable to enable log capture. This is useful for investigation mode without altering default CI runs.

```bash
QASE_CAPTURE_LOGS=true npx playwright test
```

--------------------------------

### Configure Test Run with JSON

Source: https://developers.qase.io/docs/configurations

Use this JSON configuration to specify test run configurations and enable automatic creation of missing groups/values.

```json
{
  "testops": {
    "configurations": {
      "values": [
        { "name": "Browser", "value": "Chrome" },
        { "name": "OS", "value": "Linux" }
      ],
      "createIfNotExists": true
    }
  }
}
```

--------------------------------

### GitHub Actions Workflow for Qase TestOps

Source: https://developers.qase.io/docs/deploy

This YAML defines a GitHub Actions workflow for creating, running, and completing Qase test runs. It demonstrates how to manage parallel test execution and ensure run completion even if tests fail.

```yaml
jobs:
  create-run:
    runs-on: ubuntu-latest
    outputs:
      run-id: ${{ steps.create.outputs.run-id }}
    steps:
      - name: Create Qase run
        id: create
        run: |
          qasectl testops run create \
            --project DEMO \
            --token ${{ secrets.QASE_API_TOKEN }} \
            --title "CI Run #${{ github.run_number }}"

  test:
    needs: create-run
    strategy:
      matrix:
        shard: [1, 2, 3, 4]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npx playwright test --shard=${{ matrix.shard }}/4
        env:
          QASE_MODE: testops
          QASE_TESTOPS_API_TOKEN: ${{ secrets.QASE_API_TOKEN }}
          QASE_TESTOPS_PROJECT: DEMO
          QASE_TESTOPS_RUN_ID: ${{ needs.create-run.outputs.run-id }}
          QASE_TESTOPS_RUN_COMPLETE: false

  complete-run:
    needs: [create-run, test]
    if: always()
    runs-on: ubuntu-latest
    steps:
      - name: Complete Qase run
        run: |
          qasectl testops run complete \
            --project DEMO \
            --token ${{ secrets.QASE_API_TOKEN }} \
            --id ${{ needs.create-run.outputs.run-id }}
```

--------------------------------

### Pull qasectl Docker image

Source: https://developers.qase.io/docs/qase-cli

Pulls the latest Docker image for the Qase CLI from GitHub Container Registry.

```bash
docker pull ghcr.io/qase-tms/qase-cli:latest
```

--------------------------------

### Set Test Run Description with Environment Variables

Source: https://developers.qase.io/docs/test-runs

Set a detailed description for a test run using environment variables. This is useful for providing context about the run's trigger, scope, or purpose, especially for historical analysis.

```bash
export QASE_TESTOPS_RUN_DESCRIPTION="Full regression triggered by deploy to staging. Branch: $BRANCH_NAME"
```

--------------------------------

### Enable Public Report Link via Environment Variable

Source: https://developers.qase.io/docs/public-run-report

Alternatively, enable the public report link feature by setting the `QASE_TESTOPS_SHOW_PUBLIC_REPORT_LINK` environment variable to `true`. This is useful for CI environments.

```bash
export QASE_TESTOPS_SHOW_PUBLIC_REPORT_LINK=true
```

--------------------------------

### Enable Fallback Reporting

Source: https://developers.qase.io/docs/fallback-mode

Set fallback to 'report' to save results to disk on API connection failure. This allows for later upload using `qase-report`.

```json
{
  "mode": "testops",
  "fallback": "report"
}
```

--------------------------------

### Linking CI Build to Qase Run Description

Source: https://developers.qase.io/docs/deploy

Configure the Qase run description in your CI environment to include a direct link to the CI build. This allows easy navigation from Qase results back to the specific build that generated them.

```yaml
env:
  QASE_TESTOPS_RUN_DESCRIPTION: "CI build: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
```

--------------------------------

### Configure Root Suite in JSON Config

Source: https://developers.qase.io/docs/root-suite

Set the root suite name directly in the reporter's configuration file.

```json
{
  "rootSuite": "Web E2E"
}
```

--------------------------------

### Configure File Logging Only

Source: https://developers.qase.io/docs/log-file

Enable file logging and disable console logging. This is useful when you want to avoid cluttering the console output with Qase messages and focus on your test runner's output.

```json
{
  "logging": {
    "console": false,
    "file": true
  }
}
```

--------------------------------

### Set Qase Reporter to Report Mode

Source: https://developers.qase.io/docs/report-mode-as-a-fallback

Set the QASE_MODE environment variable to 'report' to enable saving results to a local JSON file.

```bash
QASE_MODE=report
```

--------------------------------

### Configure Batch Size in qase.config.json

Source: https://developers.qase.io/docs/empty-test-run-or-missing-results

Set the batch size for sending test results to Qase via the configuration file. A batch size of 1 helps in identifying individual problematic test results.

```json
{
  "testops": {
    "batch": {
      "size": 1
    }
  }
}
```

--------------------------------

### Upload Qase Logs in GitHub Actions

Source: https://developers.qase.io/docs/log-file

Configures GitHub Actions to upload the contents of the 'logs/' directory as an artifact. 'if: always()' ensures logs are saved even if tests fail.

```yaml
- name: Run tests
  run: npx playwright test
  env:
    QASE_MODE: testops
    QASE_DEBUG: true
    QASE_TESTOPS_API_TOKEN: ${{ secrets.QASE_API_TOKEN }}
    QASE_TESTOPS_PROJECT: DEMO

- name: Upload Qase logs
  if: always()
  uses: actions/upload-artifact@v4
  with:
    name: qase-logs
    path: logs/
```

--------------------------------

### Set Root Suite via Environment Variable

Source: https://developers.qase.io/docs/root-suite

Use the QASE_ROOT_SUITE environment variable to define the root suite name. This method overrides the config file setting.

```bash
QASE_ROOT_SUITE="Web E2E" npx playwright test
```

--------------------------------

### Configure Console Logging Only

Source: https://developers.qase.io/docs/log-file

Enable console logging and disable file logging. This is useful when your CI pipeline already captures stdout and you do not need a separate log file.

```json
{
  "logging": {
    "console": true,
    "file": false
  }
}
```

--------------------------------

### Search Log File for API Responses

Source: https://developers.qase.io/docs/log-file

Uses 'grep' to search for lines containing 'status' in the Qase log file, useful for inspecting API response details.

```bash
grep "status" logs/log.txt
```

--------------------------------

### Enable Debug Mode and File Logging

Source: https://developers.qase.io/docs/debug-mode

Configure the reporter to enable debug mode and direct all logging output to a file, disabling console output. This is recommended for CI environments to keep logs clean while retaining full debug information.

```json
{
  "debug": true,
  "logging": {
    "console": false,
    "file": true
  }
}
```

--------------------------------

### Configure Selective Execution with JSON

Source: https://developers.qase.io/docs/test-plans

Use this JSON configuration to set the Qase test plan ID for selective test execution. Ensure tests are linked to Qase IDs for this to work.

```json
{
  "testops": {
    "plan": {
      "id": 42
    }
  }
}
```

--------------------------------

### Set mode to testops in config file

Source: https://developers.qase.io/docs/configuration

This is the base configuration for setting the mode. It is stored in a JSON file.

```json
// qase.config.json
{
  "mode": "testops"
}
```

--------------------------------

### Enable debug mode for a flaky test

Source: https://developers.qase.io/docs/configuration

For debugging a specific flaky test, pass the '--qase-debug=true' flag on the command line to override all other settings for that single run.

```shell
--qase-debug=true
```

--------------------------------

### Set Root Suite via CLI Flag (Python)

Source: https://developers.qase.io/docs/root-suite

Configure the root suite name using the --qase-root-suite CLI flag for Python test runners. This also overrides the config file.

```bash
pytest --qase-root-suite="Web E2E"
```

--------------------------------

### Attach file from path and content from memory in Playwright

Source: https://developers.qase.io/docs/attachments

Demonstrates attaching a JSON file from disk and a screenshot from memory to a test result using playwright-qase-reporter. Ensure the file path is correct and the content is provided with the correct MIME type.

```typescript
import { test, expect } from '@playwright/test';
import { qase } from 'playwright-qase-reporter';

test('Checkout flow', async ({ page }) => {
  await page.goto('https://example.com/checkout');

  // Attach a file from disk
  qase.attach({ paths: './test-data/order.json' });

  // Attach a screenshot from memory
  const screenshot = await page.screenshot();
  qase.attach({
    name: 'checkout-page.png',
    content: screenshot,
    contentType: 'image/png',
  });

  await expect(page.locator('.order-summary')).toBeVisible();
});
```

--------------------------------

### Search Log File for Errors

Source: https://developers.qase.io/docs/log-file

Uses 'grep' to find all lines containing 'ERROR' within the Qase log file located at 'logs/log.txt'.

```bash
grep "ERROR" logs/log.txt
```

--------------------------------

### Enable Debug Logging for Qase Reporter

Source: https://developers.qase.io/docs/empty-test-run-or-missing-results

Set the QASE_DEBUG environment variable to 'true' to enable detailed debug logs. These logs can provide valuable information about API requests, responses, and potential errors encountered by the Qase reporter.

```bash
QASE_DEBUG=true
```

--------------------------------

### Configure Report Mode Output Location

Source: https://developers.qase.io/docs/report-mode-as-a-fallback

Customize the output path and format for the local JSON report by configuring the 'report.connection.local' section in your Qase configuration.

```json
{
  "mode": "report",
  "report": {
    "connection": {
      "local": {
        "path": "./my-reports",
        "format": "json"
      }
    }
  }
}
```

--------------------------------

### Configure Batch Size in JSON

Source: https://developers.qase.io/docs/batching

Set the batch size for test result uploads using a JSON configuration file. The valid range is 1 to 2000.

```json
{
  "testops": {
    "batch": {
      "size": 200
    }
  }
}
```

--------------------------------

### Configure Environment via Environment Variable

Source: https://developers.qase.io/docs/environments

Alternatively, set the environment slug using an environment variable. This is often preferred for flexibility.

```bash
export QASE_ENVIRONMENT=staging
```

--------------------------------

### Set Test Run Title

Source: https://developers.qase.io/docs/test-runs

Configure the title for a test run using a JSON configuration. This helps in identifying the purpose of the run at a glance.

```json
{
  "testops": {
    "run": {
      "title": "Nightly regression – staging"
    }
  }
}
```

--------------------------------

### Dynamic Root Suite in CI (GitHub Actions)

Source: https://developers.qase.io/docs/root-suite

Dynamically set the root suite in a CI environment, such as GitHub Actions, to label results based on branches or pull requests. This is a niche use case for visual separation in the suite tree.

```yaml
env:
  QASE_ROOT_SUITE: "PR-${{ github.event.pull_request.number }}"
```