def test_report_message_should_allow_multiple_handlers(
self,
mock__send_payload_async,
mock__send_payload_httpx,
mock__send_payload_thread,
mock__send_payload,
):
import asyncio
import rollbar
from rollbar.lib._async import report_message, run
async def async_report(handler):
rollbar.SETTINGS['handler'] = handler
await report_message('foo')
async def sync_report(handler):
rollbar.SETTINGS['handler'] = handler
rollbar.report_message('foo')
async def send_reports():
await asyncio.gather(
sync_report('thread'),
async_report('httpx'),
sync_report('blocking'),
async_report('async'),
)
run(send_reports())
mock__send_payload_async.assert_called_once()
mock__send_payload_httpx.assert_called_once()
mock__send_payload_thread.assert_called_once()
mock__send_payload.assert_called_once()
def test_try_report_should_raise_exc_if_httpx_package_is_missing(self):
import rollbar
from rollbar.lib._async import RollbarAsyncError, run, try_report
rollbar.SETTINGS['handler'] = 'httpx'
self.assertEqual(rollbar.SETTINGS['handler'], 'httpx')
with self.assertRaises(RollbarAsyncError):
run(try_report())
def test_should_try_report_if_default_handler(self, async_report_exc_info):
import rollbar
from rollbar.lib._async import run, try_report
rollbar.SETTINGS['handler'] = 'default'
self.assertEqual(rollbar.SETTINGS['handler'], 'default')
run(try_report())
async_report_exc_info.assert_called_once()
def test_should_run_rollbar_report_message(self, rollbar_report_message):
from rollbar.lib._async import report_message, run
run(
report_message('message', 'level', 'request', 'extra_data',
'payload_data'))
rollbar_report_message.assert_called_once_with('message', 'level',
'request', 'extra_data',
'payload_data')
def test_should_not_try_report_with_async_handler_if_non_async_handler(
self, async_report_exc_info):
import rollbar
from rollbar.lib._async import RollbarAsyncError, run, try_report
rollbar.SETTINGS['handler'] = 'thread'
self.assertEqual(rollbar.SETTINGS['handler'], 'thread')
with self.assertRaises(RollbarAsyncError):
run(try_report())
async_report_exc_info.assert_not_called()
def test_report_message_should_allow_httpx_handler(
self, mock__send_payload_httpx, mock_log):
import rollbar
from rollbar.lib._async import report_message, run
rollbar.SETTINGS['handler'] = 'httpx'
self.assertEqual(rollbar.SETTINGS['handler'], 'httpx')
run(report_message('foo', 'error'))
self.assertEqual(rollbar.SETTINGS['handler'], 'httpx')
mock__send_payload_httpx.assert_called_once()
mock_log.assert_not_called()
def test_report_exc_info_should_allow_async_handler(
self, mock__send_payload_async, mock_log):
import rollbar
from rollbar.lib._async import report_exc_info, run
rollbar.SETTINGS['handler'] = 'async'
self.assertEqual(rollbar.SETTINGS['handler'], 'async')
run(report_exc_info())
self.assertEqual(rollbar.SETTINGS['handler'], 'async')
mock__send_payload_async.assert_called_once()
mock_log.assert_not_called()
def test_report_message_should_use_async_handler_regardless_of_settings(
self, mock__send_payload_async, mock_log):
import rollbar
from rollbar.lib._async import report_message, run
rollbar.SETTINGS['handler'] = 'thread'
self.assertEqual(rollbar.SETTINGS['handler'], 'thread')
run(report_message('foo'))
self.assertEqual(rollbar.SETTINGS['handler'], 'thread')
mock__send_payload_async.assert_called_once()
mock_log.assert_called_once_with(
'Running coroutines requires async compatible handler. Switching to default async handler.'
)
def test_should_use_async_report_exc_info_if_any_async_handler(
self, sync_report_exc_info, async_report_exc_info
):
import rollbar
from rollbar.contrib.asgi.middleware import ReporterMiddleware
from rollbar.lib._async import FailingTestASGIApp, run
rollbar.SETTINGS['handler'] = 'httpx'
testapp = ReporterMiddleware(FailingTestASGIApp())
with self.assertRaises(RuntimeError):
run(testapp({'type': 'http'}, None, None))
self.assertTrue(async_report_exc_info.called)
self.assertFalse(sync_report_exc_info.called)
def test_report_message_should_allow_multiple_async_handlers(
self, mock__send_payload_async, mock__send_payload_httpx):
import asyncio
import rollbar
from rollbar.lib._async import report_message, run
async def report(handler):
rollbar.SETTINGS['handler'] = handler
await report_message('foo')
async def send_reports():
await asyncio.gather(report('async'), report('httpx'))
run(send_reports())
mock__send_payload_async.assert_called_once()
mock__send_payload_httpx.assert_called_once()
def test_should_support_http_only(self):
from rollbar.contrib.asgi.middleware import ReporterMiddleware
from rollbar.lib._async import FailingTestASGIApp, run
testapp = ReporterMiddleware(FailingTestASGIApp())
with mock.patch('rollbar.report_exc_info') as mock_report:
with self.assertRaises(RuntimeError):
run(testapp({'type': 'http'}, None, None))
self.assertTrue(mock_report.called)
with mock.patch('rollbar.report_exc_info') as mock_report:
with self.assertRaises(RuntimeError):
run(testapp({'type': 'websocket'}, None, None))
self.assertFalse(mock_report.called)
def test_should_catch_and_report_errors(self, mock_report):
from rollbar.contrib.asgi.middleware import ReporterMiddleware
from rollbar.lib._async import FailingTestASGIApp, run
testapp = ReporterMiddleware(FailingTestASGIApp())
with self.assertRaises(RuntimeError):
run(testapp({'type': 'http'}, None, None))
self.assertTrue(mock_report.called)
args, kwargs = mock_report.call_args
self.assertEqual(kwargs, {})
exc_type, exc_value, exc_tb = args[0]
self.assertEqual(exc_type, RuntimeError)
self.assertIsInstance(exc_value, RuntimeError)
def test_should_use_sync_report_exc_info_if_non_async_handlers(
self, sync_report_exc_info, async_report_exc_info, mock_log
):
import rollbar
from rollbar.contrib.asgi.middleware import ReporterMiddleware
from rollbar.lib._async import FailingTestASGIApp, run
rollbar.SETTINGS['handler'] = 'threading'
testapp = ReporterMiddleware(FailingTestASGIApp())
with self.assertRaises(RuntimeError):
run(testapp({'type': 'http'}, None, None))
self.assertFalse(async_report_exc_info.called)
self.assertTrue(sync_report_exc_info.called)
mock_log.assert_called_once_with(
'Failed to report asynchronously. Trying to report synchronously.'
)
def test_should_run_rollbar_report_exc_info(self, rollbar_report_exc_info):
from rollbar.lib._async import report_exc_info, run
try:
raise Exception()
except Exception:
run(
report_exc_info(
'exc_info',
'request',
'extra_data',
'payload_data',
'level_data',
foo='bar',
))
rollbar_report_exc_info.assert_called_once_with('exc_info',
'request',
'extra_data',
'payload_data',
'level_data',
foo='bar')
def test_report_messsage(self, send_payload):
from rollbar.lib._async import report_message, run
uuid = run(report_message('foo'))
send_payload.assert_called_once()
payload = send_payload.call_args[0][0]
self.assertEqual(payload['data']['uuid'], uuid)
self.assertEqual(payload['access_token'], self.access_token)
self.assertIn('body', payload['data'])
self.assertIn('message', payload['data']['body'])
self.assertIn('body', payload['data']['body']['message'])
self.assertEqual(payload['data']['body']['message']['body'], 'foo')
def _raise():
try:
raise Exception('foo')
except:
return run(report_exc_info())
