Testdoubles mit unittest.mock

from collections.abc import Callable
from unittest.mock import Mock


def fetch_with_retry(fetch: Callable[[str], str], url: str) -> str:
    # Call fetch(url). If it raises ConnectionError, try exactly once more.
    # If the second try fails too, return "offline".
    return fetch(url)


if __name__ == "__main__":
    flaky = Mock(side_effect=[ConnectionError("down"), "<html>hello</html>"])
    print(fetch_with_retry(flaky, "https://example.com"))
    print("calls:", flaky.call_count)

from unittest.mock import Mock

from main import fetch_with_retry


def test_first_try():
    """Ein funktionierendes fetch wird einmal aufgerufen und sein Ergebnis geliefert"""
    fetch = Mock(return_value="page")
    got = fetch_with_retry(fetch, "u")
    assert got == "page", f"lieferte {got!r}, erwartet 'page'"
    assert fetch.call_count == 1, f"fetch wurde {fetch.call_count}-mal aufgerufen, erwartet 1"
    fetch.assert_called_once_with("u")


def test_retry_succeeds():
    """Ein ConnectionError, dann Erfolg: zwei Aufrufe"""
    fetch = Mock(side_effect=[ConnectionError("down"), "page"])
    got = fetch_with_retry(fetch, "u")
    assert got == "page", f"lieferte {got!r}, erwartet 'page'"
    assert fetch.call_count == 2, f"fetch wurde {fetch.call_count}-mal aufgerufen, erwartet 2"


def test_offline():
    """Zwei ConnectionErrors ergeben "offline", ohne dritten Versuch"""
    fetch = Mock(side_effect=ConnectionError("down"))
    got = fetch_with_retry(fetch, "u")
    assert got == "offline", f"lieferte {got!r}, erwartet 'offline'"
    assert fetch.call_count == 2, f"fetch wurde {fetch.call_count}-mal aufgerufen, erwartet 2"


def test_other_errors_pass():
    """Andere Ausnahmen werden weder gefangen noch wiederholt"""
    fetch = Mock(side_effect=ValueError("bad url"))
    try:
        fetch_with_retry(fetch, "u")
    except ValueError:
        pass
    else:
        assert False, "ein ValueError von fetch wurde verschluckt; fangen Sie nur ConnectionError"
    assert fetch.call_count == 1, f"fetch wurde nach einem ValueError {fetch.call_count}-mal aufgerufen, erwartet 1"

import unittest
from unittest.mock import patch

import greeting


class TestGreet(unittest.TestCase):
    def test_known_user(self) -> None:
        # 1. This patches the wrong name: greeting.py has its own "lookup".
        with patch("users.lookup", return_value={"name": "Ada"}) as fake:
            self.assertEqual(greeting.greet(7), "Hello, Ada!")
        # 2. Check that lookup was called exactly once, with 7.

    # 3. Add test_unknown_user: lookup raises KeyError, greet says "Hello, guest!".


if __name__ == "__main__":
    suite = unittest.TestLoader().loadTestsFromTestCase(TestGreet)
    unittest.TextTestRunner(verbosity=2).run(suite)

import unittest

import greeting
import main


def run_against(implementation):
    saved = greeting.greet
    greeting.greet = implementation
    try:
        result = unittest.TestResult()
        unittest.TestLoader().loadTestsFromTestCase(main.TestGreet).run(result)
    finally:
        greeting.greet = saved
    return result


def ignores_name(user_id):
    greeting.lookup(user_id)
    return "Hello, user!"


def no_guest(user_id):
    user = greeting.lookup(user_id)
    return f"Hello, {user['name']}!"


def wrong_id(user_id):
    try:
        user = greeting.lookup(user_id + 1)
    except KeyError:
        return "Hello, guest!"
    return f"Hello, {user['name']}!"


def test_correct_code_passes():
    """Ihre Tests bestehen mit dem echten greet"""
    result = run_against(greeting.greet)
    problems = [trace.strip().splitlines()[-1] for _, trace in result.failures + result.errors]
    assert result.wasSuccessful(), f"Ihre Tests scheitern an korrektem Code: {problems}"
    assert result.testsRun >= 2, f"{result.testsRun} Tests liefen; schreiben Sie mindestens 2"


def test_catches_ignored_name():
    """Ihre Tests erkennen ein greet, das den Namen des Benutzers übergeht"""
    result = run_against(ignores_name)
    assert not result.wasSuccessful(), "alle Tests bestehen, obwohl greet immer 'Hello, user!' sagt"


def test_catches_missing_guest():
    """Ihre Tests erkennen ein greet, das bei unbekannten Benutzern abstürzt"""
    result = run_against(no_guest)
    assert not result.wasSuccessful(), "alle Tests bestehen, obwohl greet den KeyError durchlässt; testen Sie einen unbekannten Benutzer"


def test_catches_wrong_id():
    """Ihre Tests prüfen die id, mit der lookup aufgerufen wurde"""
    result = run_against(wrong_id)
    assert not result.wasSuccessful(), "alle Tests bestehen, obwohl greet die falsche id nachschlägt; nutzen Sie assert_called_once_with(7)"

from users import lookup


def greet(user_id: int) -> str:
    try:
        user = lookup(user_id)
    except KeyError:
        return "Hello, guest!"
    return f"Hello, {user['name']}!"

def lookup(user_id: int) -> dict[str, str]:
    """Would read the user from a database."""
    raise RuntimeError("the user database is not available in tests")