Beginner Examples

# learning/code/ex-01-first-passing-test/test_example.py
"""Example 1: First Passing Test."""
 
# ex-01: the smallest possible pytest test -- one function, one assert
# -- pytest discovers this file because it matches test_*.py (co-02)
# -- and discovers the function below because it matches test_* (co-02)
def add(a: int, b: int) -> int:  # => the unit under test: a plain, pure function
    return a + b  # => no test framework involvement at all inside the function itself
 
 
def test_adds() -> None:  # => the test function -- name MUST start with test_ to be discovered
    assert add(2, 3) == 5  # => arrange (2, 3) + act (call add) + assert, all on one line (co-01)
    # => if add(2, 3) had returned anything other than 5, pytest would report a failure here

collected 1 item
 
test_example.py::test_adds PASSED                                        [100%]
 
============================== 1 passed in 0.08s ===============================

# learning/code/ex-02-failing-test-output/test_example.py
"""Example 2: Failing Test Output."""
 
# ex-02: a DELIBERATELY wrong assertion -- this test is meant to fail
# -- the point is to see pytest's expression introspection, not to pass (co-03)
def add(a: int, b: int) -> int:  # => the same pure function as ex-01
    return a + b  # => genuinely returns 5 for add(2, 3) -- the test below expects 6 instead
 
 
def test_adds_wrong_expectation() -> None:  # => named honestly -- this SHOULD fail
    assert add(2, 3) == 6  # => plain assert -- pytest rewrites this at import time (co-03)
    # => pytest's assertion rewriting inspects BOTH sides of == and shows the actual
    # => value (5) next to the expected literal (6), with no assertNotEqual-style API needed

collected 1 item
 
test_example.py::test_adds_wrong_expectation FAILED                      [100%]
 
=================================== FAILURES ===================================
_________________________ test_adds_wrong_expectation __________________________
 
    def test_adds_wrong_expectation() -> None:  # => named honestly -- this SHOULD fail
>       assert add(2, 3) == 6  # => plain assert -- pytest rewrites this at import time (co-03)
        ^^^^^^^^^^^^^^^^^^^^^
E       assert 5 == 6
E        +  where 5 = add(2, 3)
 
test_example.py:11: AssertionError
=========================== short test summary info ============================
FAILED test_example.py::test_adds_wrong_expectation - assert 5 == 6
============================== 1 failed in 0.09s ===============================

# learning/code/ex-03-arrange-act-assert/test_example.py
"""Example 3: Arrange-Act-Assert."""
 
# ex-03: the SAME test as ex-01, restructured into three visually distinct phases (co-01)
# -- AAA is a convention, not a pytest feature -- nothing here is pytest-specific syntax
def multiply(a: int, b: int) -> int:  # => the unit under test
    return a * b  # => a pure function -- no I/O, no hidden state (co-26)
 
 
def test_multiply_arrange_act_assert() -> None:
    # --- Arrange: build the inputs the test needs, named clearly ---
    first_factor = 6  # => arrange phase, part 1: a plain input value
    second_factor = 7  # => arrange phase, part 2: a second plain input value
    expected = 42  # => arrange phase, part 3: the expected RESULT, computed by hand
 
    # --- Act: call the ONE thing under test, exactly once ---
    actual = multiply(first_factor, second_factor)  # => act phase -- the single call being tested  # fmt: skip
 
    # --- Assert: compare what happened against what was expected ---
    assert actual == expected  # => assert phase -- the only line that can fail this test

collected 1 item
 
test_example.py::test_multiply_arrange_act_assert PASSED                 [100%]
 
============================== 1 passed in 0.07s ===============================

# learning/code/ex-04-run-single-test/test_example.py
"""Example 4: Run a Single Test by Name."""
 
# ex-04: THREE tests in one file -- run only ONE of them by name (co-02)
def square(n: int) -> int:  # => the unit under test
    return n * n  # => a pure function, reused by all three tests below
 
 
def test_square_of_two() -> None:  # => test A -- the one we will select by name below
    assert square(2) == 4  # => 2*2 -- passes
 
 
def test_square_of_three() -> None:  # => test B -- deliberately NOT selected below
    assert square(3) == 9  # => 3*3 -- passes, but never runs in this example's command
 
 
def test_square_of_negative() -> None:  # => test C -- also NOT selected below
    assert square(-4) == 16  # => (-4)*(-4) -- passes, but also skipped by the selector

collected 3 items
 
test_example.py::test_square_of_two PASSED                               [ 33%]
test_example.py::test_square_of_three PASSED                             [ 66%]
test_example.py::test_square_of_negative PASSED                          [100%]
 
============================== 3 passed in 0.07s ===============================

collected 1 item
 
test_example.py::test_square_of_two PASSED                               [100%]
 
============================== 1 passed in 0.07s ===============================

# learning/code/ex-05-assert-equality/test_example.py
"""Example 5: Assert Equality."""
 
# ex-05: equality assertions -- the most common assertion shape in any test suite (co-03)
def to_upper(text: str) -> str:  # => the unit under test
    return text.upper()  # => stdlib str.upper -- deterministic, no locale surprises here
 
 
def test_equality_passes_on_a_match() -> None:  # => the "happy path" half of this example
    assert to_upper("hello") == "HELLO"  # => == compares by VALUE, not identity (co-03)
 
 
