Standard Python testing framework for unit tests, fixtures, mocking, and coverage analysis.
Install
mkdir -p .claude/skills/pytest-terminalskills && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/16268" && unzip -o skill.zip -d .claude/skills/pytest-terminalskills && rm skill.zipInstalls to .claude/skills/pytest-terminalskills
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Test Python code with pytest. Use when a user asks to write unit tests, set up test fixtures, mock dependencies, run async tests, measure coverage, or implement test-driven development in Python.Key capabilities
- →Write basic unit test functions using plain assert statements.
- →Set up shared test fixtures for database or API clients.
- →Create data-driven tests using parametrize.
- →Mock external services or dependencies for isolated testing.
- →Run tests with various command-line options.
- →Group related tests within classes.
How it works
This skill uses pytest to discover and execute test functions, applying fixtures for setup/teardown, parametrize for data variations, and mocking for dependency isolation.
Inputs & outputs
When to use pytest
- →Writing unit tests in Python
- →Setting up test fixtures
- →Measuring code coverage
About this skill
pytest
Overview
pytest collects functions named test_* in files named test_*.py (or *_test.py), runs them, and rewrites plain assert statements so a failure shows both sides of the comparison. Fixtures provide setup and teardown, parametrize runs one test over many inputs, and plugins add async support, coverage, mocking and parallel runs. This skill targets pytest 9.x (checked against 9.1) with pytest-asyncio 1.x.
Instructions
Step 1: Install and configure
python -m venv .venv && source .venv/bin/activate
pip install pytest pytest-asyncio pytest-cov pytest-mock pytest-xdist
Put configuration in pyproject.toml ([tool.pytest.ini_options]) or, since pytest 9, in a native pytest.toml:
# pytest.toml
[pytest]
pythonpath = ["."] # lets tests import top-level modules such as `app`
testpaths = ["tests"]
asyncio_mode = "auto" # pytest-asyncio: no @pytest.mark.asyncio on every test
markers = ["slow: tests that take more than a second"]
strict = true # unknown markers and options become errors
Without pythonpath (or an installed package), from app import ... fails with ModuleNotFoundError when pytest is run from the project root.
Step 2: Basic tests
# tests/test_users.py
import pytest
from app.services.users import create_user, validate_email
def test_create_user_returns_user_object():
user = create_user(name="Priya Nair", email="[email protected]")
assert user.name == "Priya Nair"
assert user.id is not None
def test_validate_email_rejects_invalid():
assert validate_email("not-an-email") is False
assert validate_email("user@") is False
class TestUserService:
"""A class only groups tests; no base class or self.assert* methods needed."""
def test_duplicate_email_raises(self):
create_user(name="Priya Nair", email="[email protected]")
with pytest.raises(ValueError, match="Email already exists"):
create_user(name="Tom Berg", email="[email protected]")
Step 3: Fixtures
# tests/conftest.py — shared by every test in this directory and below
import pytest
import pytest_asyncio
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
from app.models import Base, User
@pytest_asyncio.fixture # async fixtures need this decorator in strict mode
async def db():
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
async with async_sessionmaker(engine, expire_on_commit=False)() as session:
yield session # code after yield is the teardown
await engine.dispose()
@pytest_asyncio.fixture
async def sample_user(db):
user = User(name="Priya Nair", email="[email protected]", role="member")
db.add(user)
await db.commit()
return user
@pytest.fixture
def api_client(db):
from fastapi.testclient import TestClient
from app.main import app
from app.dependencies import get_db
app.dependency_overrides[get_db] = lambda: db
yield TestClient(app)
app.dependency_overrides.clear()
That example needs pip install "sqlalchemy[asyncio]" aiosqlite. Built-in fixtures worth knowing: tmp_path (a fresh directory per test), monkeypatch (set env vars and attributes, undone automatically), capsys and caplog (captured output and log records). A fixture's scope can be function (default), class, module, package or session; widen it only for expensive, read-only resources.
Step 4: Parametrize
@pytest.mark.parametrize(
"plan,expected_price",
[("free", 0), ("starter", 29), ("pro", 79), pytest.param("enterprise", 199, id="enterprise-list-price")],
)
def test_calculate_price(plan, expected_price):
assert calculate_price(plan) == expected_price
pytest 9 also ships subtests (a subtests fixture) for looping over cases inside one test without stopping at the first failure:
def test_slugify_variants(subtests):
for raw, slug in [("Hello World", "hello-world"), (" Spaces ", "spaces")]:
with subtests.test(raw=raw):
assert slugify(raw) == slug
Step 5: Mocking
# tests/test_notifications.py — pytest-mock provides the `mocker` fixture
from unittest.mock import AsyncMock
async def test_send_welcome_email(mocker, sample_user):
send = mocker.patch("app.services.email.send_email", new_callable=AsyncMock,
return_value={"id": "msg_8841"})
result = await send_welcome_email(sample_user.id)
send.assert_awaited_once_with(to="[email protected]", subject="Welcome!", template="welcome")
assert result["id"] == "msg_8841"
Patch the name where it is looked up (app.services.notifications.send_email, if that module did from ... import send_email), not where it is defined.
Step 6: Run
pytest # everything under testpaths
pytest tests/test_users.py::test_validate_email_rejects_invalid # one test
pytest -x --lf # stop at first failure; rerun last failures
pytest -k "create and not duplicate" # select by expression
pytest -m "not slow" # select by marker
pytest --cov=app --cov-report=term-missing # coverage (pytest-cov)
pytest -n auto # parallel workers (pytest-xdist)
pytest -ra # summary of skipped/xfailed reasons
Examples
Example 1: Add tests for a pricing function
User request: "Write pytest tests for calculate_discount in app/pricing.py, including bad input."
# tests/test_pricing.py
import pytest
from app.pricing import calculate_discount
@pytest.mark.parametrize("total,code,expected", [(100.0, "SPRING10", 90.0), (100.0, None, 100.0), (0.0, "SPRING10", 0.0)])
def test_discount_applies(total, code, expected):
assert calculate_discount(total, code) == pytest.approx(expected)
def test_unknown_code_raises():
with pytest.raises(ValueError, match="Unknown discount code"):
calculate_discount(50.0, "NOPE")
Run pytest tests/test_pricing.py -q; expect 4 passed (three parametrized cases plus the error test).
Example 2: Fix "async def functions are not natively supported"
User request: "My async tests fail with 'async def functions are not natively supported'."
pytest does not run coroutines on its own. Install the plugin and set the mode:
pip install pytest-asyncio
Add asyncio_mode = "auto" to pytest.toml, or keep the default strict mode and decorate each test with @pytest.mark.asyncio and each async fixture with @pytest_asyncio.fixture. Re-run pytest -q: the tests now pass.
Guidelines
- Use plain
assert; usepytest.approxfor floats andpytest.raises(..., match=...)for exceptions. - In strict asyncio mode (the default), an async fixture declared with plain
@pytest.fixtureerrors with "requested an async fixture ... no plugin or hook that handled it"; use@pytest_asyncio.fixtureor switch toasyncio_mode = "auto". - Fixtures with
yieldclean up even when the test fails; no try/finally needed. - Keep tests independent: no reliance on order, shared mutable module state or a leftover database. In-memory SQLite suits unit tests; use the real database engine for integration tests.
- Register custom markers in configuration; with
strict = true(or--strict-markers) a typo fails at collection instead of silently deselecting tests. - Parallel runs (
-n auto) need tests that do not share files, ports or database rows. - Do not mock what you own and can run cheaply; mock network calls, clocks and paid APIs.
unittest.TestCaseclasses also run under pytest, but fixtures and parametrize do not apply to their methods.
When not to use it
- →When testing languages other than Python.
- →When the task is not related to writing, running, or managing Python tests.
- →When the user explicitly requests a different testing framework.
Limitations
- →The skill is specific to Python testing with pytest.
- →It requires `pytest-asyncio` for async tests.
- →Fixtures with `yield` handle cleanup automatically.
How it compares
This workflow use pytest's features like plain asserts and fixtures for Python testing, simplifying test writing and maintenance compared to frameworks requiring `self.assertEqual`.
Compared to similar skills
pytest side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| pytest (this skill) | 0 | 6mo | Review | Intermediate |
| python-testing-patterns | 77 | 6mo | Review | Intermediate |
| backtesting-frameworks | 17 | 6mo | No flags | Advanced |
| temporal-python-testing | 8 | 7mo | No flags | Advanced |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by TerminalSkills
View all by TerminalSkills →You might also like
python-testing-patterns
wshobson
Implement comprehensive testing strategies with pytest, fixtures, mocking, and test-driven development. Use when writing Python tests, setting up test suites, or implementing testing best practices.
backtesting-frameworks
wshobson
Build robust backtesting systems for trading strategies with proper handling of look-ahead bias, survivorship bias, and transaction costs. Use when developing trading algorithms, validating strategies, or building backtesting infrastructure.
temporal-python-testing
wshobson
Test Temporal workflows with pytest, time-skipping, and mocking strategies. Covers unit testing, integration testing, replay testing, and local development setup. Use when implementing Temporal workflow tests or debugging test failures.
home-assistant-integration-knowledge
home-assistant
Everything you need to know to build, test and review Home Assistant Integrations. If you're looking at an integration, you must use this as your primary reference.
testing-python
jlowin
Write and evaluate effective Python tests using pytest. Use when writing tests, reviewing test code, debugging test failures, or improving test coverage. Covers test design, fixtures, parameterization, mocking, and async testing.
pr-review
pytorch
Review PyTorch pull requests for code quality, test coverage, security, and backward compatibility. Use when reviewing PRs, when asked to review code changes, or when the user mentions "review PR", "code review", or "check this PR".