Verkettete Exceptions

class PriceError(Exception):
    pass


def parse_price(text: str) -> float:
    try:
        value = float(text)
    except ValueError:
        raise PriceError(f"bad price: {text!r}")
    if value < 0:
        raise PriceError(f"negative price: {value}")
    return value

from main import PriceError, parse_price


def test_valid():
    """Ein gültiger Preis kommt als float zurück"""
    got = parse_price("2.50")
    assert got == 2.5, f"parse_price('2.50') lieferte {got!r}"


def test_bad_price_message():
    """Text, der keine Zahl ist, löst PriceError mit klarer Meldung aus"""
    try:
        parse_price("two")
    except PriceError as err:
        assert str(err) == "bad price: 'two'", f"die Meldung war {str(err)!r}"
    else:
        assert False, "parse_price('two') kehrte normal zurück"


def test_bad_price_cause():
    """Der ValueError ist die direkte Ursache"""
    try:
        parse_price("two")
    except PriceError as err:
        assert isinstance(err.__cause__, ValueError), f"__cause__ ist {err.__cause__!r}; verwenden Sie raise ... from err"


def test_negative():
    """Ein negativer Preis löst PriceError ohne Ursache aus"""
    try:
        parse_price("-1")
    except PriceError as err:
        assert str(err) == "negative price: -1.0", f"die Meldung war {str(err)!r}"
        assert err.__cause__ is None, f"__cause__ ist {err.__cause__!r}, erwartet: None"
    else:
        assert False, "parse_price('-1') kehrte normal zurück"

class SettingError(Exception):
    pass


def get_setting(settings: dict[str, str], key: str) -> str:
    return settings[key]


def get_int_setting(settings: dict[str, str], key: str) -> int:
    return int(get_setting(settings, key))

from main import SettingError, get_int_setting, get_setting

SETTINGS = {"port": "8080", "host": "example.org"}


def catch(f, key):
    try:
        f(SETTINGS, key)
    except SettingError as err:
        return err
    assert False, f"{f.__name__}(settings, {key!r}) kehrte normal zurück"


def test_values():
    """Vorhandene Einstellungen kommen zurück"""
    got = get_setting(SETTINGS, "host"), get_int_setting(SETTINGS, "port")
    assert got == ("example.org", 8080), f"Ergebnis: {got!r}"


def test_unknown_hidden():
    """Ein unbekannter Schlüssel löst SettingError from None aus"""
    err = catch(get_setting, "user")
    assert str(err) == "unknown setting: 'user'", f"die Meldung war {str(err)!r}"
    assert err.__cause__ is None and err.__suppress_context__, "der KeyError sollte mit from None ausgeblendet werden"
    assert isinstance(err.__context__, KeyError), f"__context__ ist {err.__context__!r}, erwartet: der KeyError"


def test_not_a_number_chained():
    """Eine Einstellung, die keine Zahl ist, wird an den ValueError gekettet"""
    err = catch(get_int_setting, "host")
    assert str(err) == "setting 'host' is not a whole number", f"die Meldung war {str(err)!r}"
    assert isinstance(err.__cause__, ValueError), f"__cause__ ist {err.__cause__!r}; verwenden Sie raise ... from err"


def test_unknown_int():
    """get_int_setting meldet einen unbekannten Schlüssel genauso"""
    err = catch(get_int_setting, "user")
    assert str(err) == "unknown setting: 'user'", f"die Meldung war {str(err)!r}"