Test doubles with 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():
    """A working fetch is called once and its result returned"""
    fetch = Mock(return_value="page")
    got = fetch_with_retry(fetch, "u")
    assert got == "page", f"returned {got!r}, expected 'page'"
    assert fetch.call_count == 1, f"fetch was called {fetch.call_count} times, expected 1"
    fetch.assert_called_once_with("u")


def test_retry_succeeds():
    """One ConnectionError, then success: two calls"""
    fetch = Mock(side_effect=[ConnectionError("down"), "page"])
    got = fetch_with_retry(fetch, "u")
    assert got == "page", f"returned {got!r}, expected 'page'"
    assert fetch.call_count == 2, f"fetch was called {fetch.call_count} times, expected 2"


def test_offline():
    """Two ConnectionErrors give "offline", and no third try"""
    fetch = Mock(side_effect=ConnectionError("down"))
    got = fetch_with_retry(fetch, "u")
    assert got == "offline", f"returned {got!r}, expected 'offline'"
    assert fetch.call_count == 2, f"fetch was called {fetch.call_count} times, expected 2"


def test_other_errors_pass():
    """Other exceptions are not caught or retried"""
    fetch = Mock(side_effect=ValueError("bad url"))
    try:
        fetch_with_retry(fetch, "u")
    except ValueError:
        pass
    else:
        assert False, "a ValueError from fetch was swallowed; catch only ConnectionError"
    assert fetch.call_count == 1, f"fetch was called {fetch.call_count} times after a ValueError, expected 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():
    """Your tests pass on the real greet"""
    result = run_against(greeting.greet)
    problems = [trace.strip().splitlines()[-1] for _, trace in result.failures + result.errors]
    assert result.wasSuccessful(), f"your tests fail on correct code: {problems}"
    assert result.testsRun >= 2, f"{result.testsRun} tests ran; write at least 2"


def test_catches_ignored_name():
    """Your tests catch a greet that ignores the user's name"""
    result = run_against(ignores_name)
    assert not result.wasSuccessful(), "every test passes when greet always says 'Hello, user!'"


def test_catches_missing_guest():
    """Your tests catch a greet that crashes for an unknown user"""
    result = run_against(no_guest)
    assert not result.wasSuccessful(), "every test passes when greet lets the KeyError escape; test an unknown user"


def test_catches_wrong_id():
    """Your tests check the id that lookup was called with"""
    result = run_against(wrong_id)
    assert not result.wasSuccessful(), "every test passes when greet looks up the wrong id; use 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")