def test_dispatch_render_error(self):
"""Testing dispatch_webhook_event with an unencodable object"""
class Unencodable(object):
pass
handler = WebHookTarget(events='my-event',
url=self.ENDPOINT_URL,
encoding=WebHookTarget.ENCODING_JSON)
self.spy_on(webhooksLogger.exception)
self.spy_on(OpenerDirector.open,
owner=OpenerDirector,
call_fake=lambda *args, **kwargs: None)
message = (
'%r is not a valid data type for values in WebHook payloads.' %
Unencodable)
with self.assertRaisesMessage(ValueError, message):
dispatch_webhook_event(FakeHTTPRequest(None), [handler],
'my-event', {
'unencodable': Unencodable(),
})
self.assertFalse(OpenerDirector.open.called)
self.assertTrue(webhooksLogger.exception.called)
last_call_args = webhooksLogger.exception.last_call.args
self.assertEqual(
last_call_args[0],
'WebHook payload passed to dispatch_webhook_event containing '
'invalid data types: %s')
self.assertIsInstance(last_call_args[1], TypeError)
def test_dispatch_cannot_open(self):
"""Testing dispatch_webhook_event with an unresolvable URL"""
def _urlopen(opener, *args, **kwargs):
raise IOError('')
handler = WebHookTarget.objects.create(
events='my-event',
url=self.ENDPOINT_URL,
encoding=WebHookTarget.ENCODING_JSON)
self.spy_on(webhooksLogger.exception)
self.spy_on(OpenerDirector.open,
owner=OpenerDirector,
call_fake=_urlopen)
dispatch_webhook_event(request=FakeHTTPRequest(None),
webhook_targets=[handler, handler],
event='my-event',
payload='{}')
self.assertEqual(len(OpenerDirector.open.spy.calls), 2)
self.assertTrue(len(webhooksLogger.exception.spy.calls), 2)
self.assertIsInstance(webhooksLogger.exception.spy.calls[0].args[2],
IOError)
self.assertIsInstance(webhooksLogger.exception.spy.calls[1].args[2],
IOError)
def test_dispatch_render_error(self):
"""Testing dispatch_webhook_event with an unencodable object"""
class Unencodable(object):
pass
handler = WebHookTarget(events='my-event', url=self.ENDPOINT_URL,
encoding=WebHookTarget.ENCODING_JSON)
self.spy_on(logging.exception)
self.spy_on(OpenerDirector.open,
call_fake=lambda *args, **kwargs: None)
message = (
"<class 'reviewboard.notifications.tests.test_webhooks."
"Unencodable'> is not a valid data type for values in WebHook "
"payloads."
)
with self.assertRaisesMessage(ValueError, message):
dispatch_webhook_event(
FakeHTTPRequest(None),
[handler],
'my-event', {
'unencodable': Unencodable(),
})
self.assertFalse(OpenerDirector.open.called)
self.assertTrue(logging.exception.called)
last_call_args = logging.exception.last_call.args
self.assertEqual(
last_call_args[0],
'WebHook payload passed to dispatch_webhook_event containing '
'invalid data types: %s')
self.assertIsInstance(last_call_args[1], TypeError)
def test_dispatch_invalid_end_tag(self):
"""Testing dispatch_webhook_event with an invalid end tag in template
"""
handler = WebHookTarget(events='my-event',
url=self.ENDPOINT_URL,
encoding=WebHookTarget.ENCODING_JSON,
use_custom_content=True,
custom_content=r'{% if 1 %}{% bad_tag %}')
self.spy_on(webhooksLogger.exception)
self.spy_on(OpenerDirector.open,
owner=OpenerDirector,
call_fake=lambda *args, **kwargs: None)
dispatch_webhook_event(request=FakeHTTPRequest(None),
webhook_targets=[handler],
event='my-event',
payload='{}')
self.assertFalse(OpenerDirector.open.spy.called)
self.assertTrue(webhooksLogger.exception.spy.called)
log_call = webhooksLogger.exception.spy.last_call
self.assertIsInstance(log_call.args[1], TemplateSyntaxError)
self.assertEqual(
str(log_call.args[1]),
"Invalid block tag: 'bad_tag', expected 'elif', "
"'else' or 'endif'")
def _test_dispatch(self,
handler,
event,
payload,
expected_content_type,
expected_data,
expected_sig_header=None):
def _urlopen(opener, request, *args, **kwargs):
print(request.headers)
self.assertEqual(request.get_full_url(), self.ENDPOINT_URL)
self.assertEqual(request.headers[str('X-reviewboard-event')],
force_str(event))
self.assertEqual(request.headers[str('Content-type')],
force_str(expected_content_type))
self.assertEqual(request.data, expected_data)
self.assertEqual(request.headers[str('Content-length')],
force_str(len(expected_data)))
if expected_sig_header:
self.assertIn(str('X-hub-signature'), request.headers)
self.assertEqual(request.headers[str('X-hub-signature')],
force_str(expected_sig_header))
else:
self.assertNotIn(str('X-hub-signature'), request.headers)
# Check that all sent data are binary strings.
for h in request.headers:
self.assertIsInstance(h, str)
self.assertIsInstance(request.data, bytes)
self.spy_on(OpenerDirector.open,
owner=OpenerDirector,
call_fake=_urlopen)
# We need to ensure that webhooksLogger.exception is not called
# in order to avoid silent swallowing of test assertion failures
self.spy_on(webhooksLogger.exception)
request = FakeHTTPRequest(None)
dispatch_webhook_event(request, [handler], event, payload)
# Assuming that if webhooksLogger.exception is called, an assertion
# error was raised - and should thus be raised further.
if webhooksLogger.exception.spy.called:
raise webhooksLogger.exception.spy.calls[0].args[2]
def test_dispatch_invalid_template(self):
"""Testing dispatch_webhook_event with an invalid template"""
handler = WebHookTarget(events='my-event', url=self.ENDPOINT_URL,
encoding=WebHookTarget.ENCODING_JSON,
use_custom_content=True,
custom_content=r'{% invalid_block_tag %}')
self.spy_on(logging.exception)
self.spy_on(OpenerDirector.open,
call_fake=lambda *args, **kwargs: None)
dispatch_webhook_event(FakeHTTPRequest(None), [handler], 'my-event',
None)
self.assertFalse(OpenerDirector.open.spy.called)
self.assertTrue(logging.exception.spy.called)
self.assertIsInstance(logging.exception.spy.last_call.args[1],
TemplateSyntaxError)
def test_dispatch_cannot_open(self):
"""Testing dispatch_webhook_event with an unresolvable URL"""
def _urlopen(opener, *args, **kwargs):
raise IOError('')
handler = WebHookTarget(events='my-event',
url=self.ENDPOINT_URL,
encoding=WebHookTarget.ENCODING_JSON)
self.spy_on(logging.exception)
self.spy_on(OpenerDirector.open, call_fake=_urlopen)
dispatch_webhook_event(FakeHTTPRequest(None), [handler, handler],
'my-event', None)
self.assertEqual(len(OpenerDirector.open.spy.calls), 2)
self.assertTrue(len(logging.exception.spy.calls), 2)
self.assertIsInstance(logging.exception.spy.calls[0].args[2], IOError)
self.assertIsInstance(logging.exception.spy.calls[1].args[2], IOError)
def test_dispatch_invalid_template(self):
"""Testing dispatch_webhook_event with an invalid template"""
handler = WebHookTarget(events='my-event',
url=self.ENDPOINT_URL,
encoding=WebHookTarget.ENCODING_JSON,
use_custom_content=True,
custom_content=r'{% invalid_block_tag %}')
self.spy_on(logging.exception)
self.spy_on(OpenerDirector.open,
call_fake=lambda *args, **kwargs: None)
dispatch_webhook_event(FakeHTTPRequest(None), [handler], 'my-event',
None)
self.assertFalse(OpenerDirector.open.spy.called)
self.assertTrue(logging.exception.spy.called)
self.assertIsInstance(logging.exception.spy.last_call.args[1],
TemplateSyntaxError)
def test_dispatch_cannot_open(self):
"""Testing dispatch_webhook_event with an unresolvable URL"""
def _urlopen(opener, *args, **kwargs):
raise IOError('')
handler = WebHookTarget(events='my-event', url=self.ENDPOINT_URL,
encoding=WebHookTarget.ENCODING_JSON)
self.spy_on(logging.exception)
self.spy_on(OpenerDirector.open, call_fake=_urlopen)
dispatch_webhook_event(FakeHTTPRequest(None), [handler, handler],
'my-event',
None)
self.assertEqual(len(OpenerDirector.open.spy.calls), 2)
self.assertTrue(len(logging.exception.spy.calls), 2)
self.assertIsInstance(logging.exception.spy.calls[0].args[2], IOError)
self.assertIsInstance(logging.exception.spy.calls[1].args[2], IOError)
def test_dispatch_render_error(self):
"""Testing dispatch_webhook_event with an unencodable object"""
class Unencodable(object):
pass
handler = WebHookTarget(events='my-event',
url=self.ENDPOINT_URL,
encoding=WebHookTarget.ENCODING_JSON)
self.spy_on(logging.exception)
self.spy_on(OpenerDirector.open,
call_fake=lambda *args, **kwargs: None)
dispatch_webhook_event(FakeHTTPRequest(None), [handler], 'my-event', {
'unencodable': Unencodable(),
})
self.assertFalse(OpenerDirector.open.spy.called)
self.assertTrue(logging.exception.spy.called)
self.assertIsInstance(logging.exception.spy.last_call.args[1],
TypeError)
def _test_dispatch(self, handler, event, payload, expected_content_type,
expected_data, expected_sig_header=None):
def _urlopen(opener, request, *args, **kwargs):
self.assertEqual(request.get_full_url(), self.ENDPOINT_URL)
self.assertEqual(request.headers['X-reviewboard-event'], event)
self.assertEqual(request.headers['Content-type'],
expected_content_type)
self.assertEqual(request.data, expected_data)
self.assertEqual(request.headers['Content-length'],
len(expected_data))
if expected_sig_header:
self.assertIn('X-hub-signature', request.headers)
self.assertEqual(request.headers['X-hub-signature'],
expected_sig_header)
else:
self.assertNotIn('X-hub-signature', request.headers)
# Check that all sent data are binary strings.
self.assertIsInstance(request.get_full_url(), six.binary_type)
for h in request.headers:
self.assertIsInstance(h, six.binary_type)
self.assertNotIsInstance(request.headers[h], six.text_type)
self.assertIsInstance(request.data, six.binary_type)
self.spy_on(OpenerDirector.open, call_fake=_urlopen)
# We need to ensure that logging.exception is not called
# in order to avoid silent swallowing of test assertion failures
self.spy_on(logging.exception)
request = FakeHTTPRequest(None)
dispatch_webhook_event(request, [handler], event, payload)
# Assuming that if logging.exception is called, an assertion
# error was raised - and should thus be raised further.
if logging.exception.spy.called:
raise logging.exception.spy.calls[0].args[2]
def _test_dispatch(self, handler, event, payload, expected_content_type,
expected_data, expected_sig_header=None):
def _urlopen(request):
self.assertEqual(request.get_full_url(), self.ENDPOINT_URL)
self.assertEqual(request.headers['X-reviewboard-event'], event)
self.assertEqual(request.headers['Content-type'],
expected_content_type)
self.assertEqual(request.data, expected_data)
self.assertEqual(request.headers['Content-length'],
len(expected_data))
if expected_sig_header:
self.assertIn('X-hub-signature', request.headers)
self.assertEqual(request.headers['X-hub-signature'],
expected_sig_header)
else:
self.assertNotIn('X-hub-signature', request.headers)
self.spy_on(urlopen, call_fake=_urlopen)
request = FakeHTTPRequest(None)
dispatch_webhook_event(request, [handler], event, payload)
def _test_dispatch(self, handler, event, payload, expected_content_type,
expected_data, expected_sig_header=None):
def _urlopen(request):
self.assertEqual(request.get_full_url(), self.ENDPOINT_URL)
self.assertEqual(request.headers['X-reviewboard-event'], event)
self.assertEqual(request.headers['Content-type'],
expected_content_type)
self.assertEqual(request.data, expected_data)
self.assertEqual(request.headers['Content-length'],
len(expected_data))
if expected_sig_header:
self.assertIn('X-hub-signature', request.headers)
self.assertEqual(request.headers['X-hub-signature'],
expected_sig_header)
else:
self.assertNotIn('X-hub-signature', request.headers)
self.spy_on(urlopen, call_fake=_urlopen)
request = FakeHTTPRequest(None)
dispatch_webhook_event(request, [handler], event, payload)
