karma-coverage
Advanced tools
Package description
The karma-coverage npm package is a plugin for the Karma test runner that generates code coverage reports. It uses Istanbul under the hood to instrument the code and then record the coverage data when the tests are run. The reports can be generated in various formats and can be integrated into continuous integration workflows to ensure code quality.
Coverage Reporting
This feature allows you to generate coverage reports in various formats such as HTML, LCOV, and JSON. The code sample shows how to configure Karma to use the karma-coverage plugin to generate an HTML coverage report.
module.exports = function(config) {
config.set({
// other Karma configuration...
reporters: ['progress', 'coverage'],
preprocessors: {
'**/*.js': ['coverage']
},
coverageReporter: {
type : 'html',
dir : 'coverage/'
}
});
};Threshold Enforcement
This feature allows you to enforce coverage thresholds. If the code does not meet the specified thresholds for statements, branches, functions, or lines, Karma will exit with an error. The code sample demonstrates how to set these thresholds in the Karma configuration.
module.exports = function(config) {
config.set({
// other Karma configuration...
reporters: ['progress', 'coverage'],
coverageReporter: {
check: {
global: {
statements: 80,
branches: 80,
functions: 80,
lines: 80
}
}
}
});
};nyc is the official Istanbul command line interface. It can produce coverage reports similar to karma-coverage but is more often used with Node.js applications directly, rather than through a test runner like Karma.
Jest is a testing framework that includes its own coverage reporting capabilities. It is an alternative to using Karma with karma-coverage, offering a more integrated solution with a focus on simplicity and ease of use.
c8 is a Node.js code coverage tool built on top of V8's built-in coverage. It is similar to nyc but uses the native coverage features of V8, providing potentially more accurate coverage information for Node.js applications.
Changelog
2.0.0 (2019-08-20)
deps: This set of changes may impact some use cases.
chore: Add Updated Istanbul Dependencies
The istanbul package is deprecated in favor several split packages that control different aspects of how istanbul works. This commit adds the recommended packages that will be used in future commits as karma-coverage's usage of istanbul is updated to the latest api.
This commit refactors the in memory report implementation to use the new istanbul report API.
Report creation is removed from newer versions of the istanbul API, so this commit adds a set of utility functions to wrap around the new API and provide similar functionality as the old API. The top level export uses the new utility function to register the in-memory report.
This commit updates the preprocessor to use istanbul-lib-instrument instead of the deprecated istanbul package. The biggest change in this refactor is using a callable function instead of a constructor when creating instrumenters
The old istanbul package exposed the Instrumenter directly, allowing the preprocessor to create an instance of it. istanbul-lib-instrument, however, exposes a callable function that creates an Instrumenter. This commit updates the preprocessor to follow this new pattern of using a callable function. In order to ensure backwards compatibility, a utility function is added to wrap constructors with a callable function for creation automatically.
This change allows the following configuration for creating instrumenters:
This commit also uses the istanbul-lib-source-maps package to handle storing source maps. A global source map store registers source maps so they can be used later on in the reporter.
This commit updates the reporter by using the istanbul-lib-coverage package api for handling coverage checking/management and the istanbul-lib-report package api for handling reporting.
The new apis remove the need for collectors and remove the need to handle disposing collectors.
This commit removes the source-cache-store and source-cache files as they are no longer being used. The source-map-store and istanbul-lib-source-maps are used instead, so these files are no longer needed.
This commit updates the report creator utility to allow resetting the custom reporter map.
This commit updates the preprocessor to properly access file coverage when storing it in the global coverage map (when includeAllSources is true). The previous method did not work because the returned instrumented code from the default istanbul instrumenter returns the coverage map in a POJO object instead of JSON notation. This breaks the coverage regex used to match and parse the coverage map.
The istanbul instrumenter offers the ability to receive the coverage map for the last instrumented file through a separate function, so that is tested for and used if it is supported. The original method is used as a fallback for backwards compatibility.
This commit also addresses changes from the v0 instanbul instrumenter options. The changes are additive only to maintain backwards compatibility for other instrumenters.
This commit fixes errors with accessing data properly during the checkCoverage method. A previous commit updated the implementation to use istanbul-lib-coverage, but this involved an api change to access the raw coverage data (which checkCoverage uses).
This commit also fixes the checking coverage for each file by using a map to store file coverage summaries instead of merging summaries like the global results. Per file coverage now works as expected.
This commit updates the mocking done in unit tests to properly mock the new istanbul API. Additionally, new unit test suites are added for the utility methods report-creator and source-map-store.
:<a name="1.1.2"></a>
Readme
Generate code coverage using Istanbul.
The easiest way is to install karma-coverage as a devDependency,
by running
npm install karma karma-coverage --save-dev
For configuration details see docs/configuration.
// karma.conf.js
module.exports = function(config) {
config.set({
files: [
'src/**/*.js',
'test/**/*.js'
],
// coverage reporter generates the coverage
reporters: ['progress', 'coverage'],
preprocessors: {
// source files, that you wanna generate coverage for
// do not include tests or libraries
// (these files will be instrumented by Istanbul)
'src/**/*.js': ['coverage']
},
// optionally, configure the reporter
coverageReporter: {
type : 'html',
dir : 'coverage/'
}
});
};
For an example on how to use with CoffeeScript
see examples/coffee. For an example of how to use with
CoffeeScript and the RequireJS module loader, see
examples/coffee-requirejs (and also see
the useJSExtensionForCoffeeScript option in
docs/configuration.md).
// karma.conf.js
module.exports = function(config) {
config.set({
files: [
'src/**/*.js',
'test/**/*.js'
],
reporters: ['progress', 'coverage'],
preprocessors: {
'src/**/*.js': ['coverage']
},
coverageReporter: {
// specify a common output directory
dir: 'build/reports/coverage',
reporters: [
// reporters not supporting the `file` property
{ type: 'html', subdir: 'report-html' },
{ type: 'lcov', subdir: 'report-lcov' },
// reporters supporting the `file` property, use `subdir` to directly
// output them in the `dir` directory
{ type: 'cobertura', subdir: '.', file: 'cobertura.txt' },
{ type: 'lcovonly', subdir: '.', file: 'report-lcovonly.txt' },
{ type: 'teamcity', subdir: '.', file: 'teamcity.txt' },
{ type: 'text', subdir: '.', file: 'text.txt' },
{ type: 'text-summary', subdir: '.', file: 'text-summary.txt' },
]
}
});
};
When using the istanbul instrumenter (default), you can disable code compaction by adding the following to your configuration.
// karma.conf.js
module.exports = function(config) {
config.set({
coverageReporter: {
instrumenterOptions: {
istanbul: { noCompact: true }
}
}
});
};
For more information on Karma see the homepage.
FAQs
A Karma plugin. Generate code coverage.
We found that karma-coverage demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 4 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Application Security
New SEC disclosure rules aim to enforce timely cyber incident reporting, but fear of job loss and inadequate resources lead to significant underreporting.
Security News
The Python Software Foundation has secured a 5-year sponsorship from Fastly that supports PSF's activities and events, most notably the security and reliability of the Python Package Index (PyPI).
Security News
LDAPjs, an LDAP Client and Server API for Node.js, was decommissioned after its maintainer received an abusive email from a user, raising concerns about this form of abuse as a potential attack vector.