parametrize — এক টেস্ট, অনেক কেস

def grade(score):
    if not 0 <= score <= 100:
        raise ValueError(f"score must be between 0 and 100, got {score}")
    if score >= 80:
        return "A"
    if score >= 60:
        return "B"
    if score >= 40:
        return "C"
    return "F"

$ python3 -c "from grading import grade; print(grade(95), grade(79), grade(40), grade(0))"
A B C F

from grading import grade


def test_grade_95():
    assert grade(95) == "A"


def test_grade_79():
    assert grade(79) == "B"


def test_grade_40():
    assert grade(40) == "C"

$ pytest -q test_copy.py
...                                                                      [100%]
3 passed in 0.01s

from grading import grade


def test_grades():
    cases = [(95, "A"), (80, "A"), (79, "C"), (40, "D"), (0, "F")]
    for score, expected in cases:
        assert grade(score) == expected

$ pytest -q --tb=short test_loop.py
F                                                                        [100%]
=================================== FAILURES ===================================
_________________________________ test_grades __________________________________
test_loop.py:7: in test_grades
    assert grade(score) == expected
E   AssertionError: assert 'B' == 'C'
E     
E     - C
E     + B
=========================== short test summary info ============================
FAILED test_loop.py::test_grades - AssertionError: assert 'B' == 'C'
1 failed in 0.01s

import pytest

from grading import grade


@pytest.mark.parametrize("score", [80, 95, 100])
def test_top_grade(score):
    assert grade(score) == "A"

$ pytest -v test_one.py
collecting ... collected 3 items

test_one.py::test_top_grade[80] PASSED                                   [ 33%]
test_one.py::test_top_grade[95] PASSED                                   [ 66%]
test_one.py::test_top_grade[100] PASSED                                  [100%]

============================== 3 passed in 0.01s ===============================

import pytest

from grading import grade


@pytest.mark.parametrize(
    "score,expected",
    [(95, "A"), (80, "A"), (79, "C"), (40, "D"), (0, "F")],
)
def test_grade(score, expected):
    assert grade(score) == expected

$ pytest -q --tb=short test_param.py
..FF.                                                                    [100%]
=================================== FAILURES ===================================
_______________________________ test_grade[79-C] _______________________________
test_param.py:11: in test_grade
    assert grade(score) == expected
E   AssertionError: assert 'B' == 'C'
E     
E     - C
E     + B
_______________________________ test_grade[40-D] _______________________________
test_param.py:11: in test_grade
    assert grade(score) == expected
E   AssertionError: assert 'C' == 'D'
E     
E     - D
E     + C
=========================== short test summary info ============================
FAILED test_param.py::test_grade[79-C] - AssertionError: assert 'B' == 'C'
FAILED test_param.py::test_grade[40-D] - AssertionError: assert 'C' == 'D'
2 failed, 3 passed in 0.01s

import pytest


@pytest.mark.parametrize(
    ["value", "expected"],
    [
        (1.5, True),
        ("hello world", None),
        ([1, 2], {"a": 1}),
    ],
)
def test_show_ids(value, expected):
    pass

$ pytest -v test_ids_auto.py
collecting ... collected 3 items

test_ids_auto.py::test_show_ids[1.5-True] PASSED                         [ 33%]
test_ids_auto.py::test_show_ids[hello world-None] PASSED                 [ 66%]
test_ids_auto.py::test_show_ids[value2-expected2] PASSED                 [100%]

============================== 3 passed in 0.01s ===============================

import pytest

from grading import grade


@pytest.mark.parametrize(
    "score,expected",
    [(80, "A"), (79, "B"), (40, "C"), (39, "F")],
    ids=["lowest-A", "highest-B", "lowest-C", "highest-F"],
)
def test_grade_boundaries(score, expected):
    assert grade(score) == expected

$ pytest -v test_ids_list.py
collecting ... collected 4 items

test_ids_list.py::test_grade_boundaries[lowest-A] PASSED                 [ 25%]
test_ids_list.py::test_grade_boundaries[highest-B] PASSED                [ 50%]
test_ids_list.py::test_grade_boundaries[lowest-C] PASSED                 [ 75%]
test_ids_list.py::test_grade_boundaries[highest-F] PASSED                [100%]

============================== 4 passed in 0.01s ===============================

import pytest

from grading import grade


def describe(value):
    if isinstance(value, int):
        return f"score={value}"
    return f"grade={value}"


