Testing Functions and Return Values

We systematically test return values across the project, including edge cases: empty inputs, boundary values, and the exact examples used in each session's own concept explanation.

1. Learning Objective

2. Pre-Coding Quiz

Answer these before reading the concept explanation or writing any code. It is fine to get these wrong — that is the point. You need 4/5 to proceed to the lab.

3. The Concept — Testing Return Values Systematically

Three kinds of cases: normal, edge, and boundary

A thorough test suite for a function covers its normal, expected use; edge cases (empty inputs, zero matches); and boundary cases (values right at a validation limit, like exactly 0).

# country.py additions
def find_by_region(countries, region):
    return [c for c in countries if c.region == region]

# tests/test_find_by_region.py
from country import Country, find_by_region

def test_find_by_region_normal_case():
    countries = [
        Country(name="Kenya", region="Africa", population=54000000),
        Country(name="Peru", region="Americas", population=33000000),
    ]
    result = find_by_region(countries, "Africa")
    assert [c.name for c in result] == ["Kenya"]  # exact contents, not just length

def test_find_by_region_no_matches_returns_empty_list():
    countries = [Country(name="Kenya", region="Africa", population=54000000)]
    result = find_by_region(countries, "Antarctica")
    assert result == []  # Session 17's guarantee, verified

def test_find_by_region_empty_source_list():
    result = find_by_region([], "Africa")
    assert result == []

Parametrizing repetitive test logic

When the same test logic needs to run against several input/output pairs, @pytest.mark.parametrize avoids copy-pasting near-identical test functions.

import pytest
from country import Country

@pytest.mark.parametrize("value,expected_valid", [
    (54000000, True),
    (0, True),         # boundary — exactly zero should be valid
    (-1, False),        # boundary — just below zero should be invalid
    (-999999, False),
])
def test_set_population_validity(value, expected_valid):
    k = Country(name="Kenya", region="Africa", population=1)
    if expected_valid:
        k.set_population(value)
        assert k.population == value
    else:
        with pytest.raises(ValueError):
            k.set_population(value)

Testing from_dict with valid and malformed input

Session 18's classmethod is a natural place for edge-case testing: what happens with correct data, and what happens with a missing required field.

import pytest
from country import Country

def test_from_dict_builds_correct_instance():
    data = {"name": "Kenya", "region": "Africa", "population": 54000000}
    k = Country.from_dict(data)
    assert k.name == "Kenya"
    assert k.population == 54000000

def test_from_dict_missing_field_raises():
    data = {"name": "Ghost Nation"}  # missing region and population
    with pytest.raises(TypeError):
        Country.from_dict(data)

4. Lab

What you will build

A file called tests/test_return_values.py, building on Session 32's country.py.

Step-by-step instructions

# country.py (additions)
def find_by_region(countries, region):
    return [c for c in countries if c.region == region]

class Country:
    # ... existing __init__, summary, set_population, grow_population ...

    @classmethod
    def from_dict(cls, data):
        return cls(**data)

# tests/test_return_values.py
import pytest
from country import Country, find_by_region

def test_find_by_region_returns_exact_matches():
    countries = [
        Country(name="Kenya", region="Africa", population=54000000),
        Country(name="Ghana", region="Africa", population=31000000),
        Country(name="Peru", region="Americas", population=33000000),
    ]
    result = find_by_region(countries, "Africa")
    assert [c.name for c in result] == ["Kenya", "Ghana"]

def test_find_by_region_no_matches():
    countries = [Country(name="Kenya", region="Africa", population=54000000)]
    assert find_by_region(countries, "Antarctica") == []

def test_find_by_region_empty_source():
    assert find_by_region([], "Africa") == []

def test_from_dict_valid():
    k = Country.from_dict({"name": "Kenya", "region": "Africa", "population": 54000000})
    assert k.name == "Kenya"
    assert k.population == 54000000

def test_from_dict_missing_field_raises():
    with pytest.raises(TypeError):
        Country.from_dict({"name": "Ghost Nation"})

@pytest.mark.parametrize("value,should_succeed", [
    (54000000, True),
    (0, True),
    (-1, False),
])
def test_set_population_boundaries(value, should_succeed):
    k = Country(name="Kenya", region="Africa", population=1)
    if should_succeed:
        k.set_population(value)
        assert k.population == value
    else:
        with pytest.raises(ValueError):
            k.set_population(value)

# Run: pytest -v   (the -v flag shows each parametrized case individually)

5. Expected Files Changed

6. Commit Checkpoint

Once the lab is complete and you can explain every line, make this exact commit:

git add country.py tests/test_return_values.py docs/sessions/session-33/index.html
git commit -m "session-33: systematically test return values, including edge and boundary cases"

7. Code Review Checklist

Go through your code line by line and check each item:

8. Post-Coding Quiz

Same 5 questions. Take it again now that you have written and run the code. You need 4/5 to mark this session complete.

9. Reflection Questions

Think through these after the post-quiz. No right answer — they are for discussion.

10. What Breaks If This Knowledge Is Missing?

11. What We Learned