def test_equality_fails_on_a_mismatch() -> None:  # => proves == genuinely discriminates
    assert to_upper("hello") != "hello"  # => != is equality's negation -- also a plain assert
    # => this line is deliberately the OPPOSITE assertion (!=) so the test itself passes
    # => while still demonstrating that a naive equality check would have failed here

collected 2 items
 
test_example.py::test_equality_passes_on_a_match PASSED                  [ 50%]
test_example.py::test_equality_fails_on_a_mismatch PASSED                [100%]
 
============================== 2 passed in 0.06s ===============================

# learning/code/ex-06-assert-truthiness/test_example.py
"""Example 6: Assert Truthiness."""
 
# ex-06: a plain boolean-condition assert, then a DELIBERATE failure right after it (co-03)
def is_even(n: int) -> bool:  # => the unit under test
    return n % 2 == 0  # => returns a genuine bool, not a string or 0/1
 
 
def test_truthiness_of_a_boolean_condition() -> None:  # => passes -- shown for contrast below
    assert is_even(4)  # => truthy assert: no "== True" needed, a bare bool is enough (co-03)
 
 
def test_truthiness_reports_operands_on_failure() -> None:  # => THIS ONE deliberately fails
    assert is_even(7), "7 should be odd, so is_even(7) must be False"  # => optional message string  # fmt: skip
    # => pytest prints BOTH the failing expression (is_even(7)) and this custom message --
    # => the introspection shown here is what "assert truthiness reports operands" means

collected 2 items
 
test_example.py::test_truthiness_of_a_boolean_condition PASSED           [ 50%]
test_example.py::test_truthiness_reports_operands_on_failure FAILED      [100%]
 
=================================== FAILURES ===================================
_________________ test_truthiness_reports_operands_on_failure __________________
 
    def test_truthiness_reports_operands_on_failure() -> None:  # => THIS ONE deliberately fails
>       assert is_even(7), "7 should be odd, so is_even(7) must be False"  # => optional message string  # fmt: skip
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E       AssertionError: 7 should be odd, so is_even(7) must be False
E       assert False
E        +  where False = is_even(7)
 
test_example.py:14: AssertionError
=========================== short test summary info ============================
FAILED test_example.py::test_truthiness_reports_operands_on_failure - Asserti...
========================= 1 failed, 1 passed in 0.09s ==========================

# learning/code/ex-07-assert-membership/test_example.py
"""Example 7: Assert Membership."""
 
# ex-07: membership assertions -- "is X inside this collection?" (co-03)
def supported_formats() -> list[str]:  # => the unit under test: a fixed list of formats
    return ["json", "xml", "csv"]  # => a plain list -- membership uses Python's "in" operator
 
 
def test_membership_passes_for_a_present_element() -> None:  # => the "in" happy path
    formats = supported_formats()  # => arrange: call the function once, reuse the result
    assert "json" in formats  # => act+assert combined: "in" is itself the check (co-03)
 
 
def test_membership_for_an_absent_element() -> None:  # => the "not in" negation, its own test
    formats = supported_formats()  # => same arrange step, independent test (co-26 isolation)
    assert "yaml" not in formats  # => "not in" is membership's negation -- equally a plain assert  # fmt: skip

collected 2 items
 
test_example.py::test_membership_passes_for_a_present_element PASSED     [ 50%]
test_example.py::test_membership_for_an_absent_element PASSED            [100%]
 
============================== 2 passed in 0.07s ===============================

# learning/code/ex-08-raises-valueerror/test_example.py
"""Example 8: Raises ValueError."""
 
import pytest  # => brings in pytest.raises, the exception-testing context manager (co-04)
 
 
def parse_positive_int(text: str) -> int:  # => the unit under test
    value = int(text)  # => may itself raise ValueError for non-numeric text -- not caught here
    if value <= 0:  # => a SECOND way to reach the same exception type
        raise ValueError(f"expected a positive integer, got {value}")  # => explicit raise
    return value  # => only reached when value is a genuine positive integer
 
 
def test_raises_valueerror_on_non_positive_input() -> None:
    with pytest.raises(ValueError):  # => wraps the call -- the block must raise EXACTLY this  # fmt: skip
        parse_positive_int("-5")  # => act: -5 is not positive, so ValueError fires as expected
    # => if parse_positive_int("-5") had returned normally instead of raising, this test
    # => would fail with "DID NOT RAISE ValueError" -- pytest.raises checks BOTH directions

collected 1 item
 
test_example.py::test_raises_valueerror_on_non_positive_input PASSED     [100%]
 
============================== 1 passed in 0.06s ===============================

# learning/code/ex-09-raises-match-message/test_example.py
"""Example 9: Raises with a Matching Message."""
 
import pytest  # => same pytest.raises context manager as ex-08, plus its match= parameter
 
 
def parse_positive_int(text: str) -> int:  # => identical unit under test to ex-08
    value = int(text)  # => ValueError here if text is not numeric at all
    if value <= 0:  # => the branch this example specifically targets
        raise ValueError(f"expected a positive integer, got {value}")  # => message MATTERS here  # fmt: skip
    return value  # => the success path, not exercised by this particular test
 
 
def test_raises_match_checks_the_message_text() -> None:
    # match= takes a regex, checked with re.search against str(exception) -- not equality
    with pytest.raises(ValueError, match="expected a positive integer, got -5"):  # => co-04  # fmt: skip
        parse_positive_int("-5")  # => act: raises ValueError("expected a positive integer, got -5")  # fmt: skip
    # => a DIFFERENT message (say, "bad input") would make this test fail even though a
    # => ValueError still fired -- match= asserts on THE EXCEPTION'S CONTENT, not just its type

