Skip and xfail: dealing with tests that cannot succeed

You can mark test functions that cannot be run on certain platforms or that you expect to fail so pytest can deal with them accordingly and present a summary of the test session, while keeping the test suite green.

A skip means that you expect your test to pass only if some conditions are met, otherwise pytest should skip running the test altogether. Common examples are skipping windows-only tests on non-windows platforms, or skipping tests that depend on an external resource which is not available at the moment (for example a database).

A xfail means that you expect a test to fail for some reason. A common example is a test for a feature not yet implemented, or a bug not yet fixed.

pytest counts and lists skip and xfail tests separately. Detailed information about skipped/xfailed tests is not shown by default to avoid cluttering the output. You can use the -r option to see details corresponding to the “short” letters shown in the test progress:

pytest -rxs  # show extra info on skips and xfails

(See How to change command line options defaults)

Skipping test functions

New in version 2.9.

The simplest way to skip a test function is to mark it with the skip decorator which may be passed an optional reason:

@pytest.mark.skip(reason="no way of currently testing this")
def test_the_unknown():

Alternatively, it is also possible to skip imperatively during test execution or setup by calling the pytest.skip(reason) function:

def test_function():
    if not valid_config():
        pytest.skip("unsupported configuration")

The imperative method is useful when it is not possible to evaluate the skip condition during import time.


New in version 2.0.

If you wish to skip something conditionally then you can use skipif instead. Here is an example of marking a test function to be skipped when run on a Python3.3 interpreter:

import sys
@pytest.mark.skipif(sys.version_info < (3,3),
                    reason="requires python3.3")
def test_function():

If the condition evaluates to True during collection, the test function will be skipped, with the specified reason appearing in the summary when using -rs.

You can share skipif markers between modules. Consider this test module:

# content of
import mymodule
minversion = pytest.mark.skipif(mymodule.__versioninfo__ < (1,1),
                                reason="at least mymodule-1.1 required")
def test_function():

You can import the marker and reuse it in another test module:

from test_mymodule import minversion

def test_anotherfunction():

For larger test suites it’s usually a good idea to have one file where you define the markers which you then consistently apply throughout your test suite.

Alternatively, you can use condition strings instead of booleans, but they can’t be shared between modules easily so they are supported mainly for backward compatibility reasons.

Skip all test functions of a class or module

You can use the skipif marker (as any other marker) on classes:

@pytest.mark.skipif(sys.platform == 'win32',
                    reason="does not run on windows")
class TestPosixCalls(object):

    def test_function(self):
        "will not be setup or run under 'win32' platform"

If the condition is True, this marker will produce a skip result for each of the test methods of that class.

If you want to skip all test functions of a module, you may use the pytestmark name on the global level:

pytestmark = pytest.mark.skipif(...)

If multiple skipif decorators are applied to a test function, it will be skipped if any of the skip conditions is true.

Skipping on a missing import dependency

You can use the following helper at module level or within a test or test setup function:

docutils = pytest.importorskip("docutils")

If docutils cannot be imported here, this will lead to a skip outcome of the test. You can also skip based on the version number of a library:

docutils = pytest.importorskip("docutils", minversion="0.3")

The version will be read from the specified module’s __version__ attribute.


Here’s a quick guide on how to skip tests in a module in different situations:

  1. Skip all tests in a module unconditionally:
pytestmark = pytest.mark.skip('all tests still WIP')
  1. Skip all tests in a module based on some condition:
pytestmark = pytest.mark.skipif(sys.platform == 'win32', 'tests for linux only')
  1. Skip all tests in a module if some import is missing:
pexpect = pytest.importorskip('pexpect')

XFail: mark test functions as expected to fail

You can use the xfail marker to indicate that you expect a test to fail:

def test_function():

This test will be run but no traceback will be reported when it fails. Instead terminal reporting will list it in the “expected to fail” (XFAIL) or “unexpectedly passing” (XPASS) sections.

Alternatively, you can also mark a test as XFAIL from within a test or setup function imperatively:

def test_function():
    if not valid_config():
        pytest.xfail("failing configuration (but should work)")

This will unconditionally make test_function XFAIL. Note that no other code is executed after pytest.xfail call, differently from the marker. That’s because it is implemented internally by raising a known exception.

Here’s the signature of the xfail marker (not the function), using Python 3 keyword-only arguments syntax:

def xfail(condition=None, *, reason=None, raises=None, run=True, strict=False):

strict parameter

New in version 2.9.

Both XFAIL and XPASS don’t fail the test suite, unless the strict keyword-only parameter is passed as True:

def test_function():

This will make XPASS (“unexpectedly passing”) results from this test to fail the test suite.

You can change the default value of the strict parameter using the xfail_strict ini option:


reason parameter

As with skipif you can also mark your expectation of a failure on a particular platform:

@pytest.mark.xfail(sys.version_info >= (3,3),
                   reason="python3.3 api changes")
def test_function():

raises parameter

If you want to be more specific as to why the test is failing, you can specify a single exception, or a list of exceptions, in the raises argument.

def test_function():

Then the test will be reported as a regular failure if it fails with an exception not mentioned in raises.

run parameter

If a test should be marked as xfail and reported as such but should not be even executed, use the run parameter as False:

def test_function():

This is specially useful for xfailing tests that are crashing the interpreter and should be investigated later.

Ignoring xfail

By specifying on the commandline:

pytest --runxfail

you can force the running and reporting of an xfail marked test as if it weren’t marked at all. This also causes pytest.xfail to produce no effect.


Here is a simple test file with the several usages:

import pytest
xfail = pytest.mark.xfail

def test_hello():
    assert 0

def test_hello2():
    assert 0

@xfail("hasattr(os, 'sep')")
def test_hello3():
    assert 0

@xfail(reason="bug 110")
def test_hello4():
    assert 0

@xfail('pytest.__version__[0] != "17"')
def test_hello5():
    assert 0

def test_hello6():

def test_hello7():
    x = []
    x[1] = 1

Running it with the report-on-xfail option gives this output:

example $ pytest -rx
======= test session starts ========
platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
rootdir: $REGENDOC_TMPDIR/example, inifile:
collected 7 items xxxxxxx
======= short test summary info ========
  reason: [NOTRUN]
  condition: hasattr(os, 'sep')
  bug 110
  condition: pytest.__version__[0] != "17"
  reason: reason

======= 7 xfailed in 0.12 seconds ========

Skip/xfail with parametrize

It is possible to apply markers like skip and xfail to individual test instances when using parametrize:

import pytest

@pytest.mark.parametrize(("n", "expected"), [
    (1, 2),
pytest.param(1, 0, marks=pytest.mark.xfail),
    pytest.param(1, 3, marks=pytest.mark.xfail(reason="some bug")),
    (2, 3),
    (3, 4),
    (4, 5),
pytest.param(10, 11, marks=pytest.mark.skipif(sys.version_info >= (3, 0), reason="py2k")),
def test_increment(n, expected):
    assert n + 1 == expected

Conditions as strings instead of booleans

Prior to pytest-2.4 the only way to specify skipif/xfail conditions was to use strings:

import sys
@pytest.mark.skipif("sys.version_info >= (3,3)")
def test_function():

During test function setup the skipif condition is evaluated by calling eval('sys.version_info >= (3,0)', namespace). The namespace contains all the module globals, and os and sys as a minimum.

Since pytest-2.4 condition booleans are considered preferable because markers can then be freely imported between test modules. With strings you need to import not only the marker but all variables used by the marker, which violates encapsulation.

The reason for specifying the condition as a string was that pytest can report a summary of skip conditions based purely on the condition string. With conditions as booleans you are required to specify a reason string.

Note that string conditions will remain fully supported and you are free to use them if you have no need for cross-importing markers.

The evaluation of a condition string in pytest.mark.skipif(conditionstring) or pytest.mark.xfail(conditionstring) takes place in a namespace dictionary which is constructed as follows:

  • the namespace is initialized by putting the sys and os modules and the pytest config object into it.
  • updated with the module globals of the test function for which the expression is applied.

The pytest config object allows you to skip based on a test configuration value which you might have added:

@pytest.mark.skipif("not config.getvalue('db')")
def test_function(...):

The equivalent with “boolean conditions” is:

@pytest.mark.skipif(not pytest.config.getvalue("db"),
                    reason="--db was not specified")
def test_function(...):


You cannot use pytest.config.getvalue() in code imported before pytest’s argument parsing takes place. For example, files are imported before command line parsing and thus config.getvalue() will not execute correctly.