Code coverage

Code coverage uses generated reports to calculate the overall code coverage inside a method, class, and file. It also reports on the issues associated with the missing coverage in these entities.

This feature is available under the Ultimate and Ultimate Plus licenses in the following linters:

Linter	Code coverage tool	Supported report file extensions
Qodana for JVM	IntelliJ IDEA Code Coverage Agent is the recommended tool	`ic`
Qodana for JVM	JaCoCo	`xml`
Qodana for JS	Jest	`lcov`
Qodana for PHP	PhpUnit	`xml`
Qodana for .NET	coverlet.msbuild	`lcov`
Qodana for Python	Coverage.py	`xml`
Qodana for Go	`go test`	`out`

How code coverage works

For the missing code coverage issues, the predefined threshold in Qodana is currently set to 50%.

Code coverage uses several inspections that are already included in the qodana.recommended and qodana.starter default inspection profiles, so you do not need to enable them:

Linter	Employed inspection
Qodana for JVM	`JvmCoverageInspection`
Qodana for JS	`JsCoverageInspection`
Qodana for PHP	`PhpCoverageInspection`
Qodana for Python	`PyCoverageInspection`
Qodana for Go	`GoCoverageInspection`
Qodana for .NET	`NetCoverageInspection`

Once analysis is complete, reports are available in Qodana reports and JetBrains IDEs.

Code coverage calculation

Qodana calculates code coverage based on the number of code lines containing logic with function, method, and class statements being ignored. Here is the snippet containing comments on how it works:

function divide(a, b) { // Not analyzed by the code coverage
  return a / b; // Analyzed by the code coverage
}
module.exports = divide; // Analyzed by the code coverage

Before you start

Configure your code coverage tool. For example, Jest code coverage reports should contain paths relative to a project root. If your codebase files are contained in the <project-root>/src/ directory, then reports should contain src/<file-name> file paths.
Use your code coverage tool to generate coverage reports. These reports should be saved to the <project-root>/.qodana/code-coverage directory. You can copy the coverage report file by using the boostrap key, for example:
boostrap: copy path/to/coverage/file <project-root>/.qodana/code-coverage
To learn how to override the <project-root>/.qodana/code-coverage directory, see the recommendation from the Run code coverage chapter.
For a monorepo project containing multiple repositories, this directory should be created in each repository.
Prepare your project. If you have a monorepo project, save Qodana configuration for each repository in a separate qodana.yaml file. You can put these files in repository directories, or give them custom names and save them in the root directory of a project.
For the Qodana for .NET linter, add the coverlet.msbuild and coverlet.collector packages to the test project. Also, for the Qodana for .NET linter check whether a code coverage report contains information about generated files.

Run code coverage

To learn more about running code coverage using the Qodana for .NET linter, skip to the Qodana for .NET section of this page.

Map the directory containing code coverage reports to the /data/coverage directory and a project token using the QODANA_TOKEN variable. Here are the Docker and Qodana CLI command samples:

                    docker run \
                        -v $(pwd):/data/project/ \
                        -v .qodana/code-coverage/:/data/coverage \
                        -e QODANA_TOKEN="<qodana-cloud-token>" \
                        jetbrains/qodana-<image>
                

                    qodana scan \
                       -v .qodana/code-coverage/:/data/coverage \
                       -e QODANA_TOKEN="<qodana-cloud-token>"
                

If you have a monorepo project, use the -i <path-relative-to-project-root> option to point a repository directory. If you saved Qodana configuration files under custom names, use the --config <path-relative-to-project-root> option. To override the default code coverage report directory, use the --coverage-dir <path-relative-to-project-root> option.

Create the pipeline that will store all code coverage output files in the <project-root-dir>/.qodana/code-coverage directory. You can find various examples of the GitHub Actions configurations on the GitHub website.

Below is the pipeline configuration example for the Qodana for JS linter running in the JS/jest directory of a repository:

name: JavaScript - Jest Test

on:
  workflow_dispatch:
  pull_request:
  push:
    branches:
      - main
      - 'releases/*'

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout Code
      uses: actions/checkout@v3
      with:
        ref: ${{ github.event.pull_request.head.sha }}
        fetch-depth: 0

    - name: Use Node.js 18.x
      uses: actions/setup-node@v2
      with:
        node-version: 18.x

    - name: Install dependencies
      run: npm ci
      working-directory: JS/jest

    - name: Run tests
      run: npm test
      working-directory: JS/jest
      
    - name: Archive coverage data # Archive data for use by Qodana
      uses: actions/upload-artifact@v4
      with:
        name: jest-coverage-data
        path: JS/jest/.qodana/code-coverage

    - name: Qodana Scan # Run Qodana
      uses: JetBrains/qodana-action@main
      env:
        QODANA_TOKEN: ${{ secrets.QODANA_TOKEN_JS }}
      with:
        args: "-i,JS/jest,--image,jetbrains/qodana-js:2025.2"
        pr-mode: false

If you have a monorepo project and saved Qodana configuration files under custom names, then in the args block use the --config,<path-relative-to-project-root> option. To override the default code coverage report directory, use the --coverage-dir,<path-relative-to-project-root> option.

Create a GitLab CI/CD pipeline that will read all generated code coverage output files from the .qodana/coverage directory using the --coverage-dir option:

        include:
            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2025.2
              inputs:
                args: --coverage-dir,$CI_PROJECT_DIR/.qodana/code-coverage,--image,<image>
        

If you have a monorepo project and saved Qodana configuration files under custom names, then add the --config,<path-relative-to-project-root> option to args:

        include:
            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2025.2
              inputs:
                args: --coverage-dir,$CI_PROJECT_DIR/.qodana/code-coverage,--config,<path-relative-to-project-root>,--image,<image>
        

Create a pipeline that will read all generated code coverage output files from the .qodana/coverage directory using the --coverage-dir option:

In this configuration, the args: block maps the results of code coverage analysis to the /data/coverage directory.

         # Start with a minimal pipeline that you can customize to build and deploy your code.
         # Add steps that build, run tests, deploy, and more:
         # https://aka.ms/yaml
          
         trigger:
           - main
          
         pool:
           vmImage: ubuntu-latest
          
         steps:
           - task: Cache@2  # Not required, but Qodana will open projects with cache faster.
               key: '"$(Build.Repository.Name)" | "$(Build.SourceBranchName)" | "$(Build.SourceVersion)"'
               path: '$(Agent.TempDirectory)/qodana/cache'
               restoreKeys: |
                 "$(Build.Repository.Name)" | "$(Build.SourceBranchName)"
                 "$(Build.Repository.Name)"
           - task: QodanaScan@2025
             env:
               QODANA_TOKEN: $(QODANA_TOKEN)
             inputs:
               args: '-v,  $(System.DefaultWorkingDirectory)/<ProjectPath>/.qodana/:/data/coverage'
           

Use the Qodana CLI arguments field to map the results of code coverage analysis to the /data/coverage directory. For example, this can be the $(System.DefaultWorkingDirectory)/<ProjectPath> directory:

The Qodana Scan task UI config for baseline and quality gate

Qodana for .NET

Here is an example of the qodana.yaml file configuration for the Qodana for .NET linter:

dotnet:
  solution: <your-solution-file>

bootstrap: dotnet build; cd <path-to-dir-with-test-project-file> && \\
  dotnet add package coverlet.msbuild && dotnet add package coverlet.collector && \\
  ((dotnet test /p:CollectCoverage=true /p:CoverletOutput=<your-project-folder>/.qodana/code-coverage/ /p:CoverletOutputFormat=lcov))

Here, the dotnet option configures the solution file.

The bootstrap key performs several steps before running Qodana:

Command step	Description
`dotnet build`	Build a project or a solution
`cd <path-to-dir-with-test-project-file>`	Navigate to the directory containing the project test file
`dotnet add package coverlet.msbuild`	Add the `coverlet.msbuild` package to the project. This command needs to be repeated for each
`dotnet test ...`	Execute tests in the project, and:
`/p:CollectCoverage=true`	Enable code coverage
`/p:CoverletOutput=<your-project-folder>/.qodana/code-coverage`	Collect code coverage results to a specific directory
`/p:CoverletOutputFormat=lcov`	Specify the code coverage output format

If a code coverage report file contains information about generated files, exclude this information by adding one or both of the following lines to the dotnet test ... line:

/p:ExcludeByAttribute="Obsolete,GeneratedCodeAttribute,CompilerGeneratedAttribute" 
/p:ExcludeByFile="some-exclude-pattern"

Here is the description of these lines:

Command step	Description
`/p:ExcludeByAttribute="..."`	Exclude methods or classes marked with specific attributes
`/p:ExcludeByFile="..."`	Excludes files matching a pattern (e.g., `*/Generated/.cs`)

Code coverage analysis results for the Qodana for .NET linter are available in Qodana Cloud.

Fresh code

Fresh code is the code contained in a GitHub pull request. Qodana can calculate fresh code coverage and display the results.

To enable the fresh code feature, configure the PR-mode in your GitHub workflow.

Here is the sample for inspecting the JavaScript fresh code:

name: Code coverage fresh code

on:
  workflow_dispatch:
  pull_request:
  push:
    branches:
      - main
      - 'releases/*'

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Code
        uses: actions/checkout@v3
        with:
          ref: ${{ github.event.pull_request.head.sha }}
          fetch-depth: 0

      - name: Use Node.js 18.x
        uses: actions/setup-node@v2
        with:
          node-version: 18.x

      - name: Install dependencies
        run: npm ci

      - name: Run tests
        run: npm test
      
      - name: Archive coverage data
        uses: actions/upload-artifact@v4
        with:
          name: jest-coverage-data
          path: .qodana/code-coverage
      
      - name: Qodana Scan
        uses: JetBrains/qodana-action@main
        env:
          QODANA_TOKEN: ${{ secrets.QODANA_TOKEN_JS }}
        with:
          pr-mode: true # Enable the pull-request mode

Report overview

After you have prepared the project and ran the code coverage, you can view code coverage reports in Qodana Cloud or using your IDE.

Qodana Cloud

You can find code coverage statistics in the upper-right corner of the Qodana report UI. It also lists the inspections used by the feature.

IDE

You can view code coverage reports using IntelliJ IDEA, WebStorm, PhpStorm, PyCharm, and GoLand IDEs starting from version 2023.2. This feature is available for reports retrieved from Qodana Cloud after linking, or reports from local storage.

Open reports from Qodana Cloud

In your IDE, navigate to Tools | Qodana | Log in to Qodana.
On the Settings dialog, click Log in.
This will redirect you to the authentication page.
In the Settings dialog, search for the project you would like to link with.

View coverage reports in IDE

You can view code coverage reports based locally using JetBrains IDEs.

In your IDE, navigate to Run | Show coverage data and open the file containing a code coverage report.

The Choose Coverage Suite to Display dialog

In the Coverage tool window, you can view the test coverage report. This report shows the percentage of the code that has been executed or covered by tests.

Report overview

The IDE highlights the codebase test coverage using color marking. By default, the green color means that a particular line was covered, and the red color means the uncovered line of code.

The report shows coverage for the lines that implement the logic of a method, function, or a class, but not for the function, method, or class declaration. The image below shows that code coverage is not applicable to line 7, while line 8 is not covered.

23 September 2025