Python Mock - Comment obtenir le retour d'un MagicMock comme si c'était une méthode normale

Par exemple:

import mock

class MyClass(object):
    def foo(self, x, y, z):
        return (x, y, z)


class TestMyClass(TestCase)
    @mock.patch('MyClass')
    def TestMyClass(self, MyClassMock):
        foo_mock = MyClassMock.foo()

        self.assertEquals((x, y, z), foo_mock)

Donc, la vraie question est: Comment obtenir le retour de l'essai intead de l'obtention de ce <MagicMock name='MyClass.foo()' id='191728464'> ou comment faire face à cette MagicMock objet pour obtenir le retour de ce test qui devrait être un tuple contenant 3 éléments et rien de plus ou de moins?

Toute suggestion, toute idée, tout argument sera la bienvenue.
Merci à l'avance!

Êtes-vous en train de tester, si MyClass.foo() fonctionne correctement? Parce qu'alors vous devriez pas s'en moquer.
Pas de. L'idée ici, dans cette question, est de savoir comment obtenir le retour de l'essai au lieu d'un MagicMock objet, parce que je voudrais appliquer cette différence dans les scénarios. Il y a des tests que j'ai besoin exactement les valeurs en retour, pas un MagicMock objet.
J'ai construit un exemple ci-dessous, qui ne se moque de quelque chose d'autre, mais ne définissez la valeur de retour.
Si vous avez vraiment le but de se moquer de MyClass.foo(), votre exemple est trop verbeux (et incorrect, il n'y a pas de self sur def TestMyClass()). Vous appelez la maquette directement, en tout cas, et l'original MyClass.foo() est jamais appelé comme il a été remplacé par la fantaisie.
Il n'y a pas besoin de faire explicitement appel à une classe, ni même de l'instanciation. La maquette de la bibliothèque, tout comme par magie. En quelque sorte, à la suite de mon code d'exemple ci-dessus, après l'exécution du test, le foo_mock sera connu seulement comme <MagicMock name='MyClass.foo()' id='191728464'>.

OriginalL'auteur Nice Guy | 2014-02-06

  1. 5

    Si vous essayez de tester si MyClass.foo() fonctionne correctement, vous devez pas s'en moquer.

    Moqueur est utilisé pour quoi que ce soit à l'extérieur le code à l'essai; si foo appelé un autre, externe fonction some_module.bar(), alors vous feriez maquette some_module.bar() et de lui donner une mise en valeur de retour:

    import some_module

class MyClass(object):
    def foo(self, x, y, z):
        result = some_module.bar(x, y, z)
        return result[0] + 2, result[1] * 2, result[2] - 2

class TestMyClass(TestCase):
    @mock.patch('some_module.bar')
    def test_myclass(self, mocked_bar):
        mocked_bar.return_value = (10, 20, 30)

        mc = MyClass()

        # calling MyClass.foo returns a result based on bar()
        self.assertEquals(mc.foo('spam', 'ham', 'eggs'),
            (12, 40, 28))
        # some_class.bar() was called with the original arguments
        mocked_bar.assert_called_with('spam', 'ham', 'eggs')

    Ici, je mis mocked_bar.return_value à ce qui devrait être renvoyée lorsque le se moquaient de some_module.bar() fonction est appelée. Lorsque le code-sous-essai fait des appels bar(), la maquette renvoie cette valeur.

    Lorsque vous n'avez pas défini une return_value un nouveau MagicMock() objet est retourné au lieu de cela, l'un qui va soutenir davantage d'appels, et vous pouvez tester ces appels exactement comme sur la mocked_bar objet, etc.

    Je vais essayer quelque chose de basé sur vos réponses. Volontaire, je vais vous donner des rétroactions de ce qui se passe. Merci!
    Ce qui est testé ici? Vous avez un simulacre de méthode qui vous savez de quoi il en retourne. MyClass.foo() est aussi tout à some_module.bar(). Oui, dans quelles circonstances, ce peut échouer? Vous faites des tests ?
    il y MyClass.foo méthode est l'unité testée. Ce test échoue, si une mauvaise opération a été réalisée dans MyClass.foo méthode, par exemple, plus opération a été missplaced avec multiplication, etc.

    OriginalL'auteur Martijn Pieters