collected 1 item
 
test_example.py::test_raises_match_checks_the_message_text PASSED        [100%]
 
============================== 1 passed in 0.07s ===============================

# learning/code/ex-10-approx-float/test_example.py
"""Example 10: Approx for Floats."""
 
import pytest  # => brings in pytest.approx, the tolerance-based float comparator (co-07)
 
 
def test_float_addition_is_not_exact() -> None:  # => documents WHY approx exists at all
    assert 0.1 + 0.2 != 0.3  # => binary floating point cannot represent 0.1 exactly (IEEE 754)
    # => this assert PASSES specifically because 0.1 + 0.2 is 0.30000000000000004, not 0.3
 
 
def test_approx_treats_them_as_equal_anyway() -> None:
    assert 0.1 + 0.2 == pytest.approx(0.3)  # => approx wraps 0.3 in a tolerance-aware comparator  # fmt: skip
    # => approx's default relative tolerance is 1e-6 -- the 4e-17 error above is far inside it,
    # => so this comparison succeeds even though the plain == in the test above it fails

collected 2 items
 
test_example.py::test_float_addition_is_not_exact PASSED                 [ 50%]
test_example.py::test_approx_treats_them_as_equal_anyway PASSED          [100%]
 
============================== 2 passed in 0.07s ===============================

# learning/code/ex-11-simple-fixture/test_example.py
"""Example 11: A Simple Fixture."""
 
import pytest  # => brings in the @pytest.fixture decorator (co-05)
 
 
@pytest.fixture
def sample_user() -> dict[str, str]:  # => a fixture: reusable setup, injected by NAME (co-05)
    return {"name": "Ada", "role": "engineer"}  # => a fresh dict built fresh for each test  # fmt: skip
 
 
def test_fixture_is_injected_by_parameter_name(sample_user: dict[str, str]) -> None:
    # => pytest sees the parameter name "sample_user", matches it to the fixture ABOVE
    # => by name alone, calls the fixture function, and passes its return value in here
    assert sample_user["name"] == "Ada"  # => confirms the injected value is the real fixture output  # fmt: skip
    assert sample_user["role"] == "engineer"  # => a second field, same injected dict
 
 
def test_fixture_gives_a_fresh_copy_each_test(sample_user: dict[str, str]) -> None:
    sample_user["role"] = "mutated"  # => mutate the dict THIS test received
    assert sample_user["role"] == "mutated"  # => confirms the mutation stuck for this test only
    # => the test above never sees "mutated" -- pytest calls sample_user() again per test,
    # => by default (function scope), so each test gets its OWN independent dict instance

collected 2 items
 
test_example.py::test_fixture_is_injected_by_parameter_name PASSED       [ 50%]
test_example.py::test_fixture_gives_a_fresh_copy_each_test PASSED        [100%]
 
============================== 2 passed in 0.07s ===============================

# learning/code/ex-12-fixture-teardown/test_example.py
"""Example 12: Fixture Teardown with yield."""
 
import pytest  # => same @pytest.fixture decorator, this time using yield instead of return
 
teardown_log: list[str] = []  # => module-level list -- proves teardown genuinely ran, in order  # fmt: skip
 
 
@pytest.fixture
def managed_resource():  # => a fixture with SETUP before yield, TEARDOWN after it (co-05)
    teardown_log.append("setup")  # => runs BEFORE the test body -- setup half of the fixture
    resource = {"open": True}  # => the value the test body actually receives
    yield resource  # => pytest pauses HERE, hands `resource` to the test, resumes after the test returns  # fmt: skip
    # => everything below this yield is teardown -- it runs even if the test body raised
    resource["open"] = False  # => simulates closing/releasing the resource
    teardown_log.append("teardown")  # => proves this line genuinely executed, and in what order
 
 
def test_resource_is_open_during_the_test(managed_resource: dict[str, bool]) -> None:
    assert managed_resource["open"] is True  # => teardown has NOT run yet -- test body sees "open"  # fmt: skip
    assert teardown_log == ["setup"]  # => confirms setup ran, teardown has not, at this exact point  # fmt: skip
 
 
def test_teardown_ran_after_the_previous_test() -> None:
    # => this SECOND test runs after the FIRST test's fixture instance has already
    # => been torn down (function-scoped fixtures tear down before the next test starts)
    assert teardown_log == ["setup", "teardown"]  # => "teardown" is now present, appended after the yield  # fmt: skip

collected 2 items
 
test_example.py::test_resource_is_open_during_the_test PASSED            [ 50%]
test_example.py::test_teardown_ran_after_the_previous_test PASSED        [100%]
 
============================== 2 passed in 0.07s ===============================

# learning/code/ex-13-fixture-scope/test_example.py
"""Example 13: Fixture Scope -- Module."""
 
import pytest  # => same @pytest.fixture decorator, this time with an explicit scope= (co-05)
 
# => module-level state is the ONLY way to observe how many times a fixture body ran
build_count = 0  # => module-level counter -- proves HOW MANY TIMES the fixture body ran  # fmt: skip
 
 
@pytest.fixture(scope="module")  # => scope="module": built ONCE, shared across this whole file  # fmt: skip
def shared_connection() -> dict[str, int]:  # => the fixture body -- WHEN it reruns is the decorator's job  # fmt: skip
    global build_count  # => needed to mutate the module-level counter from inside the fixture
    build_count += 1  # => increments EXACTLY once per module, not once per test, if scope works
    return {"connection_id": build_count}  # => the same dict object every test in this file receives  # fmt: skip
 
 