@pytest.mark.parametrize("score,expected", [(80, "A"), (79, "B")], ids=describe)
def test_grade_named(score, expected):
    assert grade(score) == expected

$ pytest -v test_ids_func.py
collecting ... collected 2 items

test_ids_func.py::test_grade_named[score=80-grade=A] PASSED              [ 50%]
test_ids_func.py::test_grade_named[score=79-grade=B] PASSED              [100%]

============================== 2 passed in 0.01s ===============================

import pytest

from grading import grade


@pytest.mark.parametrize(
    "score,expected",
    [
        pytest.param(100, "A", id="perfect"),
        pytest.param(60, "B", id="lowest-B"),
        pytest.param(59.5, "B", id="round-up", marks=pytest.mark.xfail(reason="no rounding yet")),
        pytest.param(0, "F", id="zero", marks=pytest.mark.skip(reason="example of skip")),
    ],
)
def test_grade_cases(score, expected):
    assert grade(score) == expected

$ pytest -v test_param_obj.py
collecting ... collected 4 items

test_param_obj.py::test_grade_cases[perfect] PASSED                      [ 25%]
test_param_obj.py::test_grade_cases[lowest-B] PASSED                     [ 50%]
test_param_obj.py::test_grade_cases[round-up] XFAIL (no rounding yet)    [ 75%]
test_param_obj.py::test_grade_cases[zero] SKIPPED (example of skip)      [100%]

=================== 2 passed, 1 skipped, 1 xfailed in 0.01s ====================

import pytest


@pytest.mark.parametrize("currency", ["USD", "EUR"])
@pytest.mark.parametrize("amount", [0, 10, 999])
def test_format(amount, currency):
    text = f"{amount} {currency}"
    assert text.endswith(currency)

$ pytest -v test_stack.py
collecting ... collected 6 items

test_stack.py::test_format[0-USD] PASSED                                 [ 16%]
test_stack.py::test_format[0-EUR] PASSED                                 [ 33%]
test_stack.py::test_format[10-USD] PASSED                                [ 50%]
test_stack.py::test_format[10-EUR] PASSED                                [ 66%]
test_stack.py::test_format[999-USD] PASSED                               [ 83%]
test_stack.py::test_format[999-EUR] PASSED                               [100%]

============================== 6 passed in 0.01s ===============================

from contextlib import nullcontext

import pytest

from grading import grade


@pytest.mark.parametrize(
    "score,expectation",
    [
        (50, nullcontext("C")),
        (100, nullcontext("A")),
        (-1, pytest.raises(ValueError)),
        (101, pytest.raises(ValueError, match="got 101")),
    ],
)
def test_grade_or_error(score, expectation):
    with expectation as expected:
        assert grade(score) == expected

$ pytest -v test_raises.py
collecting ... collected 4 items

test_raises.py::test_grade_or_error[50-expectation0] PASSED              [ 25%]
test_raises.py::test_grade_or_error[100-expectation1] PASSED             [ 50%]
test_raises.py::test_grade_or_error[-1-expectation2] PASSED              [ 75%]
test_raises.py::test_grade_or_error[101-expectation3] PASSED             [100%]

============================== 4 passed in 0.01s ===============================

import pytest

from grading import grade


@pytest.mark.parametrize("score", [80, 100])
class TestTopBand:
    def test_is_a(self, score):
        assert grade(score) == "A"

    def test_is_a_string(self, score):
        assert isinstance(grade(score), str)

$ pytest -v test_class.py
collecting ... collected 4 items

test_class.py::TestTopBand::test_is_a[80] PASSED                         [ 25%]
test_class.py::TestTopBand::test_is_a[100] PASSED                        [ 50%]
test_class.py::TestTopBand::test_is_a_string[80] PASSED                  [ 75%]
test_class.py::TestTopBand::test_is_a_string[100] PASSED                 [100%]

============================== 4 passed in 0.01s ===============================

import math

RATES = {"local": 50, "national": 120}


def shipping_cost(weight_kg, zone):
    if zone not in RATES:
        raise KeyError(f"unknown zone: {zone}")
    if weight_kg <= 0:
        raise ValueError("weight must be positive")
    # The first kilogram is in the base rate; each started kilogram after it costs 20.
    return RATES[zone] + (math.ceil(weight_kg) - 1) * 20

