def test_signals_all_listeners_reports_first_failure(self, collector_cls):
collector = collector_cls()
class MyException(Exception):
pass
def get_mock_listener():
m = Mock()
m.return_value = None
return m
first_attached_handler = get_mock_listener()
def second_handler_that_will_fail(*a, **kw):
raise MyException('foo')
last_attached_handler = get_mock_listener()
listeners = [
first_attached_handler, second_handler_that_will_fail,
last_attached_handler]
for l in listeners:
results_collected.connect(l)
try:
with pytest.raises(MyException) as excinfo:
with collector:
pass
assert str(excinfo.value).endswith('foo')
method_name_in_stacktrace = 'second_handler_that_will_fail'
assert method_name_in_stacktrace in str(excinfo.value)
assert first_attached_handler.called
assert last_attached_handler.called
finally:
for l in listeners:
results_collected.disconnect(l)
def test_signal_handler_error_doesnt_hide_orig_error(self, collector_cls):
collector = collector_cls()
failing_signal_handler = Mock(side_effect=Exception('handler error'))
results_collected.connect(failing_signal_handler)
try:
with pytest.raises(Exception) as excinfo:
with collector:
raise Exception('actual code error')
assert str(excinfo.value) == 'actual code error'
assert failing_signal_handler.called
finally:
results_collected.disconnect(failing_signal_handler)
def test_ctx_managers_can_be_nested(db):
captured = {}
def capture_signals(signal, sender, results, context):
captured.setdefault(sender, [])
total, = (r for r in results if r.name == 'total')
captured[sender].append(total)
results_collected.connect(capture_signals)
try:
with QueryCollector() as outer:
list(Group.objects.all())
list(Group.objects.all())
with QueryCollector() as inner:
list(Group.objects.all())
assert {outer: [3], inner: [1]} == captured
finally:
results_collected.disconnect(capture_signals)
def __exit__(self, exc_type, exc_val, exc_tb):
results_collected.disconnect(self.results_collected_handler)
def end(self):
results_collected.disconnect(self.handle_results_collected)
data = pickle.dumps(self.data, pickle.HIGHEST_PROTOCOL)
# TODO: couldn't write a test to verify file is opened only here
with open(self.fpath, 'wb') as f:
f.write(data)
def __exit__(self, exc_type, exc_val, exc_tb):
if self.is_anonymous():
self.collector.__exit__(exc_type, exc_val, exc_tb)
results_collected.disconnect(self.results_collected_handler)