Mock basique

Tu testes un systeme de commande qui envoie un email de confirmation apres l'achat. Tu ne vas pas envoyer un vrai email a chaque test (tes clients recevraient des dizaines de spams par jour). C'est la qu'intervient le mock : un faux objet qui remplace le vrai.

Pense a un cascadeur au cinema. De l'exterieur, ca a l'air identique, mais c'est beaucoup plus sur et controlable. En testing, le mock te permet de verifier que ton code APPELLE bien la bonne fonction, avec les bons arguments, sans declencher d'effets reels.

En Python pur, le mock le plus simple est une fonction qui remplace une autre. Au lieu d'appeler la vraie fonction qui envoie un email, on appelle une fausse fonction qui enregistre juste qu'elle a ete appelee :

appels = []

def faux_envoi_email(destinataire, sujet):
appels.append({"destinataire": destinataire, "sujet": sujet})

Apres avoir exécute le code, on peut vérifier que la fonction a ete appelee avec les bons arguments en inspectant la liste appels.

Écris une classe MockFunction qui simule une fonction. Elle doit :

__init__() : initialise une liste d'appels vide et une valeur de retour (None par défaut).

set_return(value) : definit la valeur que le mock renverra quand il sera appele.

__call__(*args, **kwargs) : enregistre l'appel (les args et kwargs dans un dict) dans la liste d'appels, et renvoie la valeur de retour definie.

call_count() : renvoie le nombre de fois que le mock a ete appele.

was_called_with(*args, **kwargs) : renvoie True si le mock a ete appele au moins une fois avec exactement ces arguments.

reset() : vide la liste d'appels.

Exemple :

mock = MockFunction()
mock.set_return(42)
résultat = mock(1, 2, cle="valeur")
résultat vaut 42
mock.call_count() renvoie 1
mock.was_called_with(1, 2, cle="valeur") renvoie True
mock.was_called_with(3, 4) renvoie False

Tests (4/5)

Valeur de retour

m = MockFunction()
m.set_return(42)
assert m() == 42, 'Le mock devrait renvoyer 42'

Compteur d appels

m = MockFunction()
m()
m()
m()
assert m.call_count() == 3, f'Le mock a ete appele 3 fois mais call_count renvoie {m.call_count()}'

Vérification des arguments

m = MockFunction()
m(1, 2, cle='valeur')
assert m.was_called_with(1, 2, cle='valeur'), 'Le mock devrait avoir ete appele avec ces arguments'
assert not m.was_called_with(3, 4), 'Le mock n a pas ete appele avec 3, 4'

Reset

m = MockFunction()
m()
m()
m.reset()
assert m.call_count() == 0, 'Apres reset, call_count devrait etre 0'

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

class MockFunction:

    def __init__(self):
        self.appels = []
        self.valeur_retour = None

    def set_return(self, value):
        self.valeur_retour = value

    def __call__(self, *args, **kwargs):
        self.appels.append({"args": args, "kwargs": kwargs})
        return self.valeur_retour

    def call_count(self):
        return len(self.appels)

    def was_called_with(self, *args, **kwargs):
        for appel in self.appels:
            if appel["args"] == args and appel["kwargs"] == kwargs:
                return True
        return False

    def reset(self):
        self.appels = []

← Tester une classe complete Test parametrise →

solution.py

Bravo!

Mock basique

Tests (4/5)

Indices (3 disponibles)

Solution officielle