python - template - ifequal django

¿Cómo me burlo de un manejador de señal django?

Question

Tengo un signal_handler conectado a través de un decorador, algo así como este muy simple:

@receiver(post_save, sender=User, 
          dispatch_uid=''myfile.signal_handler_post_save_user'')
def signal_handler_post_save_user(sender, *args, **kwargs):
   # do stuff

Lo que quiero hacer es burlarlo con la biblioteca simulada http://www.voidspace.org.uk/python/mock/ en una prueba, para comprobar cuántas veces lo llama django. Mi código en este momento es algo así como:

def test_cache():
    with mock.patch(''myapp.myfile.signal_handler_post_save_user'') as mocked_handler:
        # do stuff that will call the post_save of User
    self.assert_equal(mocked_handler.call_count, 1)

El problema aquí es que se llama al manejador de señal original incluso si se burla, muy probablemente porque el decorador @receiver está almacenando una copia del manejador de señal en alguna parte, así que me estoy burlando del código equivocado.

Entonces la pregunta: ¿cómo me burlo de mi manejador de señal para hacer que mi prueba funcione?

Tenga en cuenta que si cambio mi manejador de señal a:

def _support_function(*args, **kwargs):
    # do stuff

@receiver(post_save, sender=User, 
          dispatch_uid=''myfile.signal_handler_post_save_user'')
def signal_handler_post_save_user(sender, *args, **kwargs):
   _support_function(*args, **kwargs)

y me burlo de _support_function en _support_function lugar, todo funciona como se esperaba.

Answer 1

En django 1.9 puedes simular todos los receptores con algo como esto

# replace actual receivers with mocks
mocked_receivers = []
for i, receiver in enumerate(your_signal.receivers):
    mock_receiver = Mock()
    your_signal.receivers[i] = (receiver[0], mock_receiver)
    mocked_receivers.append(mock_receiver)

...  # whatever your test does

# ensure that mocked receivers have been called as expected
for mocked_receiver in mocked_receivers:
    assert mocked_receiver.call_count == 1
    mocked_receiver.assert_called_with(*your_args, sender="your_sender", signal=your_signal, **your_kwargs)

Esto reemplaza a todos los receptores con simulacros, por ejemplo, los que ha registrado, las aplicaciones conectables que se han registrado y las que django mismo ha registrado. No se sorprenda si usa esto en post_save y las cosas comienzan a romperse.

Es posible que desee inspeccionar el receptor para determinar si realmente quiere burlarse de él.

Answer 2

Entonces, terminé con una especie de solución: burlarse de un manejador de señal simplemente significa conectar el simulador a la señal, así que esto es exactamente lo que hice:

def test_cache():
    with mock.patch(''myapp.myfile.signal_handler_post_save_user'', autospec=True) as mocked_handler:
        post_save.connect(mocked_handler, sender=User, dispatch_uid=''test_cache_mocked_handler'')
        # do stuff that will call the post_save of User
    self.assertEquals(mocked_handler.call_count, 1)  # standard django
    # self.assert_equal(mocked_handler.call_count, 1)  # when using django-nose

Tenga en cuenta que autospec=True en mock.patch es necesario para que post_save.connect funcione correctamente en MagicMock , de lo contrario, django generará algunas excepciones y la conexión fallará.

Answer 3

Hay una forma de burlarse de las señales de django con una clase pequeña.

Debes tener en cuenta que esto solo simularía la función como manejador de señal django y no la función original; por ejemplo, si un m2mchange implica una llamada a una función que llama directamente a su manejador, no se incrementará el número de cuenta. Necesitarías un simulacro separado para realizar un seguimiento de esas llamadas.

Aquí está la clase en cuestión:

class LocalDjangoSignalsMock():
    def __init__(self, to_mock):
        """ 
        Replaces registered django signals with MagicMocks

        :param to_mock: list of signal handlers to mock
        """
        self.mocks = {handler:MagicMock() for handler in to_mock}
        self.reverse_mocks = {magicmock:mocked
                              for mocked,magicmock in self.mocks.items()}
        django_signals = [signals.post_save, signals.m2m_changed]
        self.registered_receivers = [signal.receivers
                                     for signal in django_signals]

    def _apply_mocks(self):
        for receivers in self.registered_receivers:
            for receiver_index in xrange(len(receivers)):
                handler = receivers[receiver_index]
                handler_function = handler[1]()
                if handler_function in self.mocks:
                    receivers[receiver_index] = (
                        handler[0], self.mocks[handler_function])

    def _reverse_mocks(self):
        for receivers in self.registered_receivers:
            for receiver_index in xrange(len(receivers)):
                handler = receivers[receiver_index]
                handler_function = handler[1]
                if not isinstance(handler_function, MagicMock):
                    continue
                receivers[receiver_index] = (
                    handler[0], weakref.ref(self.reverse_mocks[handler_function]))

    def __enter__(self):
        self._apply_mocks()
        return self.mocks

    def __exit__(self, *args):
        self._reverse_mocks()

Ejemplo de uso

to_mock = [my_handler]
with LocalDjangoSignalsMock(to_mock) as mocks:
    my_trigger()
    for mocked in to_mock:
        assert(mocks[mocked].call_count)
        # ''function {0} was called {1}''.format(
        #      mocked, mocked.call_count)

Answer 4

Posiblemente una mejor idea es burlarse de la funcionalidad dentro del manejador de señal en lugar del manejador. Usando el código de OP:

@receiver(post_save, sender=User, dispatch_uid=''myfile.signal_handler_post_save_user'')
def signal_handler_post_save_user(sender, *args, **kwargs):
  do_stuff()  # <-- mock this

def do_stuff():
   ... do stuff in here

Luego do_stuff :

with mock.patch(''myapp.myfile.do_stuff'') as mocked_handler:
    self.assert_equal(mocked_handler.call_count, 1)

Answer 5

Puede simular una señal django burlándose de la clase django.db.models.signals.py en django.db.models.signals.py siguiente manera:

@patch("django.db.models.signals.ModelSignal.send")
def test_overwhelming(self, mocker_signal):
    obj = Object()

Eso debería hacer el truco. Tenga en cuenta que esto simulará TODAS las señales sin importar qué objeto esté usando.

Si por casualidad usas la biblioteca de mocker , puedes hacerlo de la siguiente manera:

from mocker import Mocker, ARGS, KWARGS

def test_overwhelming(self):
    mocker = Mocker()
    # mock the post save signal
    msave = mocker.replace("django.db.models.signals")
    msave.post_save.send(KWARGS)
    mocker.count(0, None)

    with mocker:
        obj = Object()

Son más líneas pero funciona bastante bien también :)

Answer 6

echa un vistazo a mock_django. Tiene soporte para señales

https://github.com/dcramer/mock-django/blob/master/tests/mock_django/signals/tests.py