def test_first_test_sees_connection_id_one(shared_connection: dict[str, int]) -> None:  # => pytest resolves the param via the fixture above  # fmt: skip
    assert shared_connection["connection_id"] == 1  # => first use -- fixture just built it  # fmt: skip
    assert build_count == 1  # => confirms the fixture body has run exactly once so far
 
 
def test_second_test_reuses_the_same_instance(shared_connection: dict[str, int]) -> None:  # => same param name -- pytest injects the ALREADY-BUILT instance  # fmt: skip
    assert shared_connection["connection_id"] == 1  # => SAME id as the first test -- not rebuilt  # fmt: skip
    assert build_count == 1  # => STILL 1 -- proves scope="module" built it only once for the file  # fmt: skip

collected 2 items
 
test_example.py::test_first_test_sees_connection_id_one PASSED           [ 50%]
test_example.py::test_second_test_reuses_the_same_instance PASSED        [100%]
 
============================== 2 passed in 0.07s ===============================

# learning/code/ex-14-parametrize-cases/test_example.py
"""Example 14: Parametrize Three Cases."""
 
import pytest  # => brings in @pytest.mark.parametrize (co-06)
 
 
def double(n: int) -> int:  # => the unit under test
    return n * 2  # => a pure function -- exactly what parametrize is best suited to exercise
 
 
@pytest.mark.parametrize(  # => starts the parametrize call -- ids are inferred below (Example 15 gives them explicitly)  # fmt: skip
    "input_value, expected",  # => two parameter NAMES, matched to the test function's args
    [  # => the list of rows -- each tuple below becomes one independently-reported test case  # fmt: skip
        (1, 2),  # => row 1: double(1) should be 2
        (2, 4),  # => row 2: double(2) should be 4
        (10, 20),  # => row 3: double(10) should be 20
    ],
)  # => end of parametrize's argument list -- three rows queued above  # fmt: skip
def test_double_over_three_rows(input_value: int, expected: int) -> None:  # => the SAME body runs once per row  # fmt: skip
    # => pytest runs THIS ONE function body three separate times, once per row above,
    # => reporting each row as its OWN pass/fail case in the output (co-06)
    assert double(input_value) == expected  # => act+assert, identical logic, different data each run  # fmt: skip

collected 3 items
 
test_example.py::test_double_over_three_rows[1-2] PASSED                 [ 33%]
test_example.py::test_double_over_three_rows[2-4] PASSED                 [ 66%]
test_example.py::test_double_over_three_rows[10-20] PASSED               [100%]
 
============================== 3 passed in 0.07s ===============================

# learning/code/ex-15-parametrize-ids/test_example.py
"""Example 15: Parametrize with Readable ids."""
 
import pytest  # => same @pytest.mark.parametrize as ex-14, this time with explicit ids= (co-06)
 
 
def classify_sign(n: int) -> str:  # => the unit under test
    if n > 0:  # => branch 1
        return "positive"  # => label for anything above zero
    if n < 0:  # => branch 2
        return "negative"  # => label for anything below zero
    return "zero"  # => branch 3 -- exactly n == 0
 
 
@pytest.mark.parametrize(  # => same decorator as ex-14, now with an explicit ids= argument below  # fmt: skip
    "value, expected",  # => the two parameter NAMES, unchanged from ex-14's shape  # fmt: skip
    [  # => the same three rows as ex-14 in spirit, now paired with readable ids=  # fmt: skip
        (5, "positive"),  # => row 1 -- would otherwise show as an opaque "test_...[5-positive0]"  # fmt: skip
        (-3, "negative"),  # => row 2 -- same problem without a readable id
        (0, "zero"),  # => row 3 -- hardest row to recognize by VALUE alone in a report
    ],
    ids=["positive-input", "negative-input", "zero-input"],  # => one readable id per row, in order  # fmt: skip
)  # => end of parametrize's argument list -- three rows, three matching ids, queued above  # fmt: skip
def test_classify_sign_with_readable_ids(value: int, expected: str) -> None:  # => the SAME body runs once per row  # fmt: skip
    assert classify_sign(value) == expected  # => the assertion itself is identical to ex-14's shape  # fmt: skip
    # => what differs is purely REPORTING: -v output shows test_...[positive-input] instead
    # => of test_...[5-positive0], which matters once a suite has dozens of parametrized rows

collected 3 items
 
test_example.py::test_classify_sign_with_readable_ids[positive-input] PASSED [ 33%]
test_example.py::test_classify_sign_with_readable_ids[negative-input] PASSED [ 66%]
test_example.py::test_classify_sign_with_readable_ids[zero-input] PASSED [100%]
 
============================== 3 passed in 0.08s ===============================

# learning/code/ex-16-parametrize-multiple-args/test_example.py
"""Example 16: Parametrize Multiple Arguments."""
 
import pytest  # => same parametrize mark, now stacking TWO separate decorators (co-06)
 
 
def format_greeting(name: str, punctuation: str) -> str:  # => the unit under test, two inputs
    return f"Hello, {name}{punctuation}"  # => combines both parameters into one string
 
 
