Puis-je patch un Python décorateur avant qu'il s'enveloppe d'une fonction?

Il convient de noter que plusieurs des réponses ici patche le décorateur pour l'ensemble de la session de test plutôt que d'une seule instance de test; ce qui peut être indésirable. Voici comment patcher un décorateur qui persiste uniquement par le biais d'un seul test.

De notre unité à être testé avec les indésirables décorateur:

# app/uut.py

from app.decorators import func_decor

@func_decor
def unit_to_be_tested():
    # Do stuff
    pass

De décorateurs module:

# app/decorators.py

def func_decor(func):
    def inner(*args, **kwargs):
        print "Do stuff we don't want in our test"
        return func(*args, **kwargs)
    return inner

Par le temps, notre test est recueillie au cours d'une série de tests, les indésirables décorateur a déjà été appliquée à notre unité sous test (parce que ce qui se passe à l'heure d'importation). Afin de se débarrasser de cela, nous aurons besoin de remplacer manuellement le décorateur le décorateur du module, puis ré-importer le module contenant notre UET.

Notre module de test:

#  test_uut.py

from unittest import TestCase
from app import uut  # Module with our thing to test
from app import decorators  # Module with the decorator we need to replace
import imp  # Library to help us reload our UUT module
from mock import patch


class TestUUT(TestCase):
    def setUp(self):
        # Do cleanup first so it is ready if an exception is raised
        def kill_patches():  # Create a cleanup callback that undoes our patches
            patch.stopall()  # Stops all patches started with start()
            imp.reload(uut)  # Reload our UUT module which restores the original decorator
        self.addCleanup(kill_patches)  # We want to make sure this is run so we do this in addCleanup instead of tearDown

        # Now patch the decorator where the decorator is being imported from
        patch('app.decorators.func_decor', lambda x: x).start()  # The lambda makes our decorator into a pass-thru. Also, don't forget to call start()          
        # HINT: if you're patching a decor with params use something like:
        # lambda *x, **y: lambda f: f
        imp.reload(uut)  # Reloads the uut.py module which applies our patched decorator

Le nettoyage de rappel, kill_patches, restaure l'original décorateur et re-s'applique à l'unité que nous étions l'essai. De cette façon, notre patch persiste uniquement par le biais d'un test unique, plutôt que l'ensemble de la session -- et c'est exactement comme n'importe quel autre patch devrait se comporter. Aussi, depuis le nettoyage des appels patch.stopall(), nous pouvons démarrer tous les autres patchs dans le setUp() nous avons besoin et ils seront nettoyées en un seul endroit.

La chose importante à comprendre au sujet de cette méthode est de savoir comment le rechargement aura un effet. Si un module prend trop de temps ou est la logique qui s'exécute lors de l'importation, vous aurez juste besoin de hausser les épaules et de tester le décorateur dans le cadre de l'unité. 🙁 J'espère que votre code est bien écrit que ça. Droit?

Si l'on ne se soucie pas si le patch est appliqué à l'ensemble de la session de test, la façon la plus simple de le faire est de droite en haut du fichier de test:

# test_uut.py

from mock import patch
patch('app.decorators.func_decor', lambda x: x).start()  # MUST BE BEFORE THE UUT GETS IMPORTED ANYWHERE!

from app import uut

Assurez-vous de corriger le fichier avec le décorateur plutôt que de l'étendue locale de l'UET et de lancer le patch avant l'importation de l'unité avec le décorateur.

Fait intéressant, même si le patch est arrêté, tous les fichiers déjà importés auront toujours le patch appliqué à le décorateur, ce qui est l'inverse de la situation, nous avons commencé avec. Sachez que cette méthode de patch tous les autres fichiers dans l'essai qui sont importés par la suite, même s'ils ne déclarent pas un patch eux-mêmes.

La suite fonctionné pour moi:

1. Éliminer l'instruction d'importation qui charge le test de la cible.
2. Patch le décorateur sur le test de démarrage appliquée ci-dessus.
3. Invoquer importlib.import_module() immédiatement après la mise à jour charger le test de la cible.
4. Exécuter des tests normalement.

Il a travaillé comme un charme.

Concept

Cela peut sembler un peu étrange, mais on peut patch sys.path, avec une copie de lui-même, et d'effectuer une importation dans le champ d'application de la fonction de test. Le code suivant illustre le concept.

from unittest.mock import patch
import sys

@patch('sys.modules', sys.modules.copy())
def testImport():
 oldkeys = set(sys.modules.keys())
 import MODULE
 newkeys = set(sys.modules.keys())
 print((newkeys)-(oldkeys))

oldkeys = set(sys.modules.keys())
testImport()                       -> ("MODULE") # Set contains MODULE
newkeys = set(sys.modules.keys())
print((newkeys)-(oldkeys))         -> set()      # An empty set

MODULE peut alors être remplacé par le module de test. (Cela fonctionne en Python 3.6 avec MODULE substitué avec xml par exemple)

OP

Pour votre cas, disons que la fonction décorateur réside dans le module pretty et décoré de la fonction réside dans present, alors vous patch pretty.decorator à l'aide de la simulation de machines et de leur substituer MODULE avec present. Quelque chose comme ce qui suit devrait fonctionner (non testé).

classe TestDecorator(unittest.Cas de test) :
...

  @patch(`pretty.decorator`, decorator)
  @patch(`sys.path`, sys.path.copy())
  def testFunction(self, decorator) :
   import present
   ...

Explication

Cela fonctionne en fournissant un "nettoyage" de sys.path pour chaque fonction de test, à l'aide d'une copie de la sys.path du module de test. Cette copie est faite lorsque le module est d'abord analysée assurer la cohérence de l' sys.path pour tous les tests.

Nuances

Il y a quelques implications, cependant. Si le framework de test s'exécute de multiples modules de test dans les mêmes python session de test du module que les importations MODULE à l'échelle mondiale sauts de n'importe quel module de test que les importations localement. Cela oblige à effectuer l'importation localement partout. Si le cadre s'exécute à chaque module de test dans le cadre d'un python session alors cela devrait fonctionner. De même, vous ne pouvez pas importer d' MODULE globalement dans le cadre d'un module de test où vous importez MODULE localement.

Le local des importations doit être effectué pour chaque test de la fonction au sein d'une sous-classe de unittest.TestCase. C'est peut-être possible de l'appliquer à la unittest.TestCase sous-classe de faire une importation particulière du module disponible pour toutes les fonctions de test au sein de la classe.

Construit Ins

Ceux déconner avec builtin importations trouverez remplacement MODULE avec sys, os etc. va échouer, car ce sont des alread sur sys.path lorsque vous essayez de le copier. L'astuce ici est de lancer Python avec le groupe builtin importations désactivé, je pense que python -X test.py va le faire mais j'ai oublié le drapeau approprié (Voir python --help). Ceux-ci peuvent ensuite être importées localement à l'aide de import builtins, IIRC.