def test_send(self, fake_client):
url = "https://*****:*****@host:1234/1"
timeout = 1
verify_ssl = 1
ca_certs = "/some/path/somefile"
fake = fake_client.return_value
raven_client = Client(
dsn="tornado+{0}?timeout={1}&verify_ssl={2}&ca_certs={3}".
format(url, timeout, verify_ssl, ca_certs))
raven_client.captureMessage(message="test")
# make sure an instance of HTTPClient was created, since we are not in
# an IOLoop
fake_client.assert_called_once_with()
fake_fetch = fake.fetch
# make sure we called fetch() which does the sending
self.assertEqual(fake_fetch.call_count, 1)
# only verify the special kwargs that we should be passing through,
# no need to verify the urls and whatnot
args, kwargs = fake_fetch.call_args
self.assertEqual(kwargs["connect_timeout"], timeout)
self.assertEqual(kwargs["validate_cert"], bool(verify_ssl))
self.assertEqual(kwargs["ca_certs"], ca_certs)
class SentryReporter(object):
def __init__(self, sentry_dsn, **unused):
if Client is None:
raise RavenNotAvailable('Raven is not installed, maybe run "pip install raven"')
self.client = Client(sentry_dsn)
def report(self, traceback):
environ = traceback.context.get('environ', {})
data = {
'sentry.interfaces.Http': {
'method': environ.get('REQUEST_METHOD'),
'url': get_current_url(environ, strip_querystring=True),
'query_string': environ.get('QUERY_STRING'),
# TODO
# 'data': environ.get('wsgi.input'),
'headers': dict(get_headers(environ)),
'env': dict(get_environ(environ)),
}
}
is_backlash_event = getattr(traceback.exc_value, 'backlash_event', False)
if is_backlash_event:
# Just a Stack Dump request from backlash
self.client.captureMessage(traceback.exception, data=data,
stack=traceback.frames)
else:
# This is a real crash
self.client.captureException(exc_info=traceback.exc_info, data=data)
class ThreadedTransportTest(TestCase):
def setUp(self):
self.url = "threaded+http://some_username:some_password@localhost:8143/1"
self.client = Client(dsn=self.url)
@mock.patch('raven.transport.http.HTTPTransport.send')
def test_does_send(self, send):
self.client.captureMessage(message='foo')
time.sleep(0.1)
# TODO: This test could be more precise by ensuring it's sending the same params that are sent
# to the ThreadedHTTPTransport.send() method
self.assertEqual(send.call_count, 1)
def test_shutdown_waits_for_send(self):
url = urlparse(self.url)
transport = DummyThreadedScheme(url)
transport.send_delay = 0.5
data = self.client.build_msg('raven.events.Message', message='foo')
transport.async_send(data, None, None, None)
time.sleep(0.1)
# this should wait for the message to get sent
transport.get_worker().main_thread_terminated()
self.assertEqual(len(transport.events), 1)
class SentryReporter(object):
def __init__(self, sentry_dsn, **unused):
if Client is None:
raise RavenNotAvailable('Raven is not installed, maybe run "pip install raven"')
self.client = Client(sentry_dsn)
def report(self, traceback):
environ = traceback.context.get('environ', {})
data = {
'sentry.interfaces.Http': {
'method': environ.get('REQUEST_METHOD'),
'url': get_current_url(environ, strip_querystring=True),
'query_string': environ.get('QUERY_STRING'),
# TODO
# 'data': environ.get('wsgi.input'),
'headers': dict(get_headers(environ)),
'env': dict(get_environ(environ)),
}
}
is_backlash_event = getattr(traceback.exc_value, 'backlash_event', False)
if is_backlash_event:
# Just a Stack Dump request from backlash
self.client.captureMessage(traceback.exception, data=data,
stack=traceback.frames)
else:
# This is a real crash
self.client.captureException(data=data)
class ThreadedTransportTest(TestCase):
def setUp(self):
self.url = "threaded+requests+http://some_username:some_password@localhost:8143/1"
self.client = Client(dsn=self.url)
@mock.patch('raven.transport.requests.post')
def test_does_send(self, send):
self.client.captureMessage(message='foo')
time.sleep(0.1)
self.assertEqual(send.call_count, 1)
expected_url = 'http://localhost:8143/api/1/store/'
self.assertEqual(expected_url, send.call_args[0][0])
def test_shutdown_waits_for_send(self):
url = urlparse(self.url)
transport = DummyThreadedScheme(url)
transport.send_delay = 0.5
data = self.client.build_msg('raven.events.Message', message='foo')
transport.async_send(data, None, None, None)
time.sleep(0.1)
# this should wait for the message to get sent
transport.get_worker().main_thread_terminated()
self.assertEqual(len(transport.events), 1)
def test__sending_with_error_calls_error_callback(self):
c = Client(dsn='tornado+http://uver:pass@localhost:46754/1')
with mock.patch.object(Client, '_failed_send') as mock_failed:
c.captureMessage(message='test')
yield gen.sleep(0.01) # we need to run after the async send
assert mock_failed.called
def test__sending_successfully_calls_success_callback(self):
c = Client(dsn='tornado+http://uver:pass@localhost:46754/1')
with mock.patch.object(Client, '_successful_send') as mock_successful:
with mock.patch.object(httpclient.AsyncHTTPClient,
'fetch') as mock_fetch:
mock_fetch.return_value = gen.maybe_future(True)
c.captureMessage(message='test')
yield gen.sleep(0.01) # we need to run after the async send
assert mock_successful.called
class RequestsTransportTest(TestCase):
def setUp(self):
self.client = Client(
dsn="requests+http://some_username:some_password@localhost:8143/1",
)
@mock.patch('raven.transport.requests.post')
def test_does_send(self, post):
self.client.captureMessage(message='foo')
self.assertEqual(post.call_count, 1)
expected_url = 'http://localhost:8143/api/1/store/'
self.assertEqual(expected_url, post.call_args[0][0])
class RequestsTransportTest(TestCase):
def setUp(self):
self.client = Client(
dsn="requests+http://some_username:some_password@localhost:8143/1",
)
@mock.patch('requests.post')
def test_does_send(self, post):
self.client.captureMessage(message='foo')
self.assertEqual(post.call_count, 1)
expected_url = 'http://localhost:8143/api/1/store/'
self.assertEqual(expected_url, post.call_args[0][0])
class ThreadedTransportTest(TestCase):
def setUp(self):
self.client = Client(
dsn="threaded+http://some_username:some_password@localhost:8143/1",
)
@mock.patch('raven.transport.http.HTTPTransport.send')
def test_does_send(self, send):
self.client.captureMessage(message='foo')
time.sleep(0.1)
# TODO: This test could be more precise by ensuring it's sending the same params that are sent
# to the ThreadedHTTPTransport.send() method
self.assertEqual(send.call_count, 1)
class ClientUDPTest(TestCase):
def setUp(self):
self.server_socket = socket(AF_INET, SOCK_DGRAM)
self.server_socket.bind(('127.0.0.1', 0))
self.client = Client(servers=["udp://%s:%s" % self.server_socket.getsockname()], key='BassOmatic')
def test_delivery(self):
self.client.captureMessage('test')
data, address = self.server_socket.recvfrom(2 ** 16)
self.assertTrue("\n\n" in data)
header, payload = data.split("\n\n")
for substring in ("sentry_timestamp=", "sentry_client="):
self.assertTrue(substring in header)
def tearDown(self):
self.server_socket.close()
class ClientUDPTest(TestCase):
def setUp(self):
self.server_socket = socket(AF_INET, SOCK_DGRAM)
self.server_socket.bind(("127.0.0.1", 0))
self.client = Client(servers=["udp://%s:%s" % self.server_socket.getsockname()], key="BassOmatic")
def test_delivery(self):
self.client.captureMessage("test")
data, address = self.server_socket.recvfrom(2 ** 16)
self.assertTrue("\n\n" in data)
header, payload = data.split("\n\n")
for substring in ("sentry_timestamp=", "sentry_client="):
self.assertTrue(substring in header)
def tearDown(self):
self.server_socket.close()
class GeventTransportTest(TestCase):
def setUp(self):
gevent.monkey.patch_socket()
self.addCleanup(reload, socket)
gevent.monkey.patch_time()
self.addCleanup(reload, time)
self.client = Client(
dsn="gevent+http://some_username:some_password@localhost:8143/1",
)
@mock.patch.object(GeventedHTTPTransport, '_done')
@mock.patch('raven.transport.http.HTTPTransport.send')
def test_does_send(self, send, done):
self.client.captureMessage(message='foo')
time.sleep(0)
self.assertEqual(send.call_count, 1)
time.sleep(0)
self.assertEquals(done.call_count, 1)
class GeventTransportTest(TestCase):
def setUp(self):
gevent.monkey.patch_socket()
gevent.monkey.patch_time()
self.client = Client(
dsn="gevent+http://some_username:some_password@localhost:8143/1", )
def tearDown(self):
# Undo gevent monkey patching
reload(socket)
reload(time)
@mock.patch('raven.transport.base.GeventedHTTPTransport._done')
@mock.patch('raven.transport.base.HTTPTransport.send')
def test_does_send(self, send, done):
self.client.captureMessage(message='foo')
time.sleep(0)
self.assertEqual(send.call_count, 1)
time.sleep(0)
self.assertEquals(done.call_count, 1)
class GeventTransportTest(TestCase):
def setUp(self):
gevent.monkey.patch_socket()
gevent.monkey.patch_time()
self.client = Client(
dsn="gevent+http://some_username:some_password@localhost:8143/1",
)
def tearDown(self):
# Undo gevent monkey patching
reload(socket)
reload(time)
@mock.patch('raven.transport.base.GeventedHTTPTransport._done')
@mock.patch('raven.transport.base.HTTPTransport.send')
def test_does_send(self, send, done):
self.client.captureMessage(message='foo')
time.sleep(0)
self.assertEqual(send.call_count, 1)
time.sleep(0)
self.assertEquals(done.call_count, 1)
class ThreadedTransportTest(TestCase):
def setUp(self):
self.url = "threaded+http://some_username:some_password@localhost:8143/1"
self.client = Client(dsn=self.url)
@mock.patch('raven.transport.http.HTTPTransport.send')
def test_does_send(self, send):
self.client.captureMessage(message='foo')
time.sleep(0.1)
# TODO: This test could be more precise by ensuring it's sending the same params that are sent
# to the ThreadedHTTPTransport.send() method
self.assertEqual(send.call_count, 1)
def test_shutdown_waits_for_send(self):
url = urlparse(self.url)
transport = DummyThreadedScheme()
transport.send_delay = 0.5
data = self.client.build_msg('raven.events.Message', message='foo')
transport.async_send(url, data, None, None, None)
time.sleep(0.1)
# this should wait for the message to get sent
transport.get_worker().main_thread_terminated()
self.assertEqual(len(transport.events), 1)
def test_fork_spawns_anew(self):
url = urlparse(self.url)
transport = DummyThreadedScheme()
transport.send_delay = 0.5
data = self.client.build_msg('raven.events.Message', message='foo')
pid = os.fork()
if pid == 0:
time.sleep(0.1)
transport.async_send(url, data, None, None, None)
# this should wait for the message to get sent
transport.get_worker().main_thread_terminated()
self.assertEqual(len(transport.events), 1)
# Use os._exit here so that py.test gets not confused about
# what the hell we're doing here.
os._exit(0)
else:
os.waitpid(pid, 0)
def test_fork_with_active_worker(self):
# Test threaded transport when forking with an active worker.
# Forking a process doesn't clone the worker thread - make sure
# logging from both processes still works.
event1 = self.client.build_msg('raven.events.Message',
message='parent')
event2 = self.client.build_msg('raven.events.Message', message='child')
url = urlparse(self.url)
fd, filename = mkstemp()
try:
os.close(fd)
transport = LoggingThreadedScheme(filename)
# Log from the parent process - starts the worker thread
transport.async_send(url, event1, None, None, None)
childpid = os.fork()
if childpid == 0:
# Log from the child process
transport.async_send(url, event2, None, None, None)
# Ensure threaded worker has finished
transport.get_worker().stop()
os._exit(0)
# Wait for the child process to finish
os.waitpid(childpid, 0)
assert os.path.isfile(filename)
# Ensure threaded worker has finished
transport.get_worker().stop()
with open(filename, 'r') as logfile:
events = dict(x.strip().split() for x in logfile.readlines())
# Check parent and child both logged successfully
assert events == {
str(os.getpid()): 'parent',
str(childpid): 'child',
}
finally:
os.remove(filename)
class ThreadedTransportTest(TestCase):
def setUp(self):
self.url = "threaded+http://some_username:some_password@localhost:8143/1"
self.client = Client(dsn=self.url)
@mock.patch('raven.transport.http.HTTPTransport.send')
def test_does_send(self, send):
self.client.captureMessage(message='foo')
time.sleep(0.1)
# TODO: This test could be more precise by ensuring it's sending the same params that are sent
# to the ThreadedHTTPTransport.send() method
self.assertEqual(send.call_count, 1)
def test_shutdown_waits_for_send(self):
url = urlparse(self.url)
transport = DummyThreadedScheme()
transport.send_delay = 0.5
data = self.client.build_msg('raven.events.Message', message='foo')
transport.async_send(url, data, None, None, None)
time.sleep(0.1)
# this should wait for the message to get sent
transport.get_worker().main_thread_terminated()
self.assertEqual(len(transport.events), 1)
def test_fork_spawns_anew(self):
url = urlparse(self.url)
transport = DummyThreadedScheme()
transport.send_delay = 0.5
data = self.client.build_msg('raven.events.Message', message='foo')
pid = os.fork()
if pid == 0:
time.sleep(0.1)
transport.async_send(url, data, None, None, None)
# this should wait for the message to get sent
transport.get_worker().main_thread_terminated()
self.assertEqual(len(transport.events), 1)
# Use os._exit here so that py.test gets not confused about
# what the hell we're doing here.
os._exit(0)
else:
os.waitpid(pid, 0)
def test_fork_with_active_worker(self):
# Test threaded transport when forking with an active worker.
# Forking a process doesn't clone the worker thread - make sure
# logging from both processes still works.
event1 = self.client.build_msg('raven.events.Message', message='parent')
event2 = self.client.build_msg('raven.events.Message', message='child')
url = urlparse(self.url)
fd, filename = mkstemp()
try:
os.close(fd)
transport = LoggingThreadedScheme(filename)
# Log from the parent process - starts the worker thread
transport.async_send(url, event1, None, None, None)
childpid = os.fork()
if childpid == 0:
# Log from the child process
transport.async_send(url, event2, None, None, None)
# Ensure threaded worker has finished
transport.get_worker().stop()
os._exit(0)
# Wait for the child process to finish
os.waitpid(childpid, 0)
assert os.path.isfile(filename)
# Ensure threaded worker has finished
transport.get_worker().stop()
with open(filename, 'r') as logfile:
events = dict(x.strip().split() for x in logfile.readlines())
# Check parent and child both logged successfully
assert events == {
str(os.getpid()): 'parent',
str(childpid): 'child',
}
finally:
os.remove(filename)