@pytest.mark.parametrize("name", ["Ada", "Grace"])  # => axis 1: two possible names  # fmt: skip
@pytest.mark.parametrize("punctuation", ["!", "."])  # => axis 2: two possible punctuation marks  # fmt: skip
def test_greeting_over_every_combination(name: str, punctuation: str) -> None:
    # => STACKING two @parametrize decorators multiplies the axes: 2 names x 2 punctuation
    # => marks = 4 total test runs, one per (name, punctuation) COMBINATION (co-06)
    result = format_greeting(name, punctuation)  # => act: build the actual greeting string
    assert result.startswith("Hello, ")  # => assert 1: the fixed prefix is always present
    assert result.endswith(punctuation)  # => assert 2: the LAST character is always this row's mark  # fmt: skip
    assert name in result  # => assert 3: this row's name appears somewhere in the middle

collected 4 items
 
test_example.py::test_greeting_over_every_combination[!-Ada] PASSED      [ 25%]
test_example.py::test_greeting_over_every_combination[!-Grace] PASSED    [ 50%]
test_example.py::test_greeting_over_every_combination[.-Ada] PASSED      [ 75%]
test_example.py::test_greeting_over_every_combination[.-Grace] PASSED    [100%]
 
============================== 4 passed in 0.07s ===============================

# learning/code/ex-17-mark-skip/test_example.py
"""Example 17: Mark a Test skip."""
 
import pytest  # => brings in @pytest.mark.skip, a BUILTIN marker needing no registration (co-08)
 
 
def divide(a: int, b: int) -> float:  # => the unit under test
    return a / b  # => raises ZeroDivisionError if b == 0 -- not handled here on purpose
 
 
def test_divide_normal_case() -> None:  # => runs normally -- included only for contrast
    assert divide(10, 2) == 5.0  # => a plain, unskipped assertion
 
 
@pytest.mark.skip(reason="division-by-zero handling not implemented yet")  # => co-08: skip, with a REQUIRED-by-convention reason string  # fmt: skip
def test_divide_by_zero_not_yet_supported() -> None:
    # => pytest never even EXECUTES this function body -- it is reported as "skipped"
    # => before a single line inside it runs, which is why this can safely contain
    # => code that would otherwise crash (ZeroDivisionError) without failing the suite
    assert divide(10, 0) == float("inf")  # => this line never actually runs -- entirely skipped  # fmt: skip

collected 2 items
 
test_example.py::test_divide_normal_case PASSED                          [ 50%]
test_example.py::test_divide_by_zero_not_yet_supported SKIPPED (divi...) [100%]
 
========================= 1 passed, 1 skipped in 0.10s =========================

# learning/code/ex-18-mark-xfail/test_example.py
"""Example 18: Mark a Test xfail."""
 
import pytest  # => brings in @pytest.mark.xfail, another builtin marker (co-08)
 
 
def reverse_words(sentence: str) -> str:  # => the unit under test -- has a KNOWN bug below
    words = sentence.split(" ")  # => splits on a single space only
    return " ".join(words)  # => bug: this REJOINS in the SAME order -- it never reverses anything  # fmt: skip
 
 
def test_reverse_words_normal_case() -> None:  # => runs normally -- passes, included for contrast
    assert reverse_words("a b") != "a b b"  # => a trivially true assertion, unrelated to the known bug  # fmt: skip
 
 
@pytest.mark.xfail(reason="reverse_words has a known bug -- it never actually reverses")  # => co-08  # fmt: skip
def test_reverse_words_is_known_broken() -> None:
    # => this assertion is EXPECTED to fail, because of the real bug in reverse_words above
    assert reverse_words("hello world") == "world hello"  # => genuinely fails: bug returns "hello world"  # fmt: skip
    # => pytest reports this as "xfail" (expected failure), NOT as a suite-breaking "failed" --
    # => if this line ever started passing unexpectedly, pytest would instead report "XPASS"

collected 2 items
 
test_example.py::test_reverse_words_normal_case PASSED                   [ 50%]
test_example.py::test_reverse_words_is_known_broken XFAIL (reverse_w...) [100%]
 
========================= 1 passed, 1 xfailed in 0.08s =========================

# learning/code/ex-19-custom-marker-select/test_example.py
"""Example 19: A Custom Marker and -m Selection."""
 
import pytest  # => brings in @pytest.mark.slow -- a CUSTOM marker, registered in pytest.ini (co-08)
 
 
def fast_lookup(n: int) -> int:  # => a cheap, instant computation -- stands in for "fast" work
    return n * n  # => no sleep, no I/O -- genuinely fast
 
 
def heavy_computation(n: int) -> int:  # => stands in for "slow" work, without an ACTUAL sleep()  # fmt: skip
    return sum(range(n))  # => still fast in wall-clock time -- the MARKER, not real duration, is the point  # fmt: skip
 
 
def test_fast_lookup_always_runs() -> None:  # => no marker at all -- included in every run
    assert fast_lookup(5) == 25  # => a plain, unmarked test
 
 
@pytest.mark.slow  # => co-08: a CUSTOM label, meaningful only because of pytest.ini's registration  # fmt: skip
def test_heavy_computation_is_marked_slow() -> None:
    assert heavy_computation(100) == 4950  # => sum(range(100)) == 4950 -- still correct, just labeled  # fmt: skip
    # => running plain `pytest` executes BOTH tests; running `pytest -m "not slow"`
    # => excludes THIS test specifically, based purely on the marker name above

; ex-19: registers the CUSTOM "slow" marker used by test_example.py in this directory --
; without this file, pytest still runs the tests correctly, but prints a
; PytestUnknownMarkWarning for every use of an unregistered custom marker (co-08)
[pytest]
markers =
    slow: marks a test as slow, excludable via -m "not slow"

