def test_register_reciever_call_connect(self):
"""should call connect to connect signal and receiver"""
register_reciever(self.model,
self.signal,
self.receiver)
# signal.connect should be called with receiver and model
self.signal.connect.assert_called_with(
self.receiver, sender=self.model, weak=False)
def watch(self, call_on_created=None):
self._call_on_created = (self._call_on_created if
call_on_created is None else call_on_created)
# initialize investigator
self._investigator = Investigator(self.model, include=[self.attr])
# register the receivers
register_reciever(self.model, pre_save, self._pre_save_receiver)
register_reciever(self.model, post_save, self._post_save_receiver)
def watch(self, call_on_created=None):
if call_on_created is not None:
self._call_on_created = call_on_created
super(ManyRelatedWatcher, self).watch(call_on_created)
if self.through_model:
# m2m relation
register_reciever(self.model, m2m_changed,
self._m2m_changed_receiver,
sender=self.through_model)
def test_register_reciever_call_connect_once(self):
"""should call connect only once to prevent the duplication"""
for i in range(5):
register_reciever(self.model,
self.signal,
self.receiver)
# signal.connect should be called once
self.signal.connect.assert_called_once_with(
self.receiver, sender=self.model, weak=False)
def watch(self, call_on_created=None):
if call_on_created is not None:
self._call_on_created = call_on_created
super(ManyRelatedWatcher, self).watch(call_on_created)
if self.through_model:
# m2m relation
register_reciever(self.model,
m2m_changed,
self._m2m_changed_receiver,
sender=self.through_model)
def test_register_reciever_prefer_specified_sender(self):
"""should call connect with specified sender"""
sender = MagicMock()
register_reciever(self.model,
self.signal,
self.receiver,
sender=sender)
# signal.connect should be called once with specified sender
self.signal.connect.assert_called_once_with(
self.receiver, sender=sender, weak=False)
def test_register_reciever_call_connect_of_individual_signals(self):
"""should call connect when signals are different"""
signals = [MagicMock(wraps=Signal, **{'connect.return_value': None})
for i in range(5)]
for signal in signals:
register_reciever(self.model,
signal,
self.receiver)
signal.connect.assert_called_once_with(
self.receiver, sender=self.model, weak=False)
def setUp(self):
self.model = MagicMock(wraps=models.Model)
self.signal = MagicMock(wraps=Signal, **{
'connect.return_value': None,
'disconnect.return_value': None,
})
self.receiver = MagicMock()
register_reciever(self.model,
self.signal,
self.receiver)
def watch(self, call_on_created=None):
self._call_on_created = (self._call_on_created
if call_on_created is None
else call_on_created)
# initialize investigator
self._investigator = Investigator(self.model, include=[self.attr])
# register the receivers
register_reciever(self.model, pre_save,
self._pre_save_receiver)
register_reciever(self.model, post_save,
self._post_save_receiver)
def test_register_reciever_call_connect_of_individual_receivers(self):
"""should call connect when receivers are different"""
receivers = [MagicMock() for i in range(5)]
for receiver in receivers:
register_reciever(self.model,
self.signal,
receiver)
self.signal.connect.assert_called_with(receiver, weak=False,
sender=self.model)
# called multiple times
self.assertEqual(self.signal.connect.call_count, 5)
def test_register_reciever_pass_the_options(self):
"""should call connect with specified **kwargs"""
register_reciever(self.model,
self.signal,
self.receiver,
weak=True,
foo='bar')
# signal.connect should be called once with specified **kwargs
# but weak cannot be modified
self.signal.connect.assert_called_once_with(
self.receiver, sender=self.model,
weak=False, foo='bar',
)
def test_register_reciever_return_false_for_2nd(self):
"""should return False for the 2nd and further call"""
register_reciever(self.model,
self.signal,
self.receiver)
# 2nd call
r = register_reciever(self.model,
self.signal,
self.receiver)
self.assertFalse(r)
# 3rd call
r = register_reciever(self.model,
self.signal,
self.receiver)
self.assertFalse(r)
def test_unregister_reciever_call_disconnect_of_individual_signals(self):
"""should call connect when signals are different"""
prop = {
'connect.return_value': None,
'disconnect.return_value': None,
}
signals = [MagicMock(wraps=Signal, **prop)
for i in range(5)]
for signal in signals:
register_reciever(self.model,
signal,
self.receiver)
for signal in signals:
unregister_reciever(self.model,
signal,
self.receiver)
signal.disconnect.assert_called_once_with(self.receiver)
def watch(self, call_on_created=None, include=None, exclude=None):
self._call_on_created = (self._call_on_created
if call_on_created is None
else call_on_created)
include = include or self.include
exclude = exclude or self.exclude
self._investigator = Investigator(self.related_model,
include=include,
exclude=exclude)
# register the receivers
register_reciever(self.model, pre_save,
self._pre_save_receiver,
sender=self.related_model)
register_reciever(self.model, post_save,
self._post_save_receiver,
sender=self.related_model)
register_reciever(self.model, post_save,
self._post_save_receiver_for_creation)
def watch(self, call_on_created=None, include=None, exclude=None):
self._call_on_created = (self._call_on_created if
call_on_created is None else call_on_created)
include = include or self.include
exclude = exclude or self.exclude
self._investigator = Investigator(self.related_model,
include=include,
exclude=exclude)
# register the receivers
register_reciever(self.model,
pre_save,
self._pre_save_receiver,
sender=self.related_model)
register_reciever(self.model,
post_save,
self._post_save_receiver,
sender=self.related_model)
register_reciever(self.model, post_save,
self._post_save_receiver_for_creation)
def test_register_reciever_return_true_for_1st(self):
"""should return True for the 1st call"""
r = register_reciever(self.model,
self.signal,
self.receiver)
self.assertTrue(r)
