Comment simuler une fonction définie dans un module d'un paquet?

J'ai une structure suivante:

|-- dirBar
|   |-- __init__.py
|   |-- bar.py
|-- foo.py
`-- test.py

bar.py

def returnBar():
    return 'Bar'

foo.py

from dirBar.bar import returnBar

def printFoo():
    print returnBar()

test.py

from mock import Mock

from foo import printFoo
from dirBar import bar

bar.returnBar = Mock(return_value='Foo')

printFoo()

le résultat de python test.py est Bar.

La façon de se moquer de l' printBar pour le faire revenir Foo de sorte que printFoo va l'imprimer?

EDIT: Sans modifier les autres fichiers test.py

InformationsquelleAutor zalun | 2011-12-20
  1. 37

    Je devine que vous allez vous moquer de la fonction returnBar, vous souhaitez utiliser patch décorateur:

    from mock import patch

from foo import printFoo

@patch('foo.returnBar')
def test_printFoo(mockBar):
    mockBar.return_value = 'Foo'
    printFoo()

test_printFoo()
    • La pièce manquante est que vous patch de la fonction à l'endroit où il est importé pour, pas l'endroit où elle est importée depuis. Après l'importation comme from dirBar.bar import returnBar dans foo.py, les moqueries des besoins de patch à l'importation comme foo.returnBar, pas comme dirBar.bar.returnBar.
    • principe de base est que vous patch où un objet est recherché, ce qui n'est pas nécessairement l'endroit même où il est défini. Un couple d'exemples qui vous aideront à clarifier cela. voidspace.org.royaume-uni/python/maquette/patch.html#id1
    InformationsquelleAutor number5
  2. 28

    Il suffit d'importer le bar module avant de le foo module et de s'en moquer:

    from mock import Mock

from dirBar import bar
bar.returnBar = Mock(return_value='Foo')

from foo import printFoo

printFoo()

    Lorsque vous importez les returnBar dans foo.py, vous êtes liant la valeur du module à une variable appelée returnBar. Cette variable est locale est donc mis à la fermeture de la printFoo() fonction lorsque foo est importé et les valeurs de la fermeture ne peut pas être mis à jour par le code de outiside il. Donc, il doit avoir la nouvelle valeur (qui est, les moqueries de la fonction) avant l'importation de foo.

    MODIFIER: la solution précédente workis mais n'est pas robuste car elle dépend de la commande à l'importation. Qui n'est pas très idéal. Une autre solution (qui m'a eu lieu après la première) est d'importer le bar module dans foo.py au lieu d'importer uniquement les returnBar() fonction:

    from dirBar import bar

def printFoo():
    print bar.returnBar()

    Cela fonctionne parce que le returnBar() est maintenant récupérées directement à partir de la bar module à la place de la fermeture. Donc, si je mettre à jour le module, la nouvelle fonction sera récupéré.

    • Oui, le problème était que j'avais le code tel qu'il est et de l'idn pas envie de les changer. Après une discussion sur freenode#python, j'ai décidé de revoir l'autre fichier (ici foo.py) de sorte qu'il sera mieux et plus propre
    • il existe un lien de cette discussion? Je suis curieux à propos de ça!
    InformationsquelleAutor brandizzi
  3. -3

    Une autre façon de traiter ces cas est d'utiliser une injection de dépendance.

    Un moyen facile de le faire en python est d'utiliser la magie **kwargs :

    foo.py

    from dirBar.bar import returnBar

def printFoo(**kwargs):
    real_returnBar = kwargs.get("returnBar", returnBar)
    print real_returnBar()

    test.py

    from mock import Mock

from foo import printFoo
from dirBar import bar

mocked_returnBar = Mock(return_value='Foo')

printFoo(returnBar=mocked_returnBar)

    cela va conduire à un code de tests (et d'augmenter la modularité/réutilisabilité).

    • l'idée est de ne rien modifier à l'exception de test.py
    InformationsquelleAutor Cédric Julien