Question 1

Is Pytest worth learning in 2026 when AI can write tests?

Accepted Answer

Yes, and arguably more so. AI assistants now generate first-pass test code, but you still need to know the framework deeply to review, debug failures, and design the fixture architecture for a project. Every Python team in India still hires for Pytest fluency in 2026; it's table-stakes for a backend or ML engineering role.

Question 2

How much does a Python developer with strong Pytest skills earn in India?

Accepted Answer

₹5-18 LPA in 2026, depending on experience. Mid-level backend or data engineers at Razorpay, Swiggy, Zomato, PhonePe, and similar startups typically expect Pytest fluency. Strong test design, fixtures, mocking, plugins, is a frequent differentiator at the senior level.

Question 3

Should I use unittest or Pytest for a new Python project?

Accepted Answer

Pytest, in almost every case. unittest is fine for tiny scripts where adding a dependency is unwelcome, but for any project with more than ~20 tests, Pytest's fixture system, parametrization, plugin ecosystem, and assertion rewriting save more time than the install cost. Pytest can also run unittest-style tests, so migration is incremental.

Question 4

What Pytest version should I be on in 2026?

Accepted Answer

Pytest 8.x is the current stable line, works with Python 3.9+ and ships modern fixtures, improved assertion rewriting, and faster collection. Major plugins (pytest-asyncio, pytest-cov, pytest-django, pytest-xdist, pytest-mock) all support it.

Question 5

How do I handle tests that hit external APIs (OpenAI, Razorpay, etc.)?

Accepted Answer

Three options: (1) Mock the SDK in unit tests using pytest-mock, fast and deterministic. (2) Use `vcrpy` or `pytest-recording` to record real responses once and replay them, catches contract drift without paying per CI run. (3) Reserve real-API tests for a nightly or pre-release pipeline. Never run paid-API tests on every PR, the cost adds up fast.

Question 6

What is Pytest and why is it preferred over unittest?

Accepted Answer

Pytest is a Python testing framework that emphasizes simplicity, readability, and powerful extensibility. It replaces the ceremony of `unittest` (subclassing `TestCase`, `self.assertEqual`, `setUp`/`tearDown`) with plain functions and the native `assert` statement. The reasons teams prefer it: (1) Less boilerplate, a test is just a function whose name starts with `test_`. (2) Better assertion error messages, Pytest rewrites assertions at import time and shows you the expanded values when an `assert` fails, instead of unittest's generic 'AssertionError'. (3) A fixture system that's composable and dependency-injected rather than a setUp/tearDown method on a class. (4) A massive plugin ecosystem, pytest-cov, pytest-xdist, pytest-django, pytest-asyncio, pytest-mock, each one a small `pip install` away. unittest is still in the standard library and remains useful for tiny projects where adding a dependency isn't desirable, but it's verbose: defining a class, writing `self.assertEqual(a, b)` instead of `assert a == b`, and dealing with rigid setUp/tearDown chains. Pytest can also run unittest-style tests, so migration is gradual.

Question 7

How does Pytest discover tests automatically?

Accepted Answer

Pytest's default discovery rules: (1) Start from the directory you invoked it in (or `testpaths` in `pyproject.toml`/`pytest.ini`). (2) Recurse into directories looking for files matching `test_*.py` or `*_test.py`. (3) Inside those files, collect functions whose name starts with `test_` and classes whose name starts with `Test` (which must not have an `__init__` method, that's a common mistake). (4) Inside those classes, collect methods starting with `test_`. You can override every part of this via `python_files`, `python_classes`, and `python_functions` config keys. Discovery happens before any test runs, so you can use `pytest --collect-only` to debug what gets picked up without executing anything.

Question 8

What is the assert statement in Pytest and how does assertion rewriting work?

Accepted Answer

In Pytest you use Python's native `assert` keyword, no `self.assertEqual`, no `assertIn`, no `assertGreater`. The magic is that Pytest hooks into Python's import system and rewrites every `assert` statement in your test modules at load time. When the assertion fails, Pytest doesn't just say 'AssertionError': it shows the expanded values on each side of the operator, the full diff for sequences and dicts, and even the local variables involved. This is called assertion rewriting. It's also why you should never write `assert a == b, 'they differ'` with a custom message in Pytest, the rewriter handles introspection better than any string you could write. The rewritten bytecode is cached in `__pycache__` directories alongside `.pyc` files; if rewriting misbehaves, deleting these caches forces a fresh rewrite.

Question 9

What is a Pytest fixture and how do you define one?

Accepted Answer

A fixture is a function decorated with `@pytest.fixture` that produces a value or sets up state for one or more tests. Tests opt-in to fixtures by listing them as parameters, Pytest matches parameter names to fixture names and injects the return value. This is dependency injection: tests declare what they need, fixtures supply it, Pytest wires them together. Fixtures can `yield` instead of `return` to run teardown code after the test finishes. Compared to `setUp`/`tearDown`, fixtures are more flexible: any test can request any fixture, fixtures can depend on other fixtures, and they can be scoped to a single function, a class, a module, or the whole session.

Question 10

What are the different fixture scopes and when should you use each?

Accepted Answer

Pytest fixtures support five scopes: `function` (default, recreated per test), `class` (one per test class), `module` (one per `.py` file), `package` (one per package directory), and `session` (one for the entire test run). The trade-off is isolation vs speed: function scope guarantees a clean state but is the slowest if setup is expensive (database, browser); session scope is fast but shared state between tests can hide bugs. Common pattern: a `session`-scoped fixture creates an expensive resource (DB engine, app instance), and a `function`-scoped fixture uses it to give each test a clean transaction or sandbox. The scope you choose cascades: a `session` fixture cannot depend on a `function` fixture (Pytest will error), because the inner fixture's lifetime is shorter than the outer's.

