Testing¶
Test your code!¶
Pylint is very well tested and has a high code coverage. New contributions are not accepted unless they include tests. Pylint uses two types of tests: unittests and functional tests.
The unittests can be found in the
/pylint/test
directory and they can be used for testing almost anything Pylint related.The functional tests can be found in the
/pylint/test/functional
directory. They are mainly used to test whether Pylint emits the correct messages.
Before writing a new test it is often a good idea to ensure that your change isn't breaking a current test. You can run our tests using the tox package, as in:
python -m tox
python -m tox -epy36 # for Python 3.6 suite only
python -m tox -epylint # for running Pylint over Pylint's codebase
python -m tox -eformatting # for running formatting checks over Pylint's codebase
It's usually a good idea to run tox with --recreate
. This flag tells tox to redownload
all dependencies before running the tests. This can be important when a new version of
astroid or any of the other dependencies has been published:
python -m tox --recreate # The entire tox environment will be recreated
python -m tox --recreate -e py310 # The python 3.10 tox environment will be recreated
To run only a specific test suite, use a pattern for the test filename
(without the .py
extension), as in:
python -m tox -e py310 -- -k test_functional
python -m tox -e py310 -- -k \*func\*
python -m tox --recreate -e py310 -- -k test_functional # With recreation of the environment
Since we use pytest to run the tests, you can also use it on its own. We do recommend using the tox command though:
pytest pylint -k test_functional
Writing functional tests¶
These are residing under /pylint/test/functional
and they are formed of multiple
components. First, each Python file is considered to be a test case and it
should be accompanied by a .txt file, having the same name, with the messages
that are supposed to be emitted by the given test file.
In the Python file, each line for which Pylint is supposed to emit a message
has to be annotated with a comment in the form # [message_symbol]
, as in:
a, b, c = 1 # [unbalanced-tuple-unpacking]
If multiple messages are expected on the same line, then this syntax can be used:
a, b, c = 1.test # [unbalanced-tuple-unpacking, no-member]
You can also use # +n: [
with n an integer if the above syntax would make the line too long or other reasons:
# +1: [empty-comment]
#
If you need special control over Pylint's configuration, you can also create a .rc file, which
can have sections of Pylint's configuration.
The .rc file can also contain a section [testoptions]
to pass options for the functional
test runner. The following options are currently supported:
"min_pyver": Minimal python version required to run the test "max_pyver": Python version from which the test won't be run. If the last supported version is 3.9 this setting should be set to 3.10. "min_pyver_end_position": Minimal python version required to check the end_line and end_column attributes of the message "requires": Packages required to be installed locally to run the test "except_implementations": List of python implementations on which the test should not run "exclude_platforms": List of operating systems on which the test should not run
During development, it's sometimes helpful to run all functional tests in your current environment in order to have faster feedback. Run from Pylint root directory with:
python tests/test_functional.py
You can use all the options you would use for pytest, for example -k "test_functional[len_checks]"
.
Furthermore, if required the .txt file with expected messages can be regenerated based
on the the current output by appending --update-functional-output
to the command line:
python tests/test_functional.py --update-functional-output -k "test_functional[len_checks]"
Writing unittest tests¶
Most other tests reside in the '/pylint/test' directory. These unittests can be used to test almost all functionality within Pylint. A good step before writing any new unittests is to look at some tests that test a similar funcitionality. This can often help write new tests.
If your new test requires any additional files you can put those in the
/pylint/test/regrtest_data
directory. This is the directory we use to store any data needed for
the unittests.
Writing functional tests for configurations¶
To test the different ways to configure Pylint there is also a small functional test framework for configuration files. These tests can be found in the '/pylint/test/config' directory.
To create a new test create a new file with an unused name in the directory of that type
of configuration file. Subsequently add a filename.result.json
file with 'filename'
being the same name as your configuration file. This file should record
what the configuration should be compared to the standard configuration.
For example, if the configuration should add a warning to the list of disabled messages
and you changed the configuration for job
to 10 instead of the default 1 the
.json
file should include:
"functional_append": {
"disable": [["a-message-to-be-added"],]
}
"jobs": 10,
Similarly if a message should be removed you can add the following to the .json
file:
"functional_remove": {
"disable": [["a-message-to-be-removed"],]
}
If a configuration is incorrect and should lead to a crash or warning being emitted you can
specify this by adding a .out
file. This file should have the following name
name_of_configuration_testfile.error_code.out
. So, if your test is called bad_configuration.toml
and should exit with exit code 2 the .out
file should be named bad_configuration.2.out
.
The content of the .out
file should have a similar pattern as a normal Pylint output. Note that the
module name should be {abspath}
and the file name {relpath}
.
Primer tests¶
Pylint also uses what we refer to as primer
tests. These are tests that are run automatically
in our Continuous Integration and check whether any changes in Pylint lead to crashes or fatal errors
on the stdlib
and a selection of external repositories.
To run the primer
tests you can add either --primer-stdlib
or --primer-external
to the
pytest command. If you want to only run the primer
you can add either of their marks, for example:
pytest -m primer_stdlib --primer-stdlib
The external primer
has been split up in two marks to speed up our Continuous Integration. You can run
either of the two batches or run them both:
pytest -m primer_external_batch_one --primer-external # Runs batch one
pytest -m primer_external_batch_two --primer-external # Runs batch two
pytest -m "primer_external_batch_one or primer_external_batch_two" --primer-external # Runs both batches
The list of repositories is created on the basis of three criteria: 1) projects need to use a diverse range of language features, 2) projects need to be well maintained and 3) projects should not have a codebase that is too repetitive. This guarantees a good balance between speed of our CI and finding potential bugs.
You can find the latest list of repositories and any relevant code for these tests in the tests/primer
directory.