$ python3 -c "from shipping import shipping_cost; print(shipping_cost(0.5, 'local'), shipping_cost(1.2, 'local'), shipping_cost(3, 'national'))"
50 70 160

from contextlib import nullcontext

import pytest

from shipping import shipping_cost


@pytest.mark.parametrize(
    "weight_kg,zone,expected",
    [
        pytest.param(0.5, "local", 50, id="light-local"),
        pytest.param(1, "local", 50, id="exactly-1kg"),
        pytest.param(1.2, "local", 70, id="part-kg-rounds-up"),
        pytest.param(3, "national", 160, id="heavy-national"),
    ],
)
def test_cost(weight_kg, zone, expected):
    assert shipping_cost(weight_kg, zone) == expected


@pytest.mark.parametrize("zone", ["local", "national"])
@pytest.mark.parametrize("weight_kg", [0.1, 0.5, 1])
def test_first_kg_is_flat(weight_kg, zone):
    assert shipping_cost(weight_kg, zone) == shipping_cost(1, zone)


@pytest.mark.parametrize(
    "weight_kg,zone,expectation",
    [
        pytest.param(2, "local", nullcontext(70), id="ok"),
        pytest.param(0, "local", pytest.raises(ValueError), id="zero-weight"),
        pytest.param(-1, "local", pytest.raises(ValueError), id="negative"),
        pytest.param(1, "moon", pytest.raises(KeyError, match="moon"), id="bad-zone"),
    ],
)
def test_cost_or_error(weight_kg, zone, expectation):
    with expectation as expected:
        assert shipping_cost(weight_kg, zone) == expected

$ pytest -v test_shipping.py
collecting ... collected 14 items

test_shipping.py::test_cost[light-local] PASSED                          [  7%]
test_shipping.py::test_cost[exactly-1kg] PASSED                          [ 14%]
test_shipping.py::test_cost[part-kg-rounds-up] PASSED                    [ 21%]
test_shipping.py::test_cost[heavy-national] PASSED                       [ 28%]
test_shipping.py::test_first_kg_is_flat[0.1-local] PASSED                [ 35%]
test_shipping.py::test_first_kg_is_flat[0.1-national] PASSED             [ 42%]
test_shipping.py::test_first_kg_is_flat[0.5-local] PASSED                [ 50%]
test_shipping.py::test_first_kg_is_flat[0.5-national] PASSED             [ 57%]
test_shipping.py::test_first_kg_is_flat[1-local] PASSED                  [ 64%]
test_shipping.py::test_first_kg_is_flat[1-national] PASSED               [ 71%]
test_shipping.py::test_cost_or_error[ok] PASSED                          [ 78%]
test_shipping.py::test_cost_or_error[zero-weight] PASSED                 [ 85%]
test_shipping.py::test_cost_or_error[negative] PASSED                    [ 92%]
test_shipping.py::test_cost_or_error[bad-zone] PASSED                    [100%]

============================== 14 passed in 0.01s ==============================

import pytest

from grading import grade


@pytest.mark.parametrize("scores,expected", [(80, "A"), (40, "C")])
def test_grade(score, expected):
    assert grade(score) == expected

$ pytest -q test_mismatch.py

==================================== ERRORS ====================================
______________________ ERROR collecting test_mismatch.py _______________________
In test_mismatch.py::test_grade: function uses no argument 'scores'
=========================== short test summary info ============================
ERROR test_mismatch.py - Failed: In test_mismatch.py::test_grade: function us...
!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
1 error in 0.01s

$ pytest -q test_count.py

==================================== ERRORS ====================================
________________________ ERROR collecting test_count.py ________________________
test_count.py::test_grade: in "parametrize" the number of names (2):
  ['score', 'expected']
must be equal to the number of values (1):
  (40,)

import pytest

from grading import grade


@pytest.mark.parametrize("score", [(80,), (95,)])
def test_top_grade(score):
    assert grade(score) == "A"

$ pytest -v --tb=no test_tuples.py
collecting ... collected 2 items

test_tuples.py::test_top_grade[score0] FAILED                            [ 50%]
test_tuples.py::test_top_grade[score1] FAILED                            [100%]

=========================== short test summary info ============================
FAILED test_tuples.py::test_top_grade[score0] - TypeError: '<=' not supported...
FAILED test_tuples.py::test_top_grade[score1] - TypeError: '<=' not supported...
============================== 2 failed in 0.01s ===============================