collected 2 items
 
test_example.py::test_fast_lookup_always_runs PASSED                     [ 50%]
test_example.py::test_heavy_computation_is_marked_slow PASSED            [100%]
 
============================== 2 passed in 0.06s ===============================

collected 2 items / 1 deselected / 1 selected
 
test_example.py::test_fast_lookup_always_runs PASSED                     [100%]
 
======================= 1 passed, 1 deselected in 0.06s ========================

# learning/code/ex-20-keyword-select/test_example.py
"""Example 20: Keyword Selection with -k."""
 
# ex-20: four tests, only SOME of whose NAMES contain the substring "add" (co-08)
def add(a: int, b: int) -> int:  # => the unit under test for the matching tests
    return a + b  # => a plain pure function
 
 
def subtract(a: int, b: int) -> int:  # => a second, unrelated unit under test
    return a - b  # => used by the NON-matching tests below
 
 
def test_add_two_positives() -> None:  # => name CONTAINS "add" -- selected by -k "add"
    assert add(2, 3) == 5  # => passes
 
 
def test_add_negative_numbers() -> None:  # => name ALSO contains "add" -- also selected
    assert add(-2, -3) == -5  # => passes
 
 
def test_subtract_two_positives() -> None:  # => name does NOT contain "add" -- excluded
    assert subtract(5, 3) == 2  # => passes, but never runs under `pytest -k "add"`
 
 
def test_subtract_negative_numbers() -> None:  # => name does NOT contain "add" -- also excluded  # fmt: skip
    assert subtract(-5, -3) == -2  # => passes, but also skipped by the keyword filter

collected 4 items / 2 deselected / 2 selected
 
test_example.py::test_add_two_positives PASSED                           [ 50%]
test_example.py::test_add_negative_numbers PASSED                        [100%]
 
======================= 2 passed, 2 deselected in 0.07s ========================

# learning/code/ex-21-group-tests-in-class/test_example.py
"""Example 21: Group Tests in a Class."""
 
# ex-21: related tests grouped in a class -- pytest discovers Test* classes automatically (co-09)
class Adder:  # => the unit under test -- a tiny class, not itself a test class
    def add(self, a: int, b: int) -> int:  # => instance method under test
        return a + b  # => a plain, pure computation
 
 
class TestAdder:  # => MUST start with "Test" (capital T) for pytest to discover it (co-09)
    def setup_method(self) -> None:  # => pytest calls this before EACH test method in the class  # fmt: skip
        self.adder = Adder()  # => fresh Adder instance per test -- shared setup, isolated state  # fmt: skip
 
    def test_add_two_positive_numbers(self) -> None:  # => method name still needs the test_ prefix  # fmt: skip
        assert self.adder.add(2, 3) == 5  # => uses the instance setup_method just built
 
    def test_add_a_positive_and_a_negative(self) -> None:  # => a SECOND method in the same class
        assert self.adder.add(10, -4) == 6  # => a SECOND test, sharing setup_method's fresh instance  # fmt: skip
 
    def test_add_two_negative_numbers(self) -> None:  # => a THIRD method, same class, same setup
        assert self.adder.add(-3, -7) == -10  # => grouped alongside the other two -- one coherent unit  # fmt: skip

collected 3 items
 
test_example.py::TestAdder::test_add_two_positive_numbers PASSED         [ 33%]
test_example.py::TestAdder::test_add_a_positive_and_a_negative PASSED    [ 66%]
test_example.py::TestAdder::test_add_two_negative_numbers PASSED         [100%]
 
============================== 3 passed in 0.06s ===============================

# learning/code/ex-22-shared-conftest-fixture/conftest.py
import pytest  # => conftest.py is pytest's AUTO-DISCOVERED, no-import-needed fixture home (co-09)
 
 
@pytest.fixture
def shared_greeting() -> str:  # => defined ONCE here, usable by EVERY test file in this directory  # fmt: skip
    return "hello from conftest"  # => a plain string -- the content itself is not the point here  # fmt: skip
    # => neither test_example.py nor test_more.py IMPORTS this fixture explicitly --
    # => pytest finds conftest.py automatically and makes its fixtures available by name

# learning/code/ex-22-shared-conftest-fixture/test_example.py
"""Example 22: A Shared Fixture in conftest.py."""
 
# ex-22a: this file uses shared_greeting WITHOUT ever importing it (co-09, co-05)
def test_first_file_sees_the_shared_fixture(shared_greeting: str) -> None:
    # => "shared_greeting" resolves purely by matching this PARAMETER NAME against
    # => conftest.py's fixture of the same name -- pytest wires this up automatically
    assert shared_greeting == "hello from conftest"  # => confirms the injected value is real  # fmt: skip

# learning/code/ex-22-shared-conftest-fixture/test_more.py
# ex-22b: a COMPLETELY SEPARATE test file, reusing the SAME conftest.py fixture (co-09)
def test_second_file_also_sees_it(shared_greeting: str) -> None:
    # => this file never imports test_example.py OR conftest.py directly -- the fixture
    # => is shared purely because both files live in the same directory as conftest.py
    assert len(shared_greeting) > 0  # => a second, independent assertion on the same shared value  # fmt: skip
    assert "conftest" in shared_greeting  # => confirms it's genuinely the SAME string both files see  # fmt: skip

collected 2 items
 
