Python SDET Interview Questions for 3 Years Experience (2026)

Short answer: a fixture is a function that prepares something a test needs; tests ask for it by naming it as a parameter. Code before yield is setup, code after it is teardown, and teardown runs even if the test fails.

import pytest
import requests

@pytest.fixture(scope="session")
def api():
    session = requests.Session()
    session.headers["Accept"] = "application/json"
    yield session
    session.close()          # teardown

def test_health(api):
    r = api.get("https://httpbin.org/status/200", timeout=10)
    assert r.status_code == 200

Scopes are function (default), class, module, package and session. Put shared fixtures in conftest.py; pytest finds them without imports.

Short answer: @pytest.mark.parametrize runs the test once per row. Add ids so the report says which case failed.

import pytest

@pytest.mark.parametrize(
    "email, valid",
    [("qa@example.com", True), ("qa@", False), ("", False)],
    ids=["normal", "missing-domain", "empty"],
)
def test_email_validation(email, valid):
    assert is_valid_email(email) is valid

Expected report lines look like test_email_validation[missing-domain] PASSED.

Short answer: tag tests with @pytest.mark.smoke, register the marker in config, then select with -m.

# pytest.ini
[pytest]
markers =
    smoke: fast checks run on every commit
    slow: long-running tests
addopts = --strict-markers

pytest -m "smoke and not slow"
pytest -k "login"   # select by name instead

--strict-markers turns a typo like @pytest.mark.smok into an error instead of a silently skipped selection.

Short answer: a fixture in conftest.py is available to every test in that folder and its subfolders. You can have a root conftest for shared setup and folder-level ones for, say, tests/api/ only.

Use pytest --fixtures to list available fixtures and where they come from - useful when a name is defined twice and you are not sure which one wins (the closest conftest wins).

Short answer: default values are created once, when the function is defined. A list default is therefore shared between calls.

def add_tag(tag, tags=[]):        # bug
    tags.append(tag)
    return tags

print(add_tag("smoke"))  # ['smoke']
print(add_tag("api"))    # ['smoke', 'api']  - leaked from the first call

def add_tag_fixed(tag, tags=None):
    tags = [] if tags is None else tags
    tags.append(tag)
    return tags

In test helpers this shows up as data leaking between tests, which only fails when tests run in a certain order.

Short answer: use contextlib.contextmanager; the code after yield runs on exit, including when an exception is raised if you use try/finally.

import time
from contextlib import contextmanager

@contextmanager
def timed(label):
    start = time.perf_counter()
    try:
        yield
    finally:
        print(f"{label}: {time.perf_counter() - start:.2f}s")

with timed("checkout flow"):
    run_checkout()

Short answer: a timeout. The requests documentation states that requests do not time out unless you set one, so a hung server can block a CI job until the job itself is killed.

r = session.post(f"{BASE_URL}/orders", json={"sku": "A1", "qty": 1}, timeout=(3.05, 15))
assert r.status_code == 201, r.text
order = r.json()
assert order["qty"] == 1

The tuple means 3.05 s to connect and 15 s to read. Putting r.text in the assertion message shows the server's error body when the check fails.

Short answer: when you want values one at a time without building a full list - for example unique test users, or reading a large CSV line by line.

import itertools

def unique_emails(prefix="qa"):
    for n in itertools.count(1):
        yield f"{prefix}+{n}@example.com"

emails = unique_emails()
print(next(emails))  # qa+1@example.com
print(next(emails))  # qa+2@example.com

With pytest-xdist, add the worker id to the prefix so parallel workers never produce the same email.