import pytest


@pytest.mark.parametrize("cart", [[]])
class TestCart:
    def test_add_item(self, cart):
        cart.append("pen")
        assert cart == ["pen"]

    def test_starts_empty(self, cart):
        assert cart == []

$ pytest -q --tb=short test_shared.py
.F                                                                       [100%]
=================================== FAILURES ===================================
______________________ TestCart.test_starts_empty[cart0] _______________________
test_shared.py:11: in test_starts_empty
    assert cart == []
E   AssertionError: assert ['pen'] == []
E     
E     Left contains one more item: 'pen'
E     Use -v to get more diff
=========================== short test summary info ============================
FAILED test_shared.py::TestCart::test_starts_empty[cart0] - AssertionError: a...
1 failed, 1 passed in 0.01s

def check_password(text):
    if not isinstance(text, str):
        raise TypeError(f"password must be a str, got {type(text).__name__}")
    problems = []
    if len(text) < 8:
        problems.append("too short")
    if not any(ch.isdigit() for ch in text):
        problems.append("no digit")
    if not any(ch.isalpha() for ch in text):
        problems.append("no letter")
    return problems

$ python3 -c "from password import check_password as c; print(c('abcdef12'), c('ab1'), c(''))"
[] ['too short'] ['too short', 'no digit', 'no letter']

from contextlib import nullcontext

import pytest

from password import check_password


@pytest.mark.parametrize(
    "text,expected",
    [
        pytest.param("abcdef12", [], id="eight-chars-ok"),
        pytest.param("abcde12", ["too short"], id="seven-chars"),
        pytest.param("abcdefgh", ["no digit"], id="letters-only"),
        pytest.param("12345678", ["no letter"], id="digits-only"),
        pytest.param("", ["too short", "no digit", "no letter"], id="empty"),
        pytest.param("ab1", ["too short"], id="short-but-mixed"),
        pytest.param(
            "abcdef12",
            ["no uppercase"],
            id="needs-uppercase",
            marks=pytest.mark.xfail(reason="uppercase rule not written yet"),
        ),
    ],
)
def test_problems(text, expected):
    assert check_password(text) == expected


@pytest.mark.parametrize("suffix", ["", "!"])
@pytest.mark.parametrize("good", ["abcdef12", "pass1234", "9lives9lives"])
def test_good_passwords(good, suffix):
    assert check_password(good + suffix) == []


@pytest.mark.parametrize(
    "value,expectation",
    [
        pytest.param("abcdef12", nullcontext([]), id="str-ok"),
        pytest.param("short", nullcontext(["too short", "no digit"]), id="str-problems"),
        pytest.param(None, pytest.raises(TypeError), id="none"),
        pytest.param(12345678, pytest.raises(TypeError, match="int"), id="int"),
    ],
)
def test_type_or_problems(value, expectation):
    with expectation as expected:
        assert check_password(value) == expected

$ pytest -v test_password.py
collecting ... collected 17 items

test_password.py::test_problems[eight-chars-ok] PASSED                   [  5%]
test_password.py::test_problems[seven-chars] PASSED                      [ 11%]
test_password.py::test_problems[letters-only] PASSED                     [ 17%]
test_password.py::test_problems[digits-only] PASSED                      [ 23%]
test_password.py::test_problems[empty] PASSED                            [ 29%]
test_password.py::test_problems[short-but-mixed] PASSED                  [ 35%]
test_password.py::test_problems[needs-uppercase] XFAIL (uppercase ru...) [ 41%]
test_password.py::test_good_passwords[abcdef12-] PASSED                  [ 47%]
test_password.py::test_good_passwords[abcdef12-!] PASSED                 [ 52%]
test_password.py::test_good_passwords[pass1234-] PASSED                  [ 58%]
test_password.py::test_good_passwords[pass1234-!] PASSED                 [ 64%]
test_password.py::test_good_passwords[9lives9lives-] PASSED              [ 70%]
test_password.py::test_good_passwords[9lives9lives-!] PASSED             [ 76%]
test_password.py::test_type_or_problems[str-ok] PASSED                   [ 82%]
test_password.py::test_type_or_problems[str-problems] PASSED             [ 88%]
test_password.py::test_type_or_problems[none] PASSED                     [ 94%]
test_password.py::test_type_or_problems[int] PASSED                      [100%]

======================== 16 passed, 1 xfailed in 0.01s =========================