Question 11

What is conftest.py and how is it used?

Accepted Answer

`conftest.py` is a special file Pytest auto-discovers in each directory of your test tree. Fixtures, hooks, and plugins defined in `conftest.py` are available to every test file in that directory and its subdirectories, without needing imports. The discovery is hierarchical: a fixture in `tests/conftest.py` is visible everywhere; a fixture in `tests/api/conftest.py` is visible only to tests under `tests/api/`. This makes `conftest.py` the right home for shared fixtures (like `db_session`, `client`, `mock_redis`), pytest plugins (hooks like `pytest_collection_modifyitems`), and command-line options registered via `pytest_addoption`. Never import from `conftest.py` directly, Pytest loads it specially, and importing it as a regular module breaks discovery.

Question 12

How do you run a specific test, file, or test method in Pytest?

Accepted Answer

Pytest accepts a node ID with the format `path::class::method` or `path::function`. To run a single file: `pytest tests/test_auth.py`. A single function: `pytest tests/test_auth.py::test_login`. A method in a class: `pytest tests/test_auth.py::TestLogin::test_invalid_password`. You can also use `-k ` to filter by name pattern (matches any substring) and `-m ` to filter by marker. The `-v` flag shows each test name as it runs, `-vv` adds even more detail on diffs, and `-x` stops at the first failure. For development, `--lf` (last-failed) and `--ff` (failed-first) are huge time-savers.

Question 13

What is parametrization in Pytest and how do you use @pytest.mark.parametrize?

Accepted Answer

Parametrization lets you run the same test function with multiple sets of inputs and expected outputs, effectively generating one test case per parameter set, each with its own pass/fail status. Use `@pytest.mark.parametrize(argnames, argvalues)` above the test function. `argnames` is a string of comma-separated parameter names, `argvalues` is a list of tuples (one per case). Pytest will generate `test_name[arg1-arg2]` style IDs by default, you can override with the `ids` keyword for cleaner output. Parametrization is far better than a `for` loop inside a single test, because each case is a separate test in the report: you see exactly which inputs failed, and pytest's `-x` / `--lf` works correctly.

Question 14

What are markers in Pytest? Explain skip, skipif, and xfail.

Accepted Answer

Markers are decorators that attach metadata to a test. The three built-in markers you'll use constantly: `@pytest.mark.skip(reason=...)` always skips a test (useful for temporarily disabling broken tests with a TODO); `@pytest.mark.skipif(condition, reason=...)` skips conditionally, common for Windows-only or Python-version-only tests; `@pytest.mark.xfail(reason=...)` marks a test as expected-to-fail. xfail is special: if the test fails, it's reported as 'XFAIL' (expected, no problem); if it unexpectedly passes, it's 'XPASS' (worth investigating, maybe the bug is fixed and the marker should be removed). You can also define custom markers like `@pytest.mark.slow` or `@pytest.mark.smoke` to organize tests by category, then run subsets via `pytest -m slow`. Register custom markers in `pyproject.toml` to avoid warnings.

Question 15

How do you test that a function raises an exception?

Accepted Answer

Use `pytest.raises` as a context manager. The block should contain the code that's expected to throw; if it doesn't, the test fails. You can also assert on the exception's message via the `match` keyword (a regex), or inspect the captured exception via the context variable. Avoid catching exceptions in a `try/except` and calling `pytest.fail()`, `pytest.raises` is shorter and clearer.

Pytest Interview Questions

What is Pytest and why is it preferred over unittest?

How does Pytest discover tests automatically?

What is the assert statement in Pytest and how does assertion rewriting work?

What is a Pytest fixture and how do you define one?

What are the different fixture scopes and when should you use each?

What is conftest.py and how is it used?

How do you run a specific test, file, or test method in Pytest?

What is parametrization in Pytest and how do you use @pytest.mark.parametrize?

What are markers in Pytest? Explain skip, skipif, and xfail.

How do you test that a function raises an exception?

What is autouse in fixtures and when should you use it?

How do you capture stdout/stderr in a Pytest test?

How does fixture scope cascading work, and what happens if scopes mismatch?

How do you use pytest-mock and what's the difference from unittest.mock?

Where should you patch, at the source or at the import site? Why is this a common bug?

How do you write async tests with pytest-asyncio?

How do you measure test coverage with pytest-cov?

How do you run tests in parallel with pytest-xdist?

How do you parametrize a fixture?

What is indirect parametrization and when is it useful?

How do you share state between tests deliberately? When is it OK?

How do you test database code with Pytest?

What is pytest-django and how does it differ from Django's TestCase?

How do you use tmp_path and tmp_path_factory?

How does monkeypatch work and when should you use it over mocker?

How do you write a Pytest plugin and what are the most useful hooks?

How would you design tests for an async LLM-streaming API in 2026?

How do you debug a flaky test in Pytest?

How do you organize a large test suite (10,000+ tests) for fast feedback?

What's the difference between Pytest hooks `pytest_collection_modifyitems`, `pytest_runtest_setup`, and `pytest_runtest_call`? When does each fire?

Companies Hiring Pytest

Salary Insights

Frequently Asked Questions

Is Pytest worth learning in 2026 when AI can write tests?

How much does a Python developer with strong Pytest skills earn in India?

Should I use unittest or Pytest for a new Python project?

What Pytest version should I be on in 2026?

How do I handle tests that hit external APIs (OpenAI, Razorpay, etc.)?

Introduction

Ready to practice Pytest interviews?