Pytest Run Specific Test

6 min read Oct 07, 2024

Running Specific Tests with pytest

When working on a large codebase, it's often necessary to run specific tests instead of the entire suite. This helps streamline development and debugging, allowing you to focus on relevant tests without wasting time on unnecessary ones. pytest, a popular Python testing framework, provides a flexible way to run specific tests using various techniques.

Why Run Specific Tests?

There are several reasons why you might want to run specific tests in pytest:

Faster Feedback: Running a full test suite can be time-consuming, especially in large projects. Running only the relevant tests can significantly speed up the development cycle.
Targeted Debugging: When investigating a bug, focusing on tests related to the problematic code can help isolate the issue and pinpoint the root cause.
Incremental Development: As you develop a feature or fix a bug, you can run specific tests related to the changes to ensure they are working as intended.
Test-Driven Development (TDD): In TDD, you write tests before writing the code. Running specific tests helps validate the code as you develop it.

How to Run Specific Tests in pytest

pytest offers a variety of ways to target specific tests:

1. Using Test Names (Markers)

Using the -k option: The -k option allows you to specify a string pattern to match test names.
- Example: pytest -k "test_my_function" will run all tests whose names contain "test_my_function".
- You can use wildcards like * for partial matches. pytest -k "test_*function" will run all tests starting with "test_" and ending with "function".
- You can combine multiple patterns using and or or. For instance, pytest -k "test_my_function or test_other_function".
Using Markers: pytest allows you to add markers (tags) to your tests. These markers can be used to group tests and run them selectively.
- Example:
```
import pytest

@pytest.mark.slow
def test_my_slow_function():
    # Test code
```
  You can then run only tests marked with "slow" using pytest -m slow.

2. Using File and Directory Paths

Directly specify file paths: You can specify the path to a specific test file or a directory containing test files.
- Example: pytest tests/test_module.py or pytest tests/
Using --pyargs option: This option allows you to pass arguments to the pytest command line.
- Example: pytest --pyargs my_module will run all tests within the "my_module" module.

3. Using Test IDs (Unique Identifiers)

Assign unique IDs to your tests: You can assign unique identifiers to your tests using the pytest.mark.parametrize decorator.
- Example:
```
import pytest

@pytest.mark.parametrize("input, expected", [(1, 2), (3, 6)])
def test_add_numbers(input, expected):
    assert input + 1 == expected
```
  This creates two tests with unique IDs, test_add_numbers[1-2] and test_add_numbers[3-6].
Running Tests by ID: You can then run tests by their IDs using the -x option.
- Example: pytest -x test_add_numbers[1-2] will run only the test with ID test_add_numbers[1-2].

4. Using the pytest.mark.skip Decorator

Skip tests conditionally: You can use the pytest.mark.skip decorator to skip tests based on specific conditions.
- Example:
```
import pytest

@pytest.mark.skip(reason="This test is not ready yet")
def test_my_function():
    # Test code
```
Running tests with skips: You can run tests marked with pytest.mark.skip using the -s option.
- Example: pytest -s will run all tests, including those skipped.

Example Usage

import pytest

# Test file: tests/test_calculator.py
def test_add_numbers():
    assert 1 + 1 == 2

def test_subtract_numbers():
    assert 5 - 2 == 3

# Running specific tests:
pytest -k "test_add_numbers"  # Runs only 'test_add_numbers'
pytest tests/test_calculator.py  # Runs all tests in 'test_calculator.py'
pytest --pyargs calculator  # Runs all tests in the 'calculator' module

Conclusion

pytest provides a powerful and versatile way to run specific tests, giving you more control over your testing process. By leveraging the techniques outlined above, you can streamline your workflow, isolate bugs more effectively, and accelerate your development cycle. Remember to choose the approach that best suits your needs and project structure.