Day 12: Tests and repeatable programs

Reference implementation (both files in the same directory; verified with Python 3.13 and 3.14):
# file: counter.py
def count_non_empty(lines):
"""Return how many items contain non-whitespace text.

Raise TypeError if an item is not a str.
"""
count = 0
for line in lines:
if not isinstance(line, str):
raise TypeError(f"expected str, got {type(line).__name__}")
if line.strip():
count += 1
return count
# end file
# file: test_counter.py
import unittest

from counter import count_non_empty

class CounterTests(unittest.TestCase):
def test_empty_list_returns_zero(self):
self.assertEqual(count_non_empty([]), 0)

def test_whitespace_only_line_is_ignored(self):
self.assertEqual(count_non_empty([" \t\n"]), 0)

def test_mixed_lines_count_only_non_empty(self):
self.assertEqual(count_non_empty(["alpha\n", " \n", "", "beta"]), 2)

def test_non_string_item_raises_type_error(self):
with self.assertRaises(TypeError):
count_non_empty(["alpha", None])

if __name__ == "__main__":
unittest.main()
# end file
Discovery run from that directory:
$ python -m unittest -v
test_empty_list_returns_zero (test_counter.CounterTests.test_empty_list_returns_zero) ... ok
test_mixed_lines_count_only_non_empty (test_counter.CounterTests.test_mixed_lines_count_only_non_empty) ... ok
test_non_string_item_raises_type_error (test_counter.CounterTests.test_non_string_item_raises_type_error) ... ok
test_whitespace_only_line_is_ignored (test_counter.CounterTests.test_whitespace_only_line_is_ignored) ... ok

----------------------------------------------------------------------
Ran 4 tests in 0.001s

OK
Running the file directly executes only the tests in that file, via unittest.main(); the module shows up as __main__:
$ python test_counter.py -v
test_empty_list_returns_zero (__main__.CounterTests.test_empty_list_returns_zero) ... ok
test_mixed_lines_count_only_non_empty (__main__.CounterTests.test_mixed_lines_count_only_non_empty) ... ok
test_non_string_item_raises_type_error (__main__.CounterTests.test_non_string_item_raises_type_error) ... ok
test_whitespace_only_line_is_ignored (__main__.CounterTests.test_whitespace_only_line_is_ignored) ... ok

----------------------------------------------------------------------
Ran 4 tests in 0.001s

OK
What OK proves: every assertion held for these four inputs on this interpreter, including that None raised TypeError. What it does not prove: that count_non_empty is correct for inputs nobody tested, such as other non-str types or unusual whitespace characters.

Reference implementation:
# file: scores.py
def summarize_scores(path):
"""Return {name: highest score} for rows like "ana,7".

Strict contract: a missing file raises FileNotFoundError and a
malformed score raises ValueError; blank lines are ignored.
"""
best = {}
with open(path, encoding="utf-8") as f:
for lineno, line in enumerate(f, 1):
line = line.strip()
if not line:
continue
name, _, raw = line.rpartition(",")
try:
score = int(raw)
except ValueError:
raise ValueError(f"line {lineno}: invalid score {raw!r}") from None
if name not in best or score > best[name]:
best[name] = score
return best
# end file
With the test_scores.py above in the same directory:
$ python -m unittest -v
test_invalid_score (test_scores.SummarizeTests.test_invalid_score) ... ok
test_missing_file (test_scores.SummarizeTests.test_missing_file) ... ok
test_valid_file (test_scores.SummarizeTests.test_valid_file) ... ok

----------------------------------------------------------------------
Ran 3 tests in 0.002s

OK
Decoy check in the same directory (bash):
$ echo "ana,1" > does-not-exist.txt
$ python -m unittest -v
test_invalid_score (test_scores.SummarizeTests.test_invalid_score) ... ok
test_missing_file (test_scores.SummarizeTests.test_missing_file) ... ok
test_valid_file (test_scores.SummarizeTests.test_valid_file) ... ok

----------------------------------------------------------------------
Ran 3 tests in 0.002s

OK
The same three tests pass: a file in the working directory can neither satisfy nor break test_missing_file. Each expected value is visible in an assertion: {"ana": 8, "bo": 9} (8 beats 7 for ana), FileNotFoundError, and ValueError for the bo,x9 row.

Observed before the fix (excerpt; traceback lines vary):
$ python -m unittest -v
test_three_rows (test_total.TotalTests.test_three_rows) ... FAIL

======================================================================
FAIL: test_three_rows (test_total.TotalTests.test_three_rows)
----------------------------------------------------------------------
Traceback (most recent call last):
...
AssertionError: 20 != 30

----------------------------------------------------------------------
Ran 1 test in 0.001s

FAILED (failures=1)
Diagnosis. Symptom: the total is 20, not 30 — exactly one 10-point row is missing. Evidence: the fixture is written inside the test, so no outside file, working directory or installed package is involved, and the failure is the same under each interpreter you run. Hypothesis: readlines()[1:] discards line 1 as if it were a header, but the fixture's first line is a,10. Classification: code bug; the test's 30 is correct because the documented format has no header row. Minimal fix — one line in total.py, test_total.py unchanged:
# file: total.py
def total_score(path):
"""Return the sum of the scores in rows like "a,10" (no header row)."""
total = 0
with open(path, encoding="utf-8") as f:
lines = f.readlines()
for line in lines:
name, _, raw = line.strip().rpartition(",")
total += int(raw)
return total
# end file
Re-run:
$ python -m unittest -v
test_three_rows (test_total.TotalTests.test_three_rows) ... ok

----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

Reference solution — compare only after your unaided attempt is recorded.
# file: scores.py
import sys

def summarize_scores(path):
"""Return {name: highest score} for rows like "ana,7".

Strict contract: a missing file raises FileNotFoundError and a
malformed score raises ValueError; blank lines are ignored.
"""
best = {}
with open(path, encoding="utf-8") as f:
for lineno, line in enumerate(f, 1):
line = line.strip()
if not line:
continue
name, _, raw = line.rpartition(",")
try:
score = int(raw)
except ValueError:
raise ValueError(f"line {lineno}: invalid score {raw!r}") from None
if name not in best or score > best[name]:
best[name] = score
return best

def main(argv=None):
args = sys.argv[1:] if argv is None else argv
if len(args) != 1:
print("usage: python scores.py SCORES_FILE", file=sys.stderr)
return 2
try:
result = summarize_scores(args[0])
except FileNotFoundError as e:
print(f"error: file not found: {e.filename}", file=sys.stderr)
return 1
except ValueError as e:
print(f"error: {e}", file=sys.stderr)
return 1
print(result)
return 0

if __name__ == "__main__":
sys.exit(main())
# end file
# file: test_scores.py
import tempfile
import unittest
from pathlib import Path

from scores import summarize_scores

class SummarizeTests(unittest.TestCase):
def test_valid_file(self):
with tempfile.TemporaryDirectory() as d:
p = Path(d) / "scores.txt"
p.write_text("ana,7\nbo,9\nana,8\n", encoding="utf-8")
self.assertEqual(summarize_scores(str(p)), {"ana": 8, "bo": 9})

def test_missing_file(self):
with tempfile.TemporaryDirectory() as d:
missing = Path(d) / "does-not-exist.txt"
with self.assertRaises(FileNotFoundError):
summarize_scores(str(missing))

def test_invalid_score(self):
with tempfile.TemporaryDirectory() as d:
p = Path(d) / "scores.txt"
p.write_text("ana,7\nbo,x9\n", encoding="utf-8")
with self.assertRaises(ValueError):
summarize_scores(str(p))
# end file
# file: requirements.txt
# stdlib only, no third-party dependencies
# end file
Run in the directory that holds only these three files:
$ python -m unittest -v
test_invalid_score (test_scores.SummarizeTests.test_invalid_score) ... ok
test_missing_file (test_scores.SummarizeTests.test_missing_file) ... ok
test_valid_file (test_scores.SummarizeTests.test_valid_file) ... ok

----------------------------------------------------------------------
Ran 3 tests in 0.002s

OK
Then the command line (bash; the extra fixture files are created after the test run):
$ printf 'ana,7\nbo,9\nana,8\n' > s1.txt
$ python scores.py s1.txt; echo "exit $?"
{'ana': 8, 'bo': 9}
exit 0
$ python scores.py nope.txt; echo "exit $?"
error: file not found: nope.txt
exit 1
$ printf 'ana,7\nbo,x9\n' > s2.txt
$ python scores.py s2.txt; echo "exit $?"
error: line 2: invalid score 'x9'
exit 1
Record the interpreter with python -c "import sys; print(sys.executable, sys.version)". Recovery plan: Ran 0 tests → check the test_*.py name and the discovery directory (day-12-act-01); ModuleNotFoundError → check the interpreter and working directory (day-11); FileNotFoundError → check the path (day-10); a failing assertion → diagnose before editing (day-12-act-03).