Comment tester si la méthode de l'instance est appelée avec "self" en se moquant?

Question

J'utilise unittest.mock, cette merveilleuse bibliothèque. Cependant, j'ai été surpris par un comportement inattendu, et je ne vois pas une solution évidente. Je l'utilise pour mes tests unitaires et il est essentiel de comprendre parfaitement comment il se comporte pour avoir des tests utiles.

Je sais que le code ci-dessous dans show_bar est cassé, il appelle un classmethod au lieu de la méthode d'instance. Cependant, tous mes mockunittests passent:

code contenant un bug:

class Foo(object): 
    def bar(self): 
     return "bar" 

    def show_bar(self): 
     return Foo.bar() 

utilisation prévue:

foo = Foo() 
assert foo.show_bar() == "bar" 
# => throw exception: bar() missing 1 required positional argument: 'self' 

UnitTest tente en vain de rattraper cette erreur avec mock:

from unittest.mock import patch 
with patch.object(Foo, 'bar', return_value="bar") as mock: 
    foo = Foo() 
    assert foo.show_bar() == "bar" 
mock.assert_called_once() 
# => no errors 

Idéalement, je voudrais affirmer que bar est appelée avec self.bar() et NON Foo.bar(); ce qui est faux. Malheureusement, en utilisant mock.assert_called_with() ne prend pas en compte le paramètre self ni cls, donc je suis un peu confus.

EDIT: Essayer de clarifier. Je suis à la recherche de bonnes pratiques pour utiliser la bibliothèque unittest.mock lorsque nous avons besoin de patcher la méthode d'un objet. Il ne semble pas clair pour moi comment le patcher, actuellement je n'ai aucun moyen d'affirmer si elle appelle self.bar ou Foo.bar.

Answer 1

Je ne comprends pas vraiment pourquoi vous auriez besoin de se moquer de la méthode pour tester qu'elle ne déclenche pas une erreur TypeError lorsqu'elle est appelée, mais de toute façon ... Quelqu'un d'autre pourrait expliquer comment résoudre cela en utilisant unittest.mock peut sauter juste unittest.mock et Foo.bar maquette par vous-même:

callargs = dict() 
def mock_bar(self): 
    callargs["self"] = self 
    return "bar" 

foobar = Foo.__dict__["bar"] 
Foo.bar = mock_bar 
try: 
    foo = Foo() 
    assert foo.show_bar() == "bar" 
    assert "self" in callargs 
    assert callargs["self"] is foo 
finally: 
    Foo.bar = foobar