test_example.py::test_first_file_sees_the_shared_fixture PASSED          [ 50%]
test_more.py::test_second_file_also_sees_it PASSED                       [100%]
 
============================== 2 passed in 0.07s ===============================

# learning/code/ex-23-tdd-write-failing-first/test_example.py
"""Example 23: TDD Step 1 -- Red."""
 
# ex-23: TDD step 1 -- RED. clamp() is called below but never defined anywhere in this file (co-17)
 
 
def test_clamp_restricts_value_to_a_range() -> None:
    # => act: calls a function that does not exist yet anywhere in this module or an import
    result = clamp(15, minimum=0, maximum=10)  # => NameError: 'clamp' is not defined  # fmt: skip
    # => this line is UNREACHABLE right now -- pytest reports the NameError from the line
    # => above as the test's failure, before this assert is ever evaluated at all
    assert result == 10  # => the eventual, INTENDED behavior -- not yet true, not yet checked

collected 1 item
 
test_example.py::test_clamp_restricts_value_to_a_range FAILED            [100%]
 
=================================== FAILURES ===================================
____________________ test_clamp_restricts_value_to_a_range _____________________
 
    def test_clamp_restricts_value_to_a_range() -> None:
        # => act: calls a function that does not exist yet anywhere in this module or an import
>       result = clamp(15, minimum=0, maximum=10)  # => NameError: 'clamp' is not defined  # fmt: skip
                 ^^^^^
E       NameError: name 'clamp' is not defined
 
test_example.py:9: NameError
=========================== short test summary info ============================
FAILED test_example.py::test_clamp_restricts_value_to_a_range - NameError: na...
============================== 1 failed in 0.08s ===============================

# learning/code/ex-24-tdd-make-it-pass/test_example.py
"""Example 24: TDD Step 2 -- Green."""
 
# ex-24: TDD step 2 -- GREEN. The SAME test as ex-23, now with a MINIMAL implementation (co-17)
def clamp(value: int, minimum: int, maximum: int) -> int:  # => just enough code to pass  # fmt: skip
    if value < minimum:  # => branch 1: value is too low
        return minimum  # => clamp it UP to the floor
    if value > maximum:  # => branch 2: value is too high
        return maximum  # => clamp it DOWN to the ceiling
    return value  # => branch 3: value is already inside [minimum, maximum] -- leave it alone  # fmt: skip
 
 
def test_clamp_restricts_value_to_a_range() -> None:  # => IDENTICAL test body to ex-23's red version  # fmt: skip
    result = clamp(15, minimum=0, maximum=10)  # => now resolves -- clamp() exists in this file  # fmt: skip
    assert result == 10  # => 15 is above maximum=10, so it clamps DOWN to 10 -- now genuinely true  # fmt: skip
    # => this exact assertion was FALSE-BY-NONEXISTENCE in ex-23 (NameError) and is now
    # => a real, passing check -- red became green by adding the smallest correct implementation

collected 1 item
 
test_example.py::test_clamp_restricts_value_to_a_range PASSED            [100%]
 
============================== 1 passed in 0.07s ===============================

# learning/code/ex-25-tdd-refactor-under-green/test_example.py
"""Example 25: TDD Step 3 -- Refactor."""
 
# ex-25: TDD step 3 -- REFACTOR. Same test, DIFFERENT (shorter) implementation (co-17)
def clamp(value: int, minimum: int, maximum: int) -> int:  # => refactored: one expression  # fmt: skip
    # => max(minimum, ...) rules out anything below the floor; min(maximum, ...) then rules
    # => out anything above the ceiling -- functionally IDENTICAL to ex-24's three branches
    return max(minimum, min(maximum, value))  # => a single line replaces three if/return statements  # fmt: skip
 
 
def test_clamp_restricts_value_to_a_range() -> None:  # => the EXACT SAME test as ex-23 and ex-24  # fmt: skip
    result = clamp(15, minimum=0, maximum=10)  # => still resolves to 10 -- behavior unchanged  # fmt: skip
    assert result == 10  # => still passes -- the refactor changed the CODE, not the CONTRACT
    # => this is TDD's third step in miniature: the test suite (unchanged) is what makes
    # => it safe to rewrite the implementation -- if the refactor broke something, this
    # => exact same assertion would have caught it immediately
 
 
def test_clamp_also_handles_the_low_side() -> None:  # => a SECOND case, added during refactor  # fmt: skip
    assert clamp(-5, minimum=0, maximum=10) == 0  # => -5 is below minimum=0, clamps UP to 0  # fmt: skip
    # => confirms the refactored one-liner covers BOTH directions, not just the high side
    # => ex-23/ex-24 exercised directly -- refactoring is also a natural point to add coverage

collected 2 items
 
test_example.py::test_clamp_restricts_value_to_a_range PASSED            [ 50%]
test_example.py::test_clamp_also_handles_the_low_side PASSED             [100%]
 
============================== 2 passed in 0.07s ===============================

# learning/code/ex-26-test-pure-function/test_example.py
"""Example 26: Testing a Pure Function."""
 
# ex-26: a PURE function -- same input always gives the same output, no side effects (co-01, co-26)  # fmt: skip
def celsius_to_fahrenheit(celsius: float) -> float:  # => the unit under test
    return celsius * 9 / 5 + 32  # => a pure formula -- reads no state, writes no state
 
 
def test_freezing_point_of_water() -> None:  # => a well-known, easily-verified reference point  # fmt: skip
    assert celsius_to_fahrenheit(0) == 32  # => 0C is EXACTLY 32F -- an integer-clean case
 
 
def test_boiling_point_of_water() -> None:  # => a second well-known reference point
    assert celsius_to_fahrenheit(100) == 212  # => 100C is EXACTLY 212F -- also integer-clean
 
 
def test_a_negative_temperature() -> None:  # => confirms the formula works below zero too
    assert celsius_to_fahrenheit(-40) == -40  # => -40 is the ONE temperature where C and F agree  # fmt: skip
 
 
def test_calling_it_twice_gives_the_same_result() -> None:  # => directly demonstrates PURITY  # fmt: skip
    first_call = celsius_to_fahrenheit(37)  # => call 1, same input as call 2 below
    second_call = celsius_to_fahrenheit(37)  # => call 2, no state changed between calls
    assert first_call == second_call  # => a pure function can never disagree with itself (co-26)

collected 4 items
 
test_example.py::test_freezing_point_of_water PASSED                     [ 25%]
test_example.py::test_boiling_point_of_water PASSED                      [ 50%]
test_example.py::test_a_negative_temperature PASSED                      [ 75%]
test_example.py::test_calling_it_twice_gives_the_same_result PASSED      [100%]
 
============================== 4 passed in 0.07s ===============================

# learning/code/ex-27-deterministic-no-hidden-state/test_example.py
"""Example 27: Deterministic, Order-Independent Tests."""
 
# ex-27: two tests that could, in principle, run in EITHER order -- neither depends on the other (co-26)  # fmt: skip
_counter_state = {"value": 0}  # => module-level state that COULD leak between tests if misused  # fmt: skip
 
 
def increment_and_reset(state: dict[str, int]) -> int:  # => the unit under test
    state["value"] += 1  # => mutates the PASSED-IN dict, not the module-level one directly  # fmt: skip
    result = state["value"]  # => capture before resetting
    state["value"] = 0  # => reset immediately -- the function itself leaves no lasting trace  # fmt: skip
    return result  # => returns exactly 1, every single time, regardless of call order
 
 
def test_increment_and_reset_called_first() -> None:
    fresh_state = {"value": 0}  # => arrange: a FRESH dict, not the shared module-level one  # fmt: skip
    assert increment_and_reset(fresh_state) == 1  # => always 1 -- no hidden dependency on prior calls  # fmt: skip
    assert fresh_state["value"] == 0  # => confirms the function reset its OWN input, leaking nothing  # fmt: skip
 
 
def test_increment_and_reset_called_second() -> None:
    fresh_state = {"value": 0}  # => a SEPARATE fresh dict -- identical starting point to the test above  # fmt: skip
    assert increment_and_reset(fresh_state) == 1  # => IDENTICAL result -- order-independent (co-26)  # fmt: skip
    # => if this test depended on test_increment_and_reset_called_first running earlier
    # => and mutating shared state, running these two tests in reverse order (pytest
    # => supports random ordering via plugins) would produce a DIFFERENT result here

collected 2 items
 
test_example.py::test_increment_and_reset_called_first PASSED            [ 50%]
test_example.py::test_increment_and_reset_called_second PASSED           [100%]
 
============================== 2 passed in 0.07s ===============================

# learning/code/ex-28-run-verbose-report/test_example.py
"""Example 28: A Verbose Test Report."""
 
# ex-28: three tests -- two pass, one fails -- run with -v to see each one named individually (co-27, co-02)  # fmt: skip
def is_palindrome(text: str) -> bool:  # => the unit under test
    return text == text[::-1]  # => reversed-string comparison -- simple, deliberately no normalization  # fmt: skip
 
 
def test_racecar_is_a_palindrome() -> None:  # => PASSES -- shown by name in -v output
    assert is_palindrome("racecar")  # => "racecar" reversed is still "racecar"
 
 
def test_hello_is_not_a_palindrome() -> None:  # => PASSES -- also shown by name in -v output
    assert not is_palindrome("hello")  # => "hello" reversed is "olleh" -- correctly not equal
 
 
def test_mixed_case_palindrome_without_normalization() -> None:  # => FAILS -- deliberately, to show -v's PASS/FAIL mix  # fmt: skip
    # => "Racecar" reversed is "racecaR" -- differs by case, since is_palindrome does
    # => no case-folding -- this test intentionally exposes that limitation
    assert is_palindrome("Racecar")  # => genuinely False -- this assert fails on purpose

collected 3 items
 
test_example.py::test_racecar_is_a_palindrome PASSED                     [ 33%]
test_example.py::test_hello_is_not_a_palindrome PASSED                   [ 66%]
test_example.py::test_mixed_case_palindrome_without_normalization FAILED [100%]
 
=================================== FAILURES ===================================
_______________ test_mixed_case_palindrome_without_normalization _______________
 
    def test_mixed_case_palindrome_without_normalization() -> None:  # => FAILS -- deliberately, to show -v's PASS/FAIL mix  # fmt: skip
        # => "Racecar" reversed is "racecaR" -- differs by case, since is_palindrome does
        # => no case-folding -- this test intentionally exposes that limitation
>       assert is_palindrome("Racecar")  # => genuinely False -- this assert fails on purpose
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E       AssertionError: assert False
E        +  where False = is_palindrome('Racecar')
 
test_example.py:17: AssertionError
=========================== short test summary info ============================
FAILED test_example.py::test_mixed_case_palindrome_without_normalization - As...
========================= 1 failed, 2 passed in 0.09s ==========================