Introduction

pytest provides a simple yet powerful way to write and execute test cases, making it easier for developers to maintain the quality of their code.
You may find at times that certain tests should not be executed under specific conditions. This is where conditional test skipping comes into play, allowing you to bypass tests that are not applicable in certain situations, enabling a more streamlined testing process.

Let’s take a look at the @pytest.mark.skipif decorator, which is used for conditional skipping of tests based on specified conditions, and how to use it effectively to improve your testing strategy.

Using the skipif Decorator

The @pytest.mark.skipif decorator is a convenient way to skip tests based on a condition. It takes two main arguments:

• Condition: This is a boolean expression; if the condition evaluates to True, the test will be skipped
• Reason: This is a string that explains why the test is being skipped; providing a reason can help other developers understand the context behind the skipped test

Before we dive into examples, make sure you have pytest installed in your Python environment. If you haven’t installed it yet, you can do so using pip:

pip install pytest

Once you have pytest installed, create a basic test file structure. You can reference our previous post for more information if needed.

Let’s look at a simple test function that uses the skipif decorator. In this example, we will skip a test if the operating system is Windows:

import pytest
import sys

@pytest.mark.skipif(sys.platform == "win32", reason="Test not applicable on Windows")
def dont_test_on_windows():
    assert 1 + 1 == 2

In this code, the test dont_test_on_windows will be skipped if the platform is Windows. The reason provided explains why this test is not applicable on that operating system.

You can also create custom conditions for skipping tests. For instance, you might want to skip tests based on the value of an environment variable. Here’s an example:

import pytest
import os

@pytest.mark.skipif(os.getenv('SKIP_TESTS') == '1', reason="Skipping tests due to environment variable")
def test_conditionally_skipped():
    assert 1 + 1 == 2

In this code snippet, if the environment variable SKIP_TESTS is set to 1, the test test_conditionally_skipped will be skipped. This approach allows for dynamic test skipping based on the environment configuration.

You can also combine skipif with other features of pytest, such as fixtures. Here’s an example where we use a fixture to check the environment:

import pytest
import os

@pytest.fixture
def setup_environment():
    return os.getenv('TEST_ENV')

@pytest.mark.skipif(os.getenv('TEST_ENV') == 'production', reason="Cannot run tests in production")
def test_not_in_production(setup_environment):
    assert 1 + 1 == 2

A fixture is a function that provides data or objects to tests, ensuring a consistent testing environment. It can be used to set up resources, provide test data, or manage state that can be shared across multiple tests.

In the above code, if the fixture setup_environment returns ‘production’, the test test_not_in_production will be skipped. This combination allows for more complex conditional logic in your tests.

pytest -v

The -v flag stands for verbose, which provides detailed output. When you run this command, pytest will display information about each test, including which tests were skipped, that they were skipped, and the reason specified.

Wrapping Up

Using the @pytest.mark.skipif decorator provides a flexible way to manage your test suite, and allows you to skip tests conditionally based on the environment or other criteria. This can lead to a more efficient testing process, particularly in scenarios where certain tests may not be applicable.
To find out more about pytest and its capabilities, refer to the pytest website and its official documentation.