测试人社区

Pytest-API Reference

This page contains the full reference to pytest’s API.

::: {.contents depth=“3” local=""}
:::

Functions

pytest.approx

::: {.autofunction}
pytest.approx
:::

pytest.fail

Tutorial: skipping{.interpreted-text role=“ref”}

::: {.autofunction}
pytest.fail
:::

pytest.skip

::: {.autofunction}
pytest.skip(msg, [allow_module_level=False])
:::

pytest.importorskip {#pytest.importorskip ref}

::: {.autofunction}
pytest.importorskip
:::

pytest.xfail

::: {.autofunction}
pytest.xfail
:::

pytest.exit

::: {.autofunction}
pytest.exit
:::

pytest.main

::: {.autofunction}
pytest.main
:::

pytest.param

::: {.autofunction}
pytest.param(*values, [id], [marks])
:::

pytest.raises

Tutorial: assertraises{.interpreted-text role=“ref”}.

::: {.autofunction with=“excinfo”}
pytest.raises(expected_exception: Exception [, *, match])
:::

pytest.deprecated_call

Tutorial: ensuring_function_triggers{.interpreted-text
role=“ref”}.

::: {.autofunction with=""}
pytest.deprecated_call()
:::

pytest.register_assert_rewrite

Tutorial: assertion-rewriting{.interpreted-text role=“ref”}.

::: {.autofunction}
pytest.register_assert_rewrite
:::

pytest.warns

Tutorial: assertwarnings{.interpreted-text role=“ref”}

::: {.autofunction with=""}
pytest.warns(expected_warning: Exception, [match])
:::

pytest.freeze_includes

Tutorial: freezing-pytest{.interpreted-text role=“ref”}.

::: {.autofunction}
pytest.freeze_includes
:::

Marks {#marks ref}

Marks can be used apply meta data to test functions (but not
fixtures), which can then be accessed by fixtures or plugins.

pytest.mark.filterwarnings {#pytest.mark.filterwarnings ref}

Tutorial: filterwarnings{.interpreted-text role=“ref”}.

Add warning filters to marked test items.

pytest.mark.parametrize {#pytest.mark.parametrize ref}

Tutorial: parametrize{.interpreted-text role=“doc”}.

This mark has the same signature as
:py_pytest.python.Metafunc.parametrize{.interpreted-text role=“meth”};
see there.

pytest.mark.skip {#pytest.mark.skip ref}

Tutorial: skip{.interpreted-text role=“ref”}.

Unconditionally skip a test function.

pytest.mark.skipif {#pytest.mark.skipif ref}

Tutorial: skipif{.interpreted-text role=“ref”}.

Skip a test function if a condition is True.

pytest.mark.usefixtures {#pytest.mark.usefixtures ref}

Tutorial: usefixtures{.interpreted-text role=“ref”}.

Mark a test function as using the given fixture names.

::: {.note}
::: {.title}
Note
:::

When using [usefixtures]{.title-ref} in hooks, it can only load fixtures
when applied to a test function before test setup (for example in the
[pytest_collection_modifyitems]{.title-ref} hook).

Also note that this mark has no effect when applied to fixtures.
:::

pytest.mark.xfail {#pytest.mark.xfail ref}

Tutorial: xfail{.interpreted-text role=“ref”}.

Marks a test function as expected to fail.

Custom marks

Marks are created dynamically using the factory object pytest.mark and
applied as a decorator.

For example:

@pytest.mark.timeout(10, "slow", method="thread")
def test_function():
    ...

Will create and attach a
Mark <_pytest.mark.structures.Mark>{.interpreted-text role=“class”}
object to the collected Item <pytest.Item>{.interpreted-text
role=“class”}, which can then be accessed by fixtures or hooks with
Node.iter_markers <_pytest.nodes.Node.iter_markers>{.interpreted-text
role=“meth”}. The mark object will have the following attributes:

Fixtures {#fixtures-api}

Tutorial: fixture{.interpreted-text role=“ref”}.

Fixtures are requested by test functions or other fixtures by declaring
them as argument names.

Example of a test requiring a fixture:

def test_output(capsys):
    print("hello")
    out, err = capsys.readouterr()

Example of a fixture requiring another fixture:

@pytest.fixture
def db_session(tmpdir):
    fn = tmpdir / "db.file"
    return connect(str(fn))

For more details, consult the full
fixtures docs <fixture>{.interpreted-text role=“ref”}.

@pytest.fixture {#pytest.fixture-api}

::: {.autofunction decorator=""}
pytest.fixture
:::

::: {.fixture}
cache
:::

config.cache

Tutorial: cache{.interpreted-text role=“ref”}.

The config.cache object allows other plugins and fixtures to store and
retrieve values across test runs. To access it from fixtures request
pytestconfig into your fixture and get it with pytestconfig.cache.

Under the hood, the cache plugin uses the simple dumps/loads API of
the :pyjson{.interpreted-text role=“mod”} stdlib module.

::: {.currentmodule}
_pytest.cacheprovider
:::

::: {.automethod}
Cache.get
:::

::: {.automethod}
Cache.set
:::

::: {.automethod}
Cache.makedir
:::

::: {.fixture}
capsys
:::

capsys

Tutorial: capture{.interpreted-text role=“doc”}.

::: {.currentmodule}
_pytest.capture
:::

::: {.autofunction no-auto-options=""}
capsys()

Returns an instance of :pyCaptureFixture{.interpreted-text
role=“class”}.

Example:

def test_output(capsys):
    print("hello")
    captured = capsys.readouterr()

:::

::: {.autoclass members=""}
CaptureFixture()
:::

::: {.fixture}
capsysbinary
:::

capsysbinary

Tutorial: capture{.interpreted-text role=“doc”}.

::: {.autofunction no-auto-options=""}
capsysbinary()

Returns an instance of :pyCaptureFixture{.interpreted-text
role=“class”}.

Example:

def test_output(capsysbinary):
    print("hello")
    captured = capsysbinary.readouterr()

:::

::: {.fixture}
capfd
:::

capfd

Tutorial: capture{.interpreted-text role=“doc”}.

::: {.autofunction no-auto-options=""}
capfd()

Returns an instance of :pyCaptureFixture{.interpreted-text
role=“class”}.

Example:

def test_system_echo(capfd):
    os.system('echo "hello"')
    captured = capfd.readouterr()

:::

::: {.fixture}
capfdbinary
:::

capfdbinary

Tutorial: capture{.interpreted-text role=“doc”}.

::: {.autofunction no-auto-options=""}
capfdbinary()

Returns an instance of :pyCaptureFixture{.interpreted-text
role=“class”}.

Example:

def test_system_echo(capfdbinary):
    os.system('echo "hello"')
    captured = capfdbinary.readouterr()

:::

::: {.fixture}
doctest_namespace
:::

doctest_namespace

Tutorial: doctest{.interpreted-text role=“doc”}.

::: {.autofunction}
_pytest.doctest.doctest_namespace()

Usually this fixture is used in conjunction with another autouse
fixture:

@pytest.fixture(autouse=True)
def add_np(doctest_namespace):
    doctest_namespace["np"] = numpy

For more details: doctest_namespace{.interpreted-text role=“ref”}.
:::

::: {.fixture}
request
:::

request

Tutorial: request example{.interpreted-text role=“ref”}.

The request fixture is a special fixture providing information of the
requesting test function.

::: {.autoclass members=""}
_pytest.fixtures.FixtureRequest()
:::

::: {.fixture}
pytestconfig
:::

pytestconfig

::: {.autofunction}
_pytest.fixtures.pytestconfig()
:::

::: {.fixture}
record_property
:::

record_property

Tutorial: record_property example{.interpreted-text role=“ref”}.

::: {.autofunction}
_pytest.junitxml.record_property()
:::

::: {.fixture}
record_testsuite_property
:::

record_testsuite_property

Tutorial: record_testsuite_property example{.interpreted-text
role=“ref”}.

::: {.autofunction}
_pytest.junitxml.record_testsuite_property()
:::

::: {.fixture}
caplog
:::

caplog

Tutorial: logging{.interpreted-text role=“doc”}.

::: {.autofunction no-auto-options=""}
_pytest.logging.caplog()

Returns a _pytest.logging.LogCaptureFixture{.interpreted-text
role=“class”} instance.
:::

::: {.autoclass members=""}
_pytest.logging.LogCaptureFixture
:::

::: {.fixture}
monkeypatch
:::

monkeypatch

Tutorial: monkeypatch{.interpreted-text role=“doc”}.

::: {.autofunction no-auto-options=""}
_pytest.monkeypatch.monkeypatch()

Returns a ~pytest.MonkeyPatch{.interpreted-text role=“class”}
instance.
:::

::: {.autoclass members=""}
pytest.MonkeyPatch
:::

::: {.fixture}
pytester
:::

pytester

::: {.versionadded}
6.2
:::

::: {.currentmodule}
_pytest.pytester
:::

Provides a Pytester{.interpreted-text role=“class”} instance that can
be used to run and test pytest itself.

It provides an empty directory where pytest can be executed in
isolation, and contains facilities to write tests, configuration files,
and match against expected output.

To use it, include in your topmost conftest.py file:

pytest_plugins = "pytester"

::: {.autoclass members=""}
Pytester()
:::

::: {.autoclass members=""}
RunResult()
:::

::: {.autoclass members="" special-members=“str”}
LineMatcher()
:::

::: {.autoclass members=""}
HookRecorder()
:::

::: {.fixture}
testdir
:::

testdir

Identical to pytester{.interpreted-text role=“fixture”}, but provides
an instance whose methods return legacy py.path.local objects instead
when applicable.

New code should avoid using testdir{.interpreted-text role=“fixture”}
in favor of pytester{.interpreted-text role=“fixture”}.

::: {.autoclass members=""}
Testdir()
:::

::: {.fixture}
recwarn
:::

recwarn

Tutorial: assertwarnings{.interpreted-text role=“ref”}

::: {.currentmodule}
_pytest.recwarn
:::

::: {.autofunction no-auto-options=""}
recwarn()
:::

::: {.autoclass members=""}
WarningsRecorder()
:::

Each recorded warning is an instance of
warnings.WarningMessage{.interpreted-text role=“class”}.

::: {.note}
::: {.title}
Note
:::

DeprecationWarning and PendingDeprecationWarning are treated
differently; see ensuring_function_triggers{.interpreted-text
role=“ref”}.
:::

::: {.fixture}
tmp_path
:::

tmp_path

Tutorial: tmpdir{.interpreted-text role=“doc”}

::: {.currentmodule}
_pytest.tmpdir
:::

::: {.autofunction no-auto-options=""}
tmp_path()
:::

::: {.fixture}
tmp_path_factory
:::

tmp_path_factory

Tutorial: tmp_path_factory example{.interpreted-text role=“ref”}

::: {#tmp_path_factory factory api}
tmp_path_factory instances have the following methods:
:::

::: {.currentmodule}
_pytest.tmpdir
:::

::: {.automethod}
TempPathFactory.mktemp
:::

::: {.automethod}
TempPathFactory.getbasetemp
:::

::: {.fixture}
tmpdir
:::

tmpdir

Tutorial: tmpdir{.interpreted-text role=“doc”}

::: {.currentmodule}
_pytest.tmpdir
:::

::: {.autofunction no-auto-options=""}
tmpdir()
:::

::: {.fixture}
tmpdir_factory
:::

tmpdir_factory

Tutorial: tmpdir factory example{.interpreted-text role=“ref”}

::: {#tmpdir factory api}
tmpdir_factory instances have the following methods:
:::

::: {.currentmodule}
_pytest.tmpdir
:::

::: {.automethod}
TempdirFactory.mktemp
:::

::: {.automethod}
TempdirFactory.getbasetemp
:::

Hooks {#hook-reference}

Tutorial: writing_plugins{.interpreted-text role=“doc”}.

::: {.currentmodule}
_pytest.hookspec
:::

Reference to all hooks which can be implemented by
conftest.py files <localplugin>{.interpreted-text role=“ref”} and
plugins <plugins>{.interpreted-text role=“ref”}.

Bootstrapping hooks

Bootstrapping hooks called for plugins registered early enough (internal
and setuptools plugins).

::: {.autofunction}
pytest_load_initial_conftests
:::

::: {.autofunction}
pytest_cmdline_preparse
:::

::: {.autofunction}
pytest_cmdline_parse
:::

::: {.autofunction}
pytest_cmdline_main
:::

Initialization hooks

Initialization hooks called for plugins and conftest.py files.

::: {.autofunction}
pytest_addoption
:::

::: {.autofunction}
pytest_addhooks
:::

::: {.autofunction}
pytest_configure
:::

::: {.autofunction}
pytest_unconfigure
:::

::: {.autofunction}
pytest_sessionstart
:::

::: {.autofunction}
pytest_sessionfinish
:::

::: {.autofunction}
pytest_plugin_registered
:::

Collection hooks

pytest calls the following hooks for collecting files and directories:

::: {.autofunction}
pytest_collection
:::

::: {.autofunction}
pytest_ignore_collect
:::

::: {.autofunction}
pytest_collect_file
:::

::: {.autofunction}
pytest_pycollect_makemodule
:::

For influencing the collection of objects in Python modules you can use
the following hook:

::: {.autofunction}
pytest_pycollect_makeitem
:::

::: {.autofunction}
pytest_generate_tests
:::

::: {.autofunction}
pytest_make_parametrize_id
:::

After collection is complete, you can modify the order of items, delete
or otherwise amend the test items:

::: {.autofunction}
pytest_collection_modifyitems
:::

::: {.note}
::: {.title}
Note
:::

If this hook is implemented in conftest.py files, it always receives
all collected items, not only those under the conftest.py where it is
implemented.
:::

::: {.autofunction}
pytest_collection_finish
:::

Test running (runtest) hooks

All runtest related hooks receive a
:pypytest.Item <pytest.Item>{.interpreted-text role=“class”} object.

::: {.autofunction}
pytest_runtestloop
:::

::: {.autofunction}
pytest_runtest_protocol
:::

::: {.autofunction}
pytest_runtest_logstart
:::

::: {.autofunction}
pytest_runtest_logfinish
:::

::: {.autofunction}
pytest_runtest_setup
:::

::: {.autofunction}
pytest_runtest_call
:::

::: {.autofunction}
pytest_runtest_teardown
:::

::: {.autofunction}
pytest_runtest_makereport
:::

For deeper understanding you may look at the default implementation of
these hooks in _pytest.runner and maybe also in _pytest.pdb which
interacts with _pytest.capture and its input/output capturing in order
to immediately drop into interactive debugging when a test failure
occurs.

::: {.autofunction}
pytest_pyfunc_call
:::

Reporting hooks

Session related reporting hooks:

::: {.autofunction}
pytest_collectstart
:::

::: {.autofunction}
pytest_make_collect_report
:::

::: {.autofunction}
pytest_itemcollected
:::

::: {.autofunction}
pytest_collectreport
:::

::: {.autofunction}
pytest_deselected
:::

::: {.autofunction}
pytest_report_header
:::

::: {.autofunction}
pytest_report_collectionfinish
:::

::: {.autofunction}
pytest_report_teststatus
:::

::: {.autofunction}
pytest_terminal_summary
:::

::: {.autofunction}
pytest_fixture_setup
:::

::: {.autofunction}
pytest_fixture_post_finalizer
:::

::: {.autofunction}
pytest_warning_captured
:::

::: {.autofunction}
pytest_warning_recorded
:::

Central hook for reporting about test execution:

::: {.autofunction}
pytest_runtest_logreport
:::

Assertion related hooks:

::: {.autofunction}
pytest_assertrepr_compare
:::

::: {.autofunction}
pytest_assertion_pass
:::

Debugging/Interaction hooks

There are few hooks which can be used for special reporting or
interaction with exceptions:

::: {.autofunction}
pytest_internalerror
:::

::: {.autofunction}
pytest_keyboard_interrupt
:::

::: {.autofunction}
pytest_exception_interact
:::

::: {.autofunction}
pytest_enter_pdb
:::

Objects

Full reference to objects accessible from
fixtures <fixture>{.interpreted-text role=“ref”} or
hooks <hook-reference>{.interpreted-text role=“ref”}.

CallInfo

::: {.autoclass members=""}
_pytest.runner.CallInfo()
:::

Class

::: {.autoclass members="" show-inheritance=""}
pytest.Class()
:::

Collector

::: {.autoclass members="" show-inheritance=""}
pytest.Collector()
:::

CollectReport

::: {.autoclass members="" show-inheritance="" inherited-members=""}
_pytest.reports.CollectReport()
:::

Config

::: {.autoclass members=""}
_pytest.config.Config()
:::

ExceptionInfo

::: {.autoclass members=""}
_pytest._code.ExceptionInfo
:::

ExitCode

::: {.autoclass members=""}
pytest.ExitCode
:::

File

::: {.autoclass members="" show-inheritance=""}
pytest.File()
:::

FixtureDef

::: {.autoclass members="" show-inheritance=""}
_pytest.fixtures.FixtureDef()
:::

FSCollector

::: {.autoclass members="" show-inheritance=""}
_pytest.nodes.FSCollector()
:::

Function

::: {.autoclass members="" show-inheritance=""}
pytest.Function()
:::

FunctionDefinition

::: {.autoclass members="" show-inheritance=""}
_pytest.python.FunctionDefinition()
:::

Item

::: {.autoclass members="" show-inheritance=""}
pytest.Item()
:::

MarkDecorator

::: {.autoclass members=""}
_pytest.mark.MarkDecorator
:::

MarkGenerator

::: {.autoclass members=""}
_pytest.mark.MarkGenerator
:::

Mark

::: {.autoclass members=""}
_pytest.mark.structures.Mark
:::

Metafunc

::: {.autoclass members=""}
_pytest.python.Metafunc
:::

Module

::: {.autoclass members="" show-inheritance=""}
pytest.Module()
:::

Node

::: {.autoclass members=""}
_pytest.nodes.Node()
:::

Parser

::: {.autoclass members=""}
_pytest.config.argparsing.Parser()
:::

PytestPluginManager

::: {.autoclass members="" undoc-members="" inherited-members="" show-inheritance=""}
_pytest.config.PytestPluginManager()
:::

Session

::: {.autoclass members="" show-inheritance=""}
pytest.Session()
:::

TestReport

::: {.autoclass members="" show-inheritance="" inherited-members=""}
_pytest.reports.TestReport()
:::

_Result

Result used within hook wrappers <hookwrapper>{.interpreted-text
role=“ref”}.

::: {.autoclass}
pluggy.callers._Result
:::

::: {.automethod}
pluggy.callers._Result.get_result
:::

::: {.automethod}
pluggy.callers._Result.force_result
:::

Global Variables

pytest treats some global variables in a special manner when defined in
a test module or conftest.py files.

::: {.globalvar}
collect_ignore
:::

Tutorial: customizing-test-collection{.interpreted-text
role=“ref”}

Can be declared in conftest.py files to exclude test directories or
modules. Needs to be list[str].

collect_ignore = ["setup.py"]

::: {.globalvar}
collect_ignore_glob
:::

Tutorial: customizing-test-collection{.interpreted-text
role=“ref”}

Can be declared in conftest.py files to exclude test directories or
modules with Unix shell-style wildcards. Needs to be list[str] where
str can contain glob patterns.

collect_ignore_glob = ["*_ignore.py"]

::: {.globalvar}
pytest_plugins
:::

Tutorial: available installable plugins{.interpreted-text
role=“ref”}

Can be declared at the global level in test modules and
conftest.py files to register additional plugins. Can be either a
str or Sequence[str].

pytest_plugins = "myapp.testsupport.myplugin"
pytest_plugins = ("myapp.testsupport.tools", "myapp.testsupport.regression")

::: {.globalvar}
pytestmark
:::

Tutorial: scoped-marking{.interpreted-text role=“ref”}

Can be declared at the global level in test modules to apply one
or more marks <marks ref>{.interpreted-text role=“ref”} to all test
functions and methods. Can be either a single mark or a list of marks
(applied in left-to-right order).

import pytest

pytestmark = pytest.mark.webtest
import pytest

pytestmark = [pytest.mark.integration, pytest.mark.slow]

Environment Variables

Environment variables that can be used to change pytest’s behavior.

::: {.envvar}
PYTEST_ADDOPTS
:::

This contains a command-line (parsed by the pyshlex{.interpreted-text
role=“mod”} module) that will be prepended to the command line given
by the user, see adding default options{.interpreted-text role=“ref”}
for more information.

::: {.envvar}
PYTEST_CURRENT_TEST
:::

This is not meant to be set by users, but is set by pytest internally
with the name of the current test so other processes can inspect it, see
pytest current test env{.interpreted-text role=“ref”} for more
information.

::: {.envvar}
PYTEST_DEBUG
:::

When set, pytest will print tracing and debug information.

::: {.envvar}
PYTEST_DISABLE_PLUGIN_AUTOLOAD
:::

When set, disables plugin auto-loading through setuptools entrypoints.
Only explicitly specified plugins will be loaded.

::: {.envvar}
PYTEST_PLUGINS
:::

Contains comma-separated list of modules that should be loaded as
plugins:

export PYTEST_PLUGINS=mymodule.plugin,xdist

::: {.envvar}
PY_COLORS
:::

When set to 1, pytest will use color in terminal output. When set to
0, pytest will not use color. PY_COLORS takes precedence over
NO_COLOR and FORCE_COLOR.

::: {.envvar}
NO_COLOR
:::

When set (regardless of value), pytest will not use color in terminal
output. PY_COLORS takes precedence over NO_COLOR, which takes
precedence over FORCE_COLOR. See no-color.org
for other libraries supporting this community standard.

::: {.envvar}
FORCE_COLOR
:::

When set (regardless of value), pytest will use color in terminal
output. PY_COLORS and NO_COLOR take precedence over FORCE_COLOR.

Exceptions

::: {.autoclass show-inheritance=""}
pytest.UsageError()
:::

Warnings {#warnings ref}

Custom warnings generated in some situations such as improper usage or
deprecated features.

::: {.autoclass show-inheritance=""}
pytest.PytestWarning
:::

::: {.autoclass show-inheritance=""}
pytest.PytestAssertRewriteWarning
:::

::: {.autoclass show-inheritance=""}
pytest.PytestCacheWarning
:::

::: {.autoclass show-inheritance=""}
pytest.PytestCollectionWarning
:::

::: {.autoclass show-inheritance=""}
pytest.PytestConfigWarning
:::

::: {.autoclass show-inheritance=""}
pytest.PytestDeprecationWarning
:::

::: {.autoclass show-inheritance=""}
pytest.PytestExperimentalApiWarning
:::

::: {.autoclass show-inheritance=""}
pytest.PytestUnhandledCoroutineWarning
:::

::: {.autoclass show-inheritance=""}
pytest.PytestUnknownMarkWarning
:::

Consult the internal-warnings{.interpreted-text role=“ref”} section in
the documentation for more information.

Configuration Options {#ini options ref}

Here is a list of builtin configuration options that may be written in a
pytest.ini, pyproject.toml, tox.ini or setup.cfg file, usually
located at the root of your repository. To see each file format in
details, see config file formats{.interpreted-text role=“ref”}.

::: {.warning}
::: {.title}
Warning
:::

Usage of setup.cfg is not recommended except for very simple use
cases. .cfg files use a different parser than pytest.ini and
tox.ini which might cause hard to track down problems. When possible,
it is recommended to use the latter files, or pyproject.toml, to hold
your pytest configuration.
:::

Configuration options may be overwritten in the command-line by using
-o/--override-ini, which can also be passed multiple times. The
expected format is name=value. For example:

pytest -o console_output_style=classic -o cache_dir=/tmp/mycache

::: {.confval}
addopts

Add the specified OPTS to the set of command line arguments as if they
had been specified by the user. Example: if you have this ini file
content:

# content of pytest.ini
[pytest]
addopts = --maxfail=2 -rf  # exit after 2 failures, report fail info

issuing pytest test_hello.py actually means:

pytest --maxfail=2 -rf test_hello.py

Default is to add no options.
:::

::: {.confval}
cache_dir

Sets a directory where stores content of cache plugin. Default directory
is .pytest_cache which is created in
rootdir <rootdir>{.interpreted-text role=“ref”}. Directory may be
relative or absolute path. If setting relative path, then directory is
created relative to rootdir <rootdir>{.interpreted-text role=“ref”}.
Additionally path may contain environment variables, that will be
expanded. For more information about cache plugin please refer to
cache_provider{.interpreted-text role=“ref”}.
:::

::: {.confval}
confcutdir

Sets a directory where search upwards for conftest.py files stops. By
default, pytest will stop searching for conftest.py files upwards from
pytest.ini/tox.ini/setup.cfg of the project if any, or up to the
file-system root.
:::

::: {.confval}
console_output_style

Sets the console output style while running tests:

  • classic: classic pytest output.
  • progress: like classic pytest output, but with a progress
    indicator.
  • count: like progress, but shows progress as the number of tests
    completed instead of a percent.

The default is progress, but you can fallback to classic if you
prefer or the new mode is causing unexpected problems:

# content of pytest.ini
[pytest]
console_output_style = classic

:::

::: {.confval}
doctest_encoding

Default encoding to use to decode text files with docstrings.
See how pytest handles doctests <doctest>{.interpreted-text
role=“doc”}.
:::

::: {.confval}
doctest_optionflags

One or more doctest flag names from the standard doctest module.
See how pytest handles doctests <doctest>{.interpreted-text
role=“doc”}.
:::

::: {.confval}
empty_parameter_set_mark

Allows to pick the action for empty parametersets in parameterization

  • skip skips tests with an empty parameterset (default)
  • xfail marks tests with an empty parameterset as xfail(run=False)
  • fail_at_collect raises an exception if parametrize collects an
    empty parameter set
# content of pytest.ini
[pytest]
empty_parameter_set_mark = xfail

::: {.note}
::: {.title}
Note
:::

The default value of this option is planned to change to xfail in
future releases as this is considered less error prone, see
#3155 for more
details.
:::
:::

::: {.confval}
faulthandler_timeout

Dumps the tracebacks of all threads if a test takes longer than X
seconds to run (including fixture setup and teardown). Implemented using
the
faulthandler.dump_traceback_later
function, so all caveats there apply.

# content of pytest.ini
[pytest]
faulthandler_timeout=5

For more information please refer to faulthandler{.interpreted-text
role=“ref”}.
:::

::: {.confval}
filterwarnings

Sets a list of filters and actions that should be taken for matched
warnings. By default all warnings emitted during the test session will
be displayed in a summary at the end of the test session.

# content of pytest.ini
[pytest]
filterwarnings =
    error
    ignore::DeprecationWarning

This tells pytest to ignore deprecation warnings and turn all other
warnings into errors. For more information please refer to
warnings{.interpreted-text role=“ref”}.
:::

::: {.confval}
junit_duration_report

::: {.versionadded}
4.1
:::

Configures how durations are recorded into the JUnit XML report:

  • total (the default): duration times reported include setup, call,
    and teardown times.
  • call: duration times reported include only call times, excluding
    setup and teardown.
[pytest]
junit_duration_report = call

:::

::: {.confval}
junit_family

::: {.versionadded}
4.2
:::

::: {.versionchanged}
6.1 Default changed to xunit2.
:::

Configures the format of the generated JUnit XML file. The possible
options are:

  • xunit1 (or legacy): produces old style output, compatible with
    the xunit 1.0 format.
  • xunit2: produces xunit 2.0 style
    output
    ,
    which should be more compatible with latest Jenkins versions. This
    is the default
    .
[pytest]
junit_family = xunit2

:::

::: {.confval}
junit_logging

::: {.versionadded}
3.5
:::

::: {.versionchanged}
5.4 log, all, out-err options added.
:::

Configures if captured output should be written to the JUnit XML file.
Valid values are:

  • log: write only logging captured output.
  • system-out: write captured stdout contents.
  • system-err: write captured stderr contents.
  • out-err: write both captured stdout and stderr contents.
  • all: write captured logging, stdout and stderr contents.
  • no (the default): no captured output is written.
[pytest]
junit_logging = system-out

:::

::: {.confval}
junit_log_passing_tests

::: {.versionadded}
4.6
:::

If junit_logging != "no", configures if the captured output should be
written to the JUnit XML file for passing tests. Default is True.

[pytest]
junit_log_passing_tests = False

:::

::: {.confval}
junit_suite_name

To set the name of the root test suite xml item, you can configure the
junit_suite_name option in your config file:

[pytest]
junit_suite_name = my_suite

:::

::: {.confval}
log_auto_indent

Allow selective auto-indentation of multiline log messages.

Supports command line option --log-auto-indent [value] and config
option log_auto_indent = [value] to set the auto-indentation behavior
for all logging.

[value] can be:

: - True or “On” - Dynamically auto-indent multiline log messages
- False or “Off” or 0 - Do not auto-indent multiline log
messages (the default behavior)
- [positive integer] - auto-indent multiline log messages by
[value] spaces

[pytest]
log_auto_indent = False

Supports passing kwarg extra={"auto_indent": [value]} to calls to
logging.log() to specify auto-indentation behavior for a specific
entry in the log. extra kwarg overrides the value specified on the
command line or in the config.
:::

::: {.confval}
log_cli

Enable log display during test run (also known as
"live logging" <live_logs>{.interpreted-text role=“ref”}). The default
is False.

[pytest]
log_cli = True

:::

::: {.confval}
log_cli_date_format

Sets a :pytime.strftime{.interpreted-text role=“func”}-compatible
string that will be used when formatting dates for live logging.

[pytest]
log_cli_date_format = %Y-%m-%d %H:%M:%S

For more information, see live_logs{.interpreted-text role=“ref”}.
:::

::: {.confval}
log_cli_format

Sets a :pylogging{.interpreted-text role=“mod”}-compatible string used
to format live logging messages.

[pytest]
log_cli_format = %(asctime)s %(levelname)s %(message)s

For more information, see live_logs{.interpreted-text role=“ref”}.
:::

::: {.confval}
log_cli_level

Sets the minimum log message level that should be captured for live
logging. The integer value or the names of the levels can be used.

[pytest]
log_cli_level = INFO

For more information, see live_logs{.interpreted-text role=“ref”}.
:::

::: {.confval}
log_date_format

Sets a :pytime.strftime{.interpreted-text role=“func”}-compatible
string that will be used when formatting dates for logging capture.

[pytest]
log_date_format = %Y-%m-%d %H:%M:%S

For more information, see logging{.interpreted-text role=“ref”}.
:::

::: {.confval}
log_file

Sets a file name relative to the pytest.ini file where log messages
should be written to, in addition to the other logging facilities that
are active.

[pytest]
log_file = logs/pytest-logs.txt

For more information, see logging{.interpreted-text role=“ref”}.
:::

::: {.confval}
log_file_date_format

Sets a :pytime.strftime{.interpreted-text role=“func”}-compatible
string that will be used when formatting dates for the logging file.

[pytest]
log_file_date_format = %Y-%m-%d %H:%M:%S

For more information, see logging{.interpreted-text role=“ref”}.
:::

::: {.confval}
log_file_format

Sets a :pylogging{.interpreted-text role=“mod”}-compatible string used
to format logging messages redirected to the logging file.

[pytest]
log_file_format = %(asctime)s %(levelname)s %(message)s

For more information, see logging{.interpreted-text role=“ref”}.
:::

::: {.confval}
log_file_level

Sets the minimum log message level that should be captured for the
logging file. The integer value or the names of the levels can be used.

[pytest]
log_file_level = INFO

For more information, see logging{.interpreted-text role=“ref”}.
:::

::: {.confval}
log_format

Sets a :pylogging{.interpreted-text role=“mod”}-compatible string used
to format captured logging messages.

[pytest]
log_format = %(asctime)s %(levelname)s %(message)s

For more information, see logging{.interpreted-text role=“ref”}.
:::

::: {.confval}
log_level

Sets the minimum log message level that should be captured for logging
capture. The integer value or the names of the levels can be used.

[pytest]
log_level = INFO

For more information, see logging{.interpreted-text role=“ref”}.
:::

::: {.confval}
markers

When the --strict-markers or --strict command-line arguments are
used, only known markers - defined in code by core pytest or some plugin

  • are allowed.

You can list additional markers in this setting to add them to the
whitelist, in which case you probably want to add --strict-markers to
addopts to avoid future regressions:

[pytest]
addopts = --strict-markers
markers =
    slow
    serial

::: {.note}
::: {.title}
Note
:::

The use of --strict-markers is highly preferred. --strict was kept
for backward compatibility only and may be confusing for others as it
only applies to markers and not to other options.
:::
:::

::: {.confval}
minversion

Specifies a minimal pytest version required for running tests.

# content of pytest.ini
[pytest]
minversion = 3.0  # will fail if we run with pytest-2.8

:::

::: {.confval}
norecursedirs

Set the directory basename patterns to avoid when recursing for test
discovery. The individual (fnmatch-style) patterns are applied to the
basename of a directory to decide if to recurse into it. Pattern
matching characters:

*       matches everything
?       matches any single character
[seq]   matches any character in seq
[!seq]  matches any char not in seq

Default patterns are '*.egg', '.*', '_darcs', 'build', 'CVS',
'dist', 'node_modules', 'venv', '{arch}'. Setting a
norecursedirs replaces the default. Here is an example of how to avoid
certain directories:

[pytest]
norecursedirs = .svn _build tmp*

This would tell pytest to not look into typical subversion or
sphinx-build directories or into any tmp prefixed directory.

Additionally, pytest will attempt to intelligently identify and ignore
a virtualenv by the presence of an activation script. Any directory
deemed to be the root of a virtual environment will not be considered
during test collection unless ‑‑collect‑in‑virtualenv is given. Note
also that norecursedirs takes precedence over
‑‑collect‑in‑virtualenv; e.g. if you intend to run tests in a
virtualenv with a base directory that matches '.*' you must override
norecursedirs in addition to using the ‑‑collect‑in‑virtualenv flag.
:::

::: {.confval}
python_classes

One or more name prefixes or glob-style patterns determining which
classes are considered for test collection. Search for multiple glob
patterns by adding a space between patterns. By default, pytest will
consider any class prefixed with Test as a test collection. Here is an
example of how to collect tests from classes that end in Suite:

[pytest]
python_classes = *Suite

Note that unittest.TestCase derived classes are always collected
regardless of this option, as unittest's own collection framework is
used to collect those tests.
:::

::: {.confval}
python_files

One or more Glob-style file patterns determining which python files are
considered as test modules. Search for multiple glob patterns by adding
a space between patterns:

[pytest]
python_files = test_*.py check_*.py example_*.py

Or one per line:

[pytest]
python_files =
    test_*.py
    check_*.py
    example_*.py

By default, files matching test_*.py and *_test.py will be
considered test modules.
:::

::: {.confval}
python_functions

One or more name prefixes or glob-patterns determining which test
functions and methods are considered tests. Search for multiple glob
patterns by adding a space between patterns. By default, pytest will
consider any function prefixed with test as a test. Here is an example
of how to collect test functions and methods that end in _test:

[pytest]
python_functions = *_test

Note that this has no effect on methods that live on a
unittest .TestCase derived class, as unittest's own collection
framework is used to collect those tests.

See change naming conventions{.interpreted-text role=“ref”} for more
detailed examples.
:::

::: {.confval}
required_plugins

A space separated list of plugins that must be present for pytest to
run. Plugins can be listed with or without version specifiers directly
following their name. Whitespace between different version specifiers is
not allowed. If any one of the plugins is not found, emit an error.

[pytest]
required_plugins = pytest-django>=3.0.0,<4.0.0 pytest-html pytest-xdist>=1.0.0

:::

::: {.confval}
testpaths

Sets list of directories that should be searched for tests when no
specific directories, files or test ids are given in the command line
when executing pytest from the rootdir <rootdir>{.interpreted-text
role=“ref”} directory. Useful when all project tests are in a known
location to speed up test collection and to avoid picking up undesired
tests by accident.

[pytest]
testpaths = testing doc

This tells pytest to only look for tests in testing and doc
directories when executing from the root directory.
:::

::: {.confval}
usefixtures

List of fixtures that will be applied to all test functions; this is
semantically the same to apply the @pytest.mark.usefixtures marker to
all test functions.

[pytest]
usefixtures =
    clean_db

:::

::: {.confval}
xfail_strict

If set to True, tests marked with @pytest.mark.xfail that actually
succeed will by default fail the test suite. For more information, see
xfail strict tutorial{.interpreted-text role=“ref”}.

[pytest]
xfail_strict = True

:::

Command-line Flags

All the command-line flags can be obtained by running pytest --help:

$ pytest --help
usage: pytest [options] [file_or_dir] [file_or_dir] [...]

positional arguments:
  file_or_dir

general:
  -k EXPRESSION         only run tests which match the given substring
                        expression. An expression is a python evaluatable
                        expression where all names are substring-matched
                        against test names and their parent classes.
                        Example: -k 'test_method or test_other' matches all
                        test functions and classes whose name contains
                        'test_method' or 'test_other', while -k 'not
                        test_method' matches those that don't contain
                        'test_method' in their names. -k 'not test_method
                        and not test_other' will eliminate the matches.
                        Additionally keywords are matched to classes and
                        functions containing extra names in their
                        'extra_keyword_matches' set, as well as functions
                        which have names assigned directly to them. The
                        matching is case-insensitive.
  -m MARKEXPR           only run tests matching given mark expression.
                        For example: -m 'mark1 and not mark2'.
  --markers             show markers (builtin, plugin and per-project ones).
  -x, --exitfirst       exit instantly on first error or failed test.
  --fixtures, --funcargs
                        show available fixtures, sorted by plugin appearance
                        (fixtures with leading '_' are only shown with '-v')
  --fixtures-per-test   show fixtures per test
  --pdb                 start the interactive Python debugger on errors or
                        KeyboardInterrupt.
  --pdbcls=modulename:classname
                        start a custom interactive Python debugger on
                        errors. For example:
                        --pdbcls=IPython.terminal.debugger:TerminalPdb
  --trace               Immediately break when running each test.
  --capture=method      per-test capturing method: one of fd|sys|no|tee-sys.
  -s                    shortcut for --capture=no.
  --runxfail            report the results of xfail tests as if they were
                        not marked
  --lf, --last-failed   rerun only the tests that failed at the last run (or
                        all if none failed)
  --ff, --failed-first  run all tests, but run the last failures first.
                        This may re-order tests and thus lead to repeated
                        fixture setup/teardown.
  --nf, --new-first     run tests from new files first, then the rest of the
                        tests sorted by file mtime
  --cache-show=[CACHESHOW]
                        show cache contents, don't perform collection or
                        tests. Optional argument: glob (default: '*').
  --cache-clear         remove all cache contents at start of test run.
  --lfnf={all,none}, --last-failed-no-failures={all,none}
                        which tests to run with no previously (known)
                        failures.
  --sw, --stepwise      exit on test failure and continue from last failing
                        test next time
  --stepwise-skip       ignore the first failing test but stop on the next
                        failing test

reporting:
  --durations=N         show N slowest setup/test durations (N=0 for all).
  --durations-min=N     Minimal duration in seconds for inclusion in slowest
                        list. Default 0.005
  -v, --verbose         increase verbosity.
  --no-header           disable header
  --no-summary          disable summary
  -q, --quiet           decrease verbosity.
  --verbosity=VERBOSE   set verbosity. Default is 0.
  -r chars              show extra test summary info as specified by chars:
                        (f)ailed, (E)rror, (s)kipped, (x)failed, (X)passed,
                        (p)assed, (P)assed with output, (a)ll except passed
                        (p/P), or (A)ll. (w)arnings are enabled by default
                        (see --disable-warnings), 'N' can be used to reset
                        the list. (default: 'fE').
  --disable-warnings, --disable-pytest-warnings
                        disable warnings summary
  -l, --showlocals      show locals in tracebacks (disabled by default).
  --tb=style            traceback print mode
                        (auto/long/short/line/native/no).
  --show-capture={no,stdout,stderr,log,all}
                        Controls how captured stdout/stderr/log is shown on
                        failed tests. Default is 'all'.
  --full-trace          don't cut any tracebacks (default is to cut).
  --color=color         color terminal output (yes/no/auto).
  --code-highlight={yes,no}
                        Whether code should be highlighted (only if --color
                        is also enabled)
  --pastebin=mode       send failed|all info to bpaste.net pastebin service.
  --junit-xml=path      create junit-xml style report file at given path.
  --junit-prefix=str    prepend prefix to classnames in junit-xml output

pytest-warnings:
  -W PYTHONWARNINGS, --pythonwarnings=PYTHONWARNINGS
                        set which warnings to report, see -W option of
                        python itself.
  --maxfail=num         exit after first num failures or errors.
  --strict-config       any warnings encountered while parsing the `pytest`
                        section of the configuration file raise errors.
  --strict-markers, --strict
                        markers not registered in the `markers` section of
                        the configuration file raise errors.
  -c file               load configuration from `file` instead of trying to
                        locate one of the implicit configuration files.
  --continue-on-collection-errors
                        Force test execution even if collection errors
                        occur.
  --rootdir=ROOTDIR     Define root directory for tests. Can be relative
                        path: 'root_dir', './root_dir',
                        'root_dir/another_dir/'; absolute path:
                        '/home/user/root_dir'; path with variables:
                        '$HOME/root_dir'.

collection:
  --collect-only, --co  only collect tests, don't execute them.
  --pyargs              try to interpret all arguments as python packages.
  --ignore=path         ignore path during collection (multi-allowed).
  --ignore-glob=path    ignore path pattern during collection (multi-
                        allowed).
  --deselect=nodeid_prefix
                        deselect item (via node id prefix) during collection
                        (multi-allowed).
  --confcutdir=dir      only load conftest.py's relative to specified dir.
  --noconftest          Don't load any conftest.py files.
  --keep-duplicates     Keep duplicate tests.
  --collect-in-virtualenv
                        Don't ignore tests in a local virtualenv directory
  --import-mode={prepend,append,importlib}
                        prepend/append to sys.path when importing test
                        modules and conftest files, default is to prepend.
  --doctest-modules     run doctests in all .py modules
  --doctest-report={none,cdiff,ndiff,udiff,only_first_failure}
                        choose another output format for diffs on doctest
                        failure
  --doctest-glob=pat    doctests file matching pattern, default: test*.txt
  --doctest-ignore-import-errors
                        ignore doctest ImportErrors
  --doctest-continue-on-failure
                        for a given doctest, continue to run after the first
                        failure

test session debugging and configuration:
  --basetemp=dir        base temporary directory for this test run.(warning:
                        this directory is removed if it exists)
  -V, --version         display pytest version and information about
                        plugins.When given twice, also display information
                        about plugins.
  -h, --help            show help message and configuration info
  -p name               early-load given plugin module name or entry point
                        (multi-allowed).
                        To avoid loading of plugins, use the `no:` prefix,
                        e.g. `no:doctest`.
  --trace-config        trace considerations of conftest.py files.
  --debug               store internal tracing debug information in
                        'pytestdebug.log'.
  -o OVERRIDE_INI, --override-ini=OVERRIDE_INI
                        override ini option with "option=value" style, e.g.
                        `-o xfail_strict=True -o cache_dir=cache`.
  --assert=MODE         Control assertion debugging tools.
                        'plain' performs no assertion debugging.
                        'rewrite' (the default) rewrites assert statements
                        in test modules on import to provide assert
                        expression information.
  --setup-only          only setup fixtures, do not execute tests.
  --setup-show          show setup of fixtures while executing tests.
  --setup-plan          show what fixtures and tests would be executed but
                        don't execute anything.

logging:
  --log-level=LEVEL     level of messages to catch/display.
                        Not set by default, so it depends on the root/parent
                        log handler's effective level, where it is "WARNING"
                        by default.
  --log-format=LOG_FORMAT
                        log format as used by the logging module.
  --log-date-format=LOG_DATE_FORMAT
                        log date format as used by the logging module.
  --log-cli-level=LOG_CLI_LEVEL
                        cli logging level.
  --log-cli-format=LOG_CLI_FORMAT
                        log format as used by the logging module.
  --log-cli-date-format=LOG_CLI_DATE_FORMAT
                        log date format as used by the logging module.
  --log-file=LOG_FILE   path to a file when logging will be written to.
  --log-file-level=LOG_FILE_LEVEL
                        log file logging level.
  --log-file-format=LOG_FILE_FORMAT
                        log format as used by the logging module.
  --log-file-date-format=LOG_FILE_DATE_FORMAT
                        log date format as used by the logging module.
  --log-auto-indent=LOG_AUTO_INDENT
                        Auto-indent multiline messages passed to the logging
                        module. Accepts true|on, false|off or an integer.

[pytest] ini-options in the first pytest.ini|tox.ini|setup.cfg file found:

  markers (linelist):   markers for test functions
  empty_parameter_set_mark (string):
                        default marker for empty parametersets
  norecursedirs (args): directory patterns to avoid for recursion
  testpaths (args):     directories to search for tests when no files or
                        directories are given in the command line.
  filterwarnings (linelist):
                        Each line specifies a pattern for
                        warnings.filterwarnings. Processed after
                        -W/--pythonwarnings.
  usefixtures (args):   list of default fixtures to be used with this
                        project
  python_files (args):  glob-style file patterns for Python test module
                        discovery
  python_classes (args):
                        prefixes or glob names for Python test class
                        discovery
  python_functions (args):
                        prefixes or glob names for Python test function and
                        method discovery
  disable_test_id_escaping_and_forfeit_all_rights_to_community_support (bool):
                        disable string escape non-ascii characters, might
                        cause unwanted side effects(use at your own risk)
  console_output_style (string):
                        console output: "classic", or with additional
                        progress information ("progress" (percentage) |
                        "count").
  xfail_strict (bool):  default for the strict parameter of xfail markers
                        when not given explicitly (default: False)
  enable_assertion_pass_hook (bool):
                        Enables the pytest_assertion_pass hook.Make sure to
                        delete any previously generated pyc cache files.
  junit_suite_name (string):
                        Test suite name for JUnit report
  junit_logging (string):
                        Write captured log messages to JUnit report: one of
                        no|log|system-out|system-err|out-err|all
  junit_log_passing_tests (bool):
                        Capture log information for passing tests to JUnit
                        report:
  junit_duration_report (string):
                        Duration time to report: one of total|call
  junit_family (string):
                        Emit XML for schema: one of legacy|xunit1|xunit2
  doctest_optionflags (args):
                        option flags for doctests
  doctest_encoding (string):
                        encoding used for doctest files
  cache_dir (string):   cache directory path.
  log_level (string):   default value for --log-level
  log_format (string):  default value for --log-format
  log_date_format (string):
                        default value for --log-date-format
  log_cli (bool):       enable log display during test run (also known as
                        "live logging").
  log_cli_level (string):
                        default value for --log-cli-level
  log_cli_format (string):
                        default value for --log-cli-format
  log_cli_date_format (string):
                        default value for --log-cli-date-format
  log_file (string):    default value for --log-file
  log_file_level (string):
                        default value for --log-file-level
  log_file_format (string):
                        default value for --log-file-format
  log_file_date_format (string):
                        default value for --log-file-date-format
  log_auto_indent (string):
                        default value for --log-auto-indent
  faulthandler_timeout (string):
                        Dump the traceback of all threads if a test takes
                        more than TIMEOUT seconds to finish.
  addopts (args):       extra command line options
  minversion (string):  minimally required pytest version
  required_plugins (args):
                        plugins that must be present for pytest to run

environment variables:
  PYTEST_ADDOPTS           extra command line options
  PYTEST_PLUGINS           comma-separated plugins to load during startup
  PYTEST_DISABLE_PLUGIN_AUTOLOAD set to disable plugin auto-loading
  PYTEST_DEBUG             set to enable debug tracing of pytest's internals


to see available markers type: pytest --markers
to see available fixtures type: pytest --fixtures
(shown according to specified file_or_dir or current dir if not specified; fixtures with leading '_' are only shown with the '-v' option