Exception-Gruppen und Notizen

def parse_all(texts: list[str]) -> list[int]:
    return [int(text) for text in texts]

from main import parse_all


def test_all_good():
    """Gute Texte kommen als ints zurück"""
    got = parse_all(["1", "22", "-3"])
    assert got == [1, 22, -3], f"parse_all lieferte {got!r}"


def catch(texts):
    try:
        parse_all(texts)
    except ExceptionGroup as eg:
        return eg
    except ValueError:
        assert False, "parse_all brach beim ersten ValueError ab; sammeln Sie sie in einer ExceptionGroup"
    assert False, "parse_all kehrte bei schlechter Eingabe normal zurück"


def test_group():
    """Zwei schlechte Texte ergeben eine Gruppe mit beiden Fehlern"""
    eg = catch(["1", "x", "3", "y"])
    assert eg.message == "some items are not numbers", f"die Meldung der Gruppe ist {eg.message!r}"
    assert len(eg.exceptions) == 2, f"die Gruppe enthält {len(eg.exceptions)} Exceptions, erwartet: 2"
    assert all(isinstance(e, ValueError) for e in eg.exceptions), "jede Exception in der Gruppe sollte ein ValueError sein"


def test_notes():
    """Jeder Fehler hat eine Notiz mit seiner Position"""
    eg = catch(["1", "x", "3", "y"])
    notes = [getattr(e, "__notes__", []) for e in eg.exceptions]
    assert notes == [["item 2"], ["item 4"]], f"die Notizen sind {notes!r}"

def check(record: dict[str, str]) -> None:
    if "email" not in record:
        raise KeyError("email")
    if not record["age"].isdigit():
        raise ValueError(f"age must be a number, got {record['age']!r}")


def check_all(records: list[dict[str, str]]) -> None:
    errors: list[Exception] = []
    for number, record in enumerate(records, start=1):
        try:
            check(record)
        except (ValueError, KeyError) as err:
            err.add_note(f"in record {number}")
            errors.append(err)
    if errors:
        raise ExceptionGroup(f"{len(errors)} records failed", errors)


def summarize(records: list[dict[str, str]]) -> list[str]:
    check_all(records)
    return ["all valid"]

from main import summarize


def test_all_valid():
    """Gültige Datensätze ergeben all valid"""
    got = summarize([{"age": "34", "email": "ada@example.org"}])
    assert got == ["all valid"], f"summarize lieferte {got!r}"


def test_both_kinds():
    """Erst die falschen Werte, dann die fehlenden Felder, jeweils mit Notiz"""
    records = [{"age": "x", "email": "a@b"}, {"age": "3"}, {"age": "-3", "email": "c@d"}]
    got = summarize(records)
    want = [
        "bad value: age must be a number, got 'x' (in record 1)",
        "bad value: age must be a number, got '-3' (in record 3)",
        "missing field: 'email' (in record 2)",
    ]
    assert got == want, f"summarize lieferte {got!r}"


def test_only_missing():
    """Auch eine Gruppe nur aus KeyErrors wird behandelt"""
    got = summarize([{"age": "1"}, {"age": "2"}])
    assert got == ["missing field: 'email' (in record 1)", "missing field: 'email' (in record 2)"], f"summarize lieferte {got!r}"


def test_other_errors_pass():
    """Andere Fehler werden nicht gefangen"""
    try:
        summarize([{"age": 5, "email": "a@b"}])  # type: ignore[dict-item]
    except AttributeError:
        pass
    else:
        assert False, "summarize hat einen AttributeError verschluckt"