Python Academy · Leçon

Simulation avec unittest.mock

Isolez les unités testées en simulant leurs dépendances.

Simulation avec unittest.mock est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Pourquoi utiliser des mocks ?

Les mocks remplacent les dépendances réelles (bases de données, API, système de fichiers) par des simulacres contrôlables afin que les tests s’exécutent rapidement, de manière déterministe et isolée.

from unittest.mock import Mock

api = Mock()
api.get_user.return_value = {"id": 1, "name": "Alice"}

result = api.get_user(1)
print(result)  # {'id': 1, 'name': 'Alice'}

Mock et MagicMock

Mock est la classe de base. MagicMock configure automatiquement les méthodes magiques (ou dunder), ce qui permet de l’utiliser comme itérateur, gestionnaire de contexte, etc.

from unittest.mock import MagicMock

m = MagicMock()
m.__len__.return_value = 5
print(len(m))  # 5

m.__iter__.return_value = iter([1, 2, 3])
for x in m:
    print(x)

patch comme décorateur

Utilisez @patch pour remplacer un objet dans un module par un mock pendant la durée du test.

from unittest.mock import patch

def get_data():
    import requests
    return requests.get("https://api.example.com").json()

@patch("requests.get")
def test_get_data(mock_get):
    mock_get.return_value.json.return_value = {"key": "value"}
    result = get_data()
    assert result == {"key": "value"}

patch comme gestionnaire de contexte

Utilisez patch() comme gestionnaire de contexte pour limiter davantage la portée de la simulation.

from unittest.mock import patch

def test_open():
    with patch("builtins.open", create=True) as mock_open:
        mock_open.return_value.__enter__.return_value.read.return_value = "data"
        with open("file.txt") as f:
            assert f.read() == "data"

patch.object

patch.object(target, attribute) modifie temporairement un attribut précis d’un objet ou d’une classe existante.

from unittest.mock import patch
import mymodule

def test_method():
    with patch.object(mymodule.MyClass, "fetch", return_value=42):
        obj = mymodule.MyClass()
        assert obj.fetch() == 42

Vérifier les appels

Les mocks enregistrent chaque appel. Utilisez assert_called_once_with, assert_called_with et call_count pour vérifier le comportement.

from unittest.mock import Mock

send = Mock()
send("hello", to="alice")

send.assert_called_once_with("hello", to="alice")
print(send.call_count)  # 1

return_value et side_effect

Définissez return_value pour contrôler ce que le mock renvoie. Utilisez side_effect pour lever des exceptions ou renvoyer des valeurs différentes lors d’appels successifs.

from unittest.mock import Mock

m = Mock(side_effect=[1, 2, ValueError("done")])
print(m())  # 1
print(m())  # 2
m()         # raises ValueError

spec : mocks compatibles avec les types

Transmettez spec=MyClass pour limiter le mock aux seuls attributs qui existent dans la classe réelle.

from unittest.mock import Mock

class Calc:
    def add(self, a, b): return a + b

m = Mock(spec=Calc)
m.add(1, 2)         # OK
# m.subtract(1, 2)  # AttributeError: Mock does not have 'subtract'

patch.dict

Utilisez patch.dict pour modifier temporairement un dictionnaire, par exemple des variables d’environnement ou des configurations au niveau du module.

from unittest.mock import patch
import os

def test_env():
    with patch.dict(os.environ, {"DEBUG": "true"}):
        assert os.environ["DEBUG"] == "true"
    assert "DEBUG" not in os.environ

Utiliser des mocks dans pytest avec pytest-mock

pytest-mock fournit une fixture mocker qui encapsule unittest.mock et effectue automatiquement le nettoyage après chaque test.

# pip install pytest-mock

def test_service(mocker):
    mocker.patch("mymodule.requests.get", return_value=mocker.Mock(
        json=lambda: {"status": "ok"}
    ))
    from mymodule import call_api
    assert call_api()["status"] == "ok"

AsyncMock pour les coroutines

Utilisez AsyncMock pour simuler les fonctions asynchrones attendues avec await.

from unittest.mock import AsyncMock, patch
import asyncio

async def fetch():
    import httpx
    async with httpx.AsyncClient() as c:
        r = await c.get("https://example.com")
        return r.json()

def test_fetch():
    with patch("httpx.AsyncClient.get", new_callable=AsyncMock) as m:
        m.return_value.json.return_value = {"ok": True}
        result = asyncio.run(fetch())
        assert result["ok"] is True

Vérification rapide

Quel attribut définissez-vous sur un Mock pour contrôler la valeur qu’il renvoie lorsqu’il est appelé ?

Récapitulatif

unittest.mock fournit Mock, MagicMock, patch et AsyncMock. Utilisez return_value et side_effect pour contrôler le comportement, ainsi que les méthodes d’assertion pour vérifier comment les mocks ont été appelés.

Questions Fréquemment Posées

La leçon « Simulation avec unittest.mock » est-elle gratuite ?

Oui — le texte complet de « Simulation avec unittest.mock » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Simulation avec unittest.mock » ?

Isolez les unités testées en simulant leurs dépendances. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Simulation avec unittest.mock » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Python Academy