#coverage

• Type:

type CoverageOptions = {
  enabled?: boolean;
  provider?: 'istanbul';
  include?: string[];
  changed?: boolean | string;
  exclude?: string[];
  reporters?: (keyof ReportOptions | ReportWithOptions)[];
  reportsDirectory?: string;
  reportOnFailure?: boolean;
  clean?: boolean;
  allowExternal?: boolean;
  thresholds?: CoverageThresholds;
};

• Default: undefined

Collect code coverage and generate coverage reports.

$ npx rstest --coverage

----------|---------|----------|---------|---------|-------------------
File      | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
----------|---------|----------|---------|---------|-------------------
All files |     100 |      100 |     100 |     100 |
 index.ts |     100 |      100 |     100 |     100 |
----------|---------|----------|---------|---------|-------------------

#Options

#enabled

• Type: boolean
• Default: false
• CLI: --coverage, --coverage=false, --no-coverage

Enable or disable test coverage collection.

npx rstest --coverage

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
  },
});

#provider

• Type: 'istanbul'
• Default: 'istanbul'

The coverage provider to use. Currently, only istanbul is supported.

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    provider: 'istanbul',
  },
});

#Istanbul provider

Istanbul is a widely used JavaScript code coverage tool that collects code coverage information through instrumentation.

To enable istanbul coverage, you need to install the @rstest/coverage-istanbul package first.

npm add @rstest/coverage-istanbul -D

yarn add @rstest/coverage-istanbul -D

pnpm add @rstest/coverage-istanbul -D

bun add @rstest/coverage-istanbul -D

deno add npm:@rstest/coverage-istanbul -D

@rstest/coverage-istanbul is powered by swc-plugin-coverage-instrument.

#include

• Type: string[]
• Default: undefined

A list of glob patterns that should be included for coverage collection.

By default, rstest will only collect coverage for files that are tested. If you want to include untested files in the coverage report, you can use the include option to specify the files or patterns to include.

Note that you should use standard glob syntax here. For a single extension, write src/**/*.ts instead of src/**/*.{ts}. Single-value braces are treated literally by the underlying glob libraries, so src/**/*.{ts} will not match .ts files.

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    include: ['src/**/*.{js,jsx,ts,tsx}'],
  },
});

#changed

• Type: boolean | string
• Default: undefined
• CLI: --coverage.changed, --coverage.changed=<commit>

Collect coverage only for files changed in the current Git repository. Pass a commit or branch to collect coverage for files changed since that ref.

This option is available in both config and CLI:

• Use coverage.changed in rstest.config.ts when you want a persistent default, for example in CI.
• Use --coverage.changed for one-off local or CI runs.

coverage.changed only limits the coverage report scope. It does not change which tests are executed.

That means these two commands do different things:

npx rstest run --changed
npx rstest run --coverage.changed

• --changed changes the test selection and runs tests related to changed files.
• --coverage.changed keeps the normal test selection, but only reports coverage for changed source files.

#Interaction with --changed

• When --changed is used and coverage.changed is not configured, coverage reports inherit the changed files collected by --changed.
• If --changed hits forceRerunTriggers, Rstest reruns the full test suite. Coverage stays full in that case unless coverage.changed is explicitly enabled.
• If you want to use --changed for test selection but still keep full coverage reports, set coverage.changed to false in config.

Common setups:

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    changed: 'origin/main',
  },
});

The example above still runs the normal test suite, but the coverage report only includes files changed since origin/main.

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    changed: 'HEAD~1',
  },
});

npx rstest run --changed --coverage
npx rstest run --coverage.changed
npx rstest run --coverage.changed=HEAD~1
npx rstest run --coverage.changed=origin/main

• npx rstest run --changed --coverage runs changed-related tests and, by default, also limits coverage to the same changed file set.
• npx rstest run --coverage.changed=HEAD~1 runs the normal test suite but only reports coverage for files changed since HEAD~1.
• npx rstest run --coverage.changed=origin/main is useful when your branch is based on main: it still runs the normal test suite, but the coverage report only includes files changed compared with origin/main.

#exclude

• Type: string[]
• Default:

[
  '**/node_modules/**',
  '**/test/**',
  '**/__tests__/**',
  '**/__mocks__/**',
  '**/*.d.ts',
  '**/*.{test,spec}.[jt]s',
  '**/*.{test,spec}.[cm][jt]s',
  '**/*.{test,spec}.[jt]sx',
  '**/*.{test,spec}.[cm][jt]sx',
];

A glob pattern array to exclude files from test coverage collection.

Any patterns specified here will be merged with default values.

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    exclude: ['**/node_modules/**', '**/dist/**'],
  },
});

#reporters

• Type: (ReporterName | [ReporterName, ReporterOptions>])[]
• Default: ['text', 'html', 'clover', 'json']

The reporters to use for coverage collection. Each reporter can be either a string (the reporter name) or a tuple with the reporter name and its options.

• See Istanbul Reporters for available reporters.
• See @types/istanbul-reporter for details about reporter specific options.

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    reporters: [
      'html',
      ['text', { skipFull: true }],
      ['json', { file: 'coverage-final.json' }],
    ],
  },
});

#reportsDirectory

• Type: string
• Default: './coverage'

The directory to store coverage reports.

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    reportsDirectory: './coverage-reports',
  },
});

#reportOnFailure

• Type: boolean
• Default: false

Whether to report coverage and check thresholds when tests fail.

import { defineConfig } from '@rstest/core';
export default defineConfig({
  coverage: {
    enabled: true,
    reportOnFailure: true,
  },
});

#allowExternal

• Type: boolean
• Default: false
• CLI: --coverage.allowExternal

Whether to collect coverage for source files outside the project root directory. This is useful in monorepo setups where tests import modules from sibling packages.

By default, rstest excludes files outside the project root from coverage reports, which aligns with the behavior of Jest and Vitest.

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    allowExternal: true,
  },
});

#clean

• Type: boolean
• Default: true

Whether to clean the coverage directory before running tests.

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    clean: true,
  },
});

#thresholds

• Type:

type CoverageThreshold = {
  statements?: number;
  functions?: number;
  branches?: number;
  lines?: number;
};

type CoverageThresholds = CoverageThreshold & {
  /** check thresholds for matched files */
  [glob: string]: CoverageThreshold & {
    perFile?: boolean;
  };
};

• Default: undefined

Coverage thresholds for enforcing minimum coverage requirements. You can set thresholds for statements, functions, branches, and lines.

Thresholds specified as a positive number are taken to be the minimum percentage required. Thresholds specified as a negative number represent the maximum number of uncovered entities allowed.

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    thresholds: {
      statements: 80,
      functions: 80,
      branches: 80,
      lines: -10,
    },
  },
});

When the code coverage is below the specified thresholds, the test will fail and output an error message like below:

Error: Coverage for statements 75% does not meet global threshold 80%
Error: Coverage for functions 75% does not meet global threshold 80%
Error: Coverage for branches 75% does not meet global threshold 80%
Error: Uncovered lines 20 exceeds maximum global threshold allowed 10

#glob pattern

If globs are specified, thresholds will be checked for each matched file pattern. If the file specified by path is not found, an error is returned.

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    thresholds: {
      // Thresholds for matching glob pattern
      'src/**': {
        statements: 100,
      },
      'node/**/*.js': {
        statements: 90,
      },
      // Thresholds for all files
      statements: 80,
    },
  },
});

Following the above configuration, rstest will fail if:

• The total code coverage of all files in src/** is below 100%.
• The total code coverage of all files in node/**/*.js is below 90%.
• The global code coverage is below 80% for statements.

#check threshold for per file

Rstest also supports checking thresholds for each matched file by setting perFile to true.

import { defineConfig } from '@rstest/core';

export default defineConfig({
  coverage: {
    enabled: true,
    thresholds: {
      'src/**': {
        statements: 90,
        perFile: true,
      },
    },
  },
});