Se moquant d'une méthode de classe et de changer certains des attributs d'un objet en Python

Des excuses par avance si je ne comprends pas ce que vous essayez de faire, mais je pense que cela peut fonctionner:

import unittest
from unittest.mock import patch

class MyClass:

    def __init__(self):
        self.x = 0
        self.y = 0

    def some_method(self):   
        self.x = 4   
        self.y = 6    

class OtherClass:

    def other_method(self):
        self.x = 5
        self.y = 16

class MyTestClass(unittest.TestCase):

    @patch('__main__.MyClass.some_method', new=OtherClass.other_method)
    def test_patched(self):
        a = MyClass()
        a.some_method()
        self.assertEqual(a.x, 5)
        self.assertEqual(a.y, 16)

    def test_not_patched(self):
        a = MyClass()
        a.some_method()
        self.assertEqual(a.x, 4)
        self.assertEqual(a.y, 6)

if __name__ == "__main__":
    unittest.main()

Cela remplace some_method() avec other_method() lors de la mise à jour, qui définit les différentes valeurs pour les attributs x, y, et lorsque le test est exécuté, il donne les résultats:

..
----------------------------------------------------------------------
Ran 2 tests in 0.020s

OK

EDIT: pour répondre à la question sur la façon de faire à l'intérieur de la fonction de test sans se moquant d'une classe...

def test_inside_patch(self):
    def othermethod(self):
        self.x = 5
        self.y = 16
    patcher = patch('__main__.MyClass.some_method', new=othermethod)
    patcher.start()
    a = MyClass()
    a.some_method()
    self.assertEqual(a.x, 5)
    self.assertEqual(a.y, 16) 
    patcher.stop()

Assurez-vous d'appeler la méthode start() et stop() sur le patcher sinon, vous pouvez vous retrouver dans une situation où le patch est active et que vous ne voulez pas qu'il soit. Notez que pour définir la maquette de la fonction à l'intérieur de la test code de la fonction, je n'ai pas utilisé le patch en tant que décorateur, parce que la simulation de la fonction doit être définie avant d'utiliser le "nouveau" mot-clé dans le patch. Si vous souhaitez utiliser le patch comme un décorateur, vous devez définir la maquette de la fonction de quelque part avant le patch, en le définissant à l'intérieur de MyTestClass fonctionne aussi, mais il semble que vous voulez vraiment avoir la fantaisie de la fonction définie à l'intérieur de votre test de code de la fonction.

EDIT: ajout du résumé de 4 façons je vois pour ce faire...

# first way uses a class outside MyTest class
class OtherClass:
    def other_method(self):
        ...

class MyTest(unittest.TestCase):

    @patch('path_to_MyClass.some_method', new=OtherClass.other_method)
    def test_1(self)
        ...

    # 2nd way uses class defined inside test class    
    class MyOtherClass:
        def other_method(self):
            ...
    @patch('path_to_MyClass.some_method', new=MyOtherClass.other_method)    
    def test_2(self):
        ...

    # 3rd way uses function defined inside test class but before patch decorator 
    def another_method(self):
        ...
    @patch('path_to_MyClass.some_method', new=another_method)    
    def test_3(self):
        ...

    # 4th way uses function defined inside test function but without a decorator
    def test_4(self):
        def yet_another_method(self):
            ...
        patcher = patch('path_to_MyClass.some_method', new=yet_another_method)
        patcher.start()
        ...
        patcher.stop()

Aucun de ces utilise un side_effect, mais ils ont tous de résoudre le problème de se moquer d'une méthode de classe et de changer certains attributs. Celui que vous choisissez dépend de l'application.

OriginalL'auteur Steve Misuta