entrouvert
/
debian-python-raven
17
0
Fork 0
Code Issues Pull Requests Releases Activity

Python3 port !

This commit is contained in:
Xavier Ordoquy 2013-04-01 23:22:38 +02:00
parent 8bd666d3b8
commit 90b5846a06
17 changed files with 201 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
conftest.py
View File

@ -1,6 +1,26 @@
from django.conf import settings
import os.path
INSTALLED_APPS=[
'django.contrib.auth',
'django.contrib.admin',
'django.contrib.sessions',
'django.contrib.sites',
# Included to fix Disqus' test Django which solves IntegrityMessage case
'django.contrib.contenttypes',
'raven.contrib.django',
]
use_djcelery = True
try:
import djcelery
INSTALLED_APPS.append('djcelery')
except ImportError:
use_djcelery = False
def pytest_configure(config):
where_am_i = os.path.dirname(os.path.abspath(__file__))
@ -17,19 +37,7 @@ def pytest_configure(config):
},
DATABASE_NAME=':memory:',
TEST_DATABASE_NAME=':memory:',
INSTALLED_APPS=[
'django.contrib.auth',
'django.contrib.admin',
'django.contrib.sessions',
'django.contrib.sites',
# Included to fix Disqus' test Django which solves IntegrityMessage case
'django.contrib.contenttypes',
'djcelery', # celery client
'raven.contrib.django',
],
INSTALLED_APPS=INSTALLED_APPS,
ROOT_URLCONF='',
DEBUG=False,
SITE_ID=1,
@ -42,6 +50,5 @@ def pytest_configure(config):
CELERY_ALWAYS_EAGER=True,
TEMPLATE_DEBUG=True,
TEMPLATE_DIRS=[os.path.join(where_am_i, 'tests', 'contrib', 'django', 'templates')],
ALLOWED_HOSTS=['*'],
)
import djcelery
djcelery.setup_loader()

7
raven/contrib/django/models.py
View File

@ -9,6 +9,7 @@ Acts as an implicit hook for Django installs.
"""
from __future__ import absolute_import
from __future__ import unicode_literals
from hashlib import md5
import logging
@ -125,7 +126,7 @@ def get_client(client=None):
options.setdefault('timeout', ga('TIMEOUT'))
options.setdefault('name', ga('NAME'))
options.setdefault('auto_log_stacks', ga('AUTO_LOG_STACKS'))
options.setdefault('key', ga('KEY', md5(django_settings.SECRET_KEY).hexdigest()))
options.setdefault('key', ga('KEY', md5(django_settings.SECRET_KEY.encode('utf8')).hexdigest()))
options.setdefault('string_max_length', ga('MAX_LENGTH_STRING'))
options.setdefault('list_max_length', ga('MAX_LENGTH_LIST'))
options.setdefault('site', ga('SITE'))
@ -154,9 +155,9 @@ def sentry_exception_handler(request=None, **kwargs):
client.captureException(exc_info=exc_info, request=request)
except Exception as exc:
try:
logger.exception(u'Unable to process log entry: %s' % (exc,))
logger.exception('Unable to process log entry: %s' % (exc,))
except Exception as exc:
warnings.warn(u'Unable to process log entry: %s' % (exc,))
warnings.warn('Unable to process log entry: %s' % (exc,))
def register_handlers():

9
raven/contrib/django/serializers.py
View File

@ -6,6 +6,7 @@ raven.contrib.django.serializers
:license: BSD, see LICENSE for more details.
"""
from __future__ import absolute_import
from __future__ import unicode_literals
from django.conf import settings
from django.http import HttpRequest
@ -48,8 +49,7 @@ class HttpRequestSerializer(Serializer):
types = (HttpRequest,)
def serialize(self, value, **kwargs):
return six.text_type(
'<%s at 0x%s>' % (type(value).__name__, id(value)))
return '<%s at 0x%s>' % (type(value).__name__, id(value))
register(HttpRequestSerializer)
@ -63,8 +63,7 @@ if getattr(settings, 'DATABASES', None):
def serialize(self, value, **kwargs):
qs_name = type(value).__name__
if value.model:
return six.text_type(
'<%s: model=%s>' % (qs_name, value.model.__name__))
return six.text_type('<%s: (Unbound)>' % (qs_name,))
return '<%s: model=%s>' % (qs_name, value.model.__name__)
return '<%s: (Unbound)>' % (qs_name,)
register(QuerySetSerializer)

2
raven/contrib/django/views.py
View File

@ -99,7 +99,7 @@ def report(request, project_id=None):
return HttpResponseBadRequest()
try:
decoded = json.loads(data)
decoded = json.loads(data.decode('utf8'))
except json.JSONDecodeError:
return HttpResponseBadRequest()

10
raven/handlers/logging.py
View File

@ -7,6 +7,7 @@ raven.handlers.logging
"""
from __future__ import absolute_import
from __future__ import print_function
import datetime
import logging
@ -47,18 +48,19 @@ class SentryHandler(logging.Handler, object):
def emit(self, record):
try:
# Beware to python3 bug (see #10805) if exc_info is (None, None, None)
self.format(record)
# Avoid typical config issues by overriding loggers behavior
if record.name.startswith('sentry.errors'):
print >> sys.stderr, to_string(record.message)
print(to_string(record.message), sys.stderr)
return
return self._emit(record)
except Exception:
print >> sys.stderr, "Top level Sentry exception caught - failed creating log record"
print >> sys.stderr, to_string(record.msg)
print >> sys.stderr, to_string(traceback.format_exc())
print("Top level Sentry exception caught - failed creating log record", sys.stderr)
print(to_string(record.msg), sys.stderr)
print(to_string(traceback.format_exc()), sys.stderr)
try:
self.client.captureException()

8
raven/transport/threaded.py
View File

@ -36,12 +36,12 @@ class AsyncWorker(object):
size = self._queue.qsize()
if size:
timeout = self.options['shutdown_timeout']
print "Sentry is attempting to send %s pending error messages" % size
print "Waiting up to %s seconds" % timeout
print("Sentry is attempting to send %s pending error messages" % size)
print("Waiting up to %s seconds" % timeout)
if os.name == 'nt':
print "Press Ctrl-Break to quit"
print("Press Ctrl-Break to quit")
else:
print "Press Ctrl-C to quit"
print("Press Ctrl-C to quit")
self.stop(timeout=timeout)
def start(self):

66
raven/utils/encoding.py
View File

@ -5,39 +5,53 @@ raven.utils.encoding
:copyright: (c) 2010-2012 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from __future__ import unicode_literals
import warnings
from raven.utils import six
def force_unicode(s, encoding='utf-8', errors='strict'):
def is_protected_type(obj):
"""Determine if the object instance is of a protected type.
Objects of protected types are preserved as-is when passed to
force_text(strings_only=True).
"""
Similar to smart_unicode, except that lazy instances are resolved to
import Decimal
import datetime
return isinstance(obj, six.integer_types + (type(None), float, Decimal,
datetime.datetime, datetime.date, datetime.time))
def force_text(s, encoding='utf-8', strings_only=False, errors='strict'):
"""
Similar to smart_text, except that lazy instances are resolved to
strings, rather than kept as lazy objects.
Adapted from Django
If strings_only is True, don't convert (some) non-string-like objects.
"""
# Handle the common case first, saves 30-40% when s is an instance of
# six.text_type. This function gets called often in that setting.
if isinstance(s, six.text_type):
return s
if strings_only and is_protected_type(s):
return s
try:
if not isinstance(s, basestring,):
if not isinstance(s, six.string_types):
if hasattr(s, '__unicode__'):
s = unicode(s)
s = s.__unicode__()
else:
try:
s = unicode(str(s), encoding, errors)
except UnicodeEncodeError:
if not isinstance(s, Exception):
raise
# If we get to here, the caller has passed in an Exception
# subclass populated with non-ASCII data without special
# handling to display as a string. We need to handle this
# without raising a further exception. We do an
# approximation to what the Exception's standard str()
# output should be.
s = ' '.join([force_unicode(arg, encoding,
errors) for arg in s])
elif not isinstance(s, unicode):
# Note: We use .decode() here, instead of unicode(s, encoding,
# errors), so that if s is a SafeString, it ends up being a
# SafeUnicode at the end.
if six.PY3:
if isinstance(s, bytes):
s = six.text_type(s, encoding, errors)
else:
s = six.text_type(s)
else:
s = six.text_type(bytes(s), encoding, errors)
else:
# Note: We use .decode() here, instead of six.text_type(s, encoding,
# errors), so that if s is a SafeBytes, it ends up being a
# SafeText at the end.
s = s.decode(encoding, errors)
except UnicodeDecodeError as e:
if not isinstance(s, Exception):
@ -48,7 +62,7 @@ def force_unicode(s, encoding='utf-8', errors='strict'):
# working unicode method. Try to handle this without raising a
# further exception by individually forcing the exception args
# to unicode.
s = ' '.join([force_unicode(arg, encoding,
s = ' '.join([force_text(arg, encoding, strings_only,
errors) for arg in s])
return s
@ -62,12 +76,12 @@ def transform(value):
def to_unicode(value):
try:
value = unicode(force_unicode(value))
value = six.text_type(force_text(value))
except (UnicodeEncodeError, UnicodeDecodeError):
value = '(Error decoding value)'
except Exception: # in some cases we get a different exception
try:
value = str(repr(type(value)))
value = six.binary_type(repr(type(value)))
except Exception:
value = '(Error decoding value)'
return value
@ -75,6 +89,6 @@ def to_unicode(value):
def to_string(value):
try:
return str(value.decode('utf-8').encode('utf-8'))
return six.binary_type(value.decode('utf-8').encode('utf-8'))
except:
return to_unicode(value).encode('utf-8')

6
raven/utils/serializer/base.py
View File

@ -51,7 +51,7 @@ class Serializer(object):
_depth += 1
if _depth >= max_depth:
try:
value = repr(value)
value = six.text_type(repr(value))
except Exception as e:
import traceback
traceback.print_exc()
@ -83,7 +83,7 @@ class DictSerializer(Serializer):
types = (dict,)
def make_key(self, key):
if not isinstance(key, basestring):
if not isinstance(key, six.string_types):
return to_unicode(key)
return key
@ -105,7 +105,7 @@ class UnicodeSerializer(Serializer):
# unicode character
# e.g. we want the output to be like: "u'רונית מגן'"
string_max_length = kwargs.get('string_max_length', None)
return six.text_type("u'{}'").format(value[:string_max_length])
return "u'{}'".format(value[:string_max_length])
class StringSerializer(Serializer):

4
raven/utils/stacks.py
View File

@ -47,7 +47,7 @@ def get_lines_from_file(filename, lineno, context_lines, loader=None, module_nam
source = source.splitlines()
if source is None:
try:
f = open(filename)
f = open(filename, 'rb')
try:
source = f.readlines()
finally:
@ -61,7 +61,7 @@ def get_lines_from_file(filename, lineno, context_lines, loader=None, module_nam
for line in source[:2]:
# File coding may be specified. Match pattern from PEP-263
# (http://www.python.org/dev/peps/pep-0263/)
match = _coding_re.search(line)
match = _coding_re.search(line.decode('ascii')) # let's assume ascii
if match:
encoding = match.group(1)
break

11
tests/base/tests.py
View File

@ -1,14 +1,16 @@
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import inspect
import mock
import raven
import time
from socket import socket, AF_INET, SOCK_DGRAM
from raven.utils.compat import TestCase
from raven.base import Client, ClientState
from raven.transport import AsyncTransport
from raven.utils.stacks import iter_stack_frames
from raven.utils import six
from raven.utils.compat import TestCase, skipIf
class TempStoreClient(Client):
@ -143,7 +145,7 @@ class ClientTest(TestCase):
})
send_remote.assert_called_once_with(
url='http://example.com',
data='eJyrVkrLz1eyUlBKSixSqgUAIJgEVA==',
data=six.b('eJyrVkrLz1eyUlBKSixSqgUAIJgEVA=='),
headers={
'User-Agent': 'raven-python/%s' % (raven.VERSION,),
'Content-Type': 'application/octet-stream',
@ -170,7 +172,7 @@ class ClientTest(TestCase):
})
send_remote.assert_called_once_with(
url='http://example.com',
data='eJyrVkrLz1eyUlBKSixSqgUAIJgEVA==',
data=six.b('eJyrVkrLz1eyUlBKSixSqgUAIJgEVA=='),
headers={
'User-Agent': 'raven-python/%s' % (raven.VERSION,),
'Content-Type': 'application/octet-stream',
@ -364,9 +366,10 @@ class ClientTest(TestCase):
self.assertEquals(len(self.client.events), 1)
event = self.client.events.pop(0)
self.assertEquals(event['extra'], {'logger': "'test'", 'foo': "'bar'"})
self.assertEquals(event['extra'], {'logger': "u'test'", 'foo': "u'bar'"})
@skipIf(six.PY3, "Skipping UDP for python3 for now")
class ClientUDPTest(TestCase):
def setUp(self):
self.server_socket = socket(AF_INET, SOCK_DGRAM)

31
tests/contrib/django/tests.py
View File

@ -2,6 +2,7 @@
from __future__ import absolute_import
from __future__ import with_statement
from __future__ import unicode_literals
import datetime
import django
@ -10,7 +11,6 @@ import mock
import re
from exam import fixture
from celery.tests.utils import with_eager_tasks
from StringIO import StringIO
from django.conf import settings
from django.core.exceptions import SuspiciousOperation
@ -29,6 +29,9 @@ from raven.contrib.django.middleware.wsgi import Sentry
from raven.contrib.django.templatetags.raven import sentry_public_dsn
from raven.contrib.django.views import is_valid_origin
from raven.utils.serializer import transform
from raven.utils import six
from raven.utils.six import StringIO
from raven.utils.compat import skipIf
from django.test.client import Client as TestClient, ClientHandler as TestClientHandler
from .models import TestModel
@ -91,12 +94,12 @@ class Settings(object):
self._orig = {}
def __enter__(self):
for k, v in self.overrides.iteritems():
for k, v in six.iteritems(self.overrides):
self._orig[k] = getattr(settings, k, self.NotDefined)
setattr(settings, k, v)
def __exit__(self, exc_type, exc_value, traceback):
for k, v in self._orig.iteritems():
for k, v in six.iteritems(self._orig):
if v is self.NotDefined:
delattr(settings, k)
else:
@ -144,9 +147,9 @@ class DjangoClientTest(TestCase):
self.assertTrue('sentry.interfaces.Exception' in event)
exc = event['sentry.interfaces.Exception']
self.assertEquals(exc['type'], 'ValueError')
self.assertEquals(exc['value'], u"invalid literal for int() with base 10: 'hello'")
self.assertEquals(exc['value'], "invalid literal for int() with base 10: 'hello'")
self.assertEquals(event['level'], logging.ERROR)
self.assertEquals(event['message'], u"ValueError: invalid literal for int() with base 10: 'hello'")
self.assertEquals(event['message'], "ValueError: invalid literal for int() with base 10: 'hello'")
self.assertEquals(event['culprit'], 'tests.contrib.django.tests in test_signal_integration')
def test_view_exception(self):
@ -310,6 +313,7 @@ class DjangoClientTest(TestCase):
# self.assertEquals(event['culprit'], 'tests.contrib.django.views in logging_request_exc')
# self.assertEquals(event['data']['META']['REMOTE_ADDR'], '127.0.0.1')
@skipIf(six.PY3, "Skipping due to python bug #10805")
def test_record_none_exc_info(self):
# sys.exc_info can return (None, None, None) if no exception is being
# handled anywhere on the stack. See:
@ -328,7 +332,6 @@ class DjangoClientTest(TestCase):
self.assertEquals(len(self.raven.events), 1)
event = self.raven.events.pop(0)
self.assertEquals(event['message'], 'test')
def test_404_middleware(self):
@ -344,7 +347,7 @@ class DjangoClientTest(TestCase):
self.assertTrue('sentry.interfaces.Http' in event)
http = event['sentry.interfaces.Http']
self.assertEquals(http['url'], u'http://testserver/non-existant-page')
self.assertEquals(http['url'], 'http://testserver/non-existant-page')
self.assertEquals(http['method'], 'GET')
self.assertEquals(http['query_string'], '')
self.assertEquals(http['data'], None)
@ -448,7 +451,7 @@ class DjangoClientTest(TestCase):
tags = event['tags']
assert 'site' in event['tags']
assert tags['site'] == u'example.com'
assert tags['site'] == 'example.com'
def test_adds_site_to_tags_fallback(self):
with Settings(SITE_ID=12345): # nonexistant site, should fallback to SITE_ID
@ -682,19 +685,19 @@ class PromiseSerializerTestCase(TestCase):
obj = lazy(lambda: 'bar', str)()
res = transform(obj)
self.assertEquals(res, "'bar'")
self.assertEquals(res, "bar")
def test_handles_gettext_lazy(self):
from django.utils.functional import lazy
def fake_gettext(to_translate):
return u'Igpay Atinlay'
return 'Igpay Atinlay'
fake_gettext_lazy = lazy(fake_gettext, str)
result = transform(fake_gettext_lazy("something"))
self.assertTrue(isinstance(result, basestring))
self.assertEquals(result, "u'Igpay Atinlay'")
self.assertTrue(isinstance(result, six.string_types))
self.assertEquals(result, "Igpay Atinlay")
class ModelInstanceSerializerTestCase(TestCase):
@ -702,7 +705,7 @@ class ModelInstanceSerializerTestCase(TestCase):
instance = TestModel()
result = transform(instance)
self.assertTrue(isinstance(result, basestring))
self.assertTrue(isinstance(result, six.string_types))
self.assertEquals(result, '<TestModel: TestModel object>')
@ -712,7 +715,7 @@ class QuerySetSerializerTestCase(TestCase):
obj = QuerySet(model=TestModel)
result = transform(obj)
self.assertTrue(isinstance(result, basestring))
self.assertTrue(isinstance(result, six.string_types))
self.assertEquals(result, '<QuerySet: model=TestModel>')

6
tests/contrib/tornado/tests.py
View File

@ -4,6 +4,8 @@
Test the tornado Async Client
"""
from __future__ import unicode_literals
import unittest
from mock import patch
from tornado import web, gen, testing
@ -122,7 +124,7 @@ class TornadoAsyncClientTestCase(testing.AsyncHTTPTestCase):
self.assertEqual(user_data['is_authenticated'], False)
assert 'extra_data' in kwargs['extra']
assert kwargs['extra']['extra_data'] == "'extra custom non-dict data'"
assert kwargs['extra']['extra_data'] == "u'extra custom non-dict data'"
@patch('raven.contrib.tornado.AsyncSentryClient.send')
def test_error_with_custom_dict_data_handler(self, send):
@ -147,7 +149,7 @@ class TornadoAsyncClientTestCase(testing.AsyncHTTPTestCase):
self.assertEqual(user_data['is_authenticated'], False)
assert 'extra_data' in kwargs['extra']
assert kwargs['extra']['extra_data'] == "'extra custom dict data'"
assert kwargs['extra']['extra_data'] == "u'extra custom dict data'"
@patch(
'raven.contrib.tornado.AsyncSentryClient.send',

7
tests/handlers/logbook/tests.py
View File

@ -1,6 +1,9 @@
from __future__ import with_statement
from __future__ import unicode_literals
import logbook
from raven.utils.compat import TestCase
from raven.utils import six
from raven.base import Client
from raven.handlers.logbook import SentryHandler
@ -59,7 +62,7 @@ class LogbookHandlerTest(TestCase):
))
self.assertEquals(len(client.events), 1)
event = client.events.pop(0)
self.assertEquals(event['extra']['url'], "'http://example.com'")
self.assertEquals(event['extra']['url'], "u'http://example.com'")
self.assertFalse('sentry.interfaces.Stacktrace' in event)
self.assertFalse('sentry.interfaces.Exception' in event)
self.assertTrue('sentry.interfaces.Message' in event)
@ -96,7 +99,7 @@ class LogbookHandlerTest(TestCase):
self.assertTrue('sentry.interfaces.Message' in event)
msg = event['sentry.interfaces.Message']
self.assertEquals(msg['message'], 'This is a test of {0}')
self.assertEquals(msg['params'], ("'args'",))
self.assertEquals(msg['params'], ("u'args'",))
def test_client_arg(self):
client = TempStoreClient(include_paths=['tests'])

76
tests/handlers/logging/tests.py
View File

@ -1,3 +1,5 @@
from __future__ import unicode_literals
import logging
import sys
from raven.utils.compat import TestCase
@ -35,17 +37,17 @@ class LoggingIntegrationTest(TestCase):
record = self.make_record('This is a test error')
self.handler.emit(record)
self.assertEquals(len(self.client.events), 1)
self.assertEqual(len(self.client.events), 1)
event = self.client.events.pop(0)
self.assertEquals(event['logger'], 'root')
self.assertEquals(event['level'], logging.INFO)
self.assertEquals(event['message'], 'This is a test error')
self.assertEqual(event['logger'], 'root')
self.assertEqual(event['level'], logging.INFO)
self.assertEqual(event['message'], 'This is a test error')
self.assertFalse('sentry.interfaces.Stacktrace' in event)
self.assertFalse('sentry.interfaces.Exception' in event)
self.assertTrue('sentry.interfaces.Message' in event)
msg = event['sentry.interfaces.Message']
self.assertEquals(msg['message'], 'This is a test error')
self.assertEquals(msg['params'], ())
self.assertEqual(msg['message'], 'This is a test error')
self.assertEqual(msg['params'], ())
def test_logger_extra_data(self):
record = self.make_record('This is a test error', extra={'data': {
@ -53,9 +55,9 @@ class LoggingIntegrationTest(TestCase):
}})
self.handler.emit(record)
self.assertEquals(len(self.client.events), 1)
self.assertEqual(len(self.client.events), 1)
event = self.client.events.pop(0)
self.assertEquals(event['extra']['url'], "'http://example.com'")
self.assertEqual(event['extra']['url'], "u'http://example.com'")
def test_logger_exc_info(self):
try:
@ -67,94 +69,94 @@ class LoggingIntegrationTest(TestCase):
self.handler.emit(record)
self.assertEquals(len(self.client.events), 1)
self.assertEqual(len(self.client.events), 1)
event = self.client.events.pop(0)
self.assertEquals(event['message'], 'This is a test info with an exception')
self.assertEqual(event['message'], 'This is a test info with an exception')
self.assertTrue('sentry.interfaces.Stacktrace' in event)
self.assertTrue('sentry.interfaces.Exception' in event)
exc = event['sentry.interfaces.Exception']
self.assertEquals(exc['type'], 'ValueError')
self.assertEquals(exc['value'], 'This is a test ValueError')
self.assertEqual(exc['type'], 'ValueError')
self.assertEqual(exc['value'], 'This is a test ValueError')
self.assertTrue('sentry.interfaces.Message' in event)
msg = event['sentry.interfaces.Message']
self.assertEquals(msg['message'], 'This is a test info with an exception')
self.assertEquals(msg['params'], ())
self.assertEqual(msg['message'], 'This is a test info with an exception')
self.assertEqual(msg['params'], ())
def test_message_params(self):
record = self.make_record('This is a test of %s', args=('args',))
self.handler.emit(record)
self.assertEquals(len(self.client.events), 1)
self.assertEqual(len(self.client.events), 1)
event = self.client.events.pop(0)
self.assertEquals(event['message'], 'This is a test of args')
self.assertEqual(event['message'], 'This is a test of args')
msg = event['sentry.interfaces.Message']
self.assertEquals(msg['message'], 'This is a test of %s')
self.assertEquals(msg['params'], ("'args'",))
self.assertEqual(msg['message'], 'This is a test of %s')
self.assertEqual(msg['params'], ("u'args'",))
def test_record_stack(self):
record = self.make_record('This is a test of stacks', extra={'stack': True})
self.handler.emit(record)
self.assertEquals(len(self.client.events), 1)
self.assertEqual(len(self.client.events), 1)
event = self.client.events.pop(0)
self.assertTrue('sentry.interfaces.Stacktrace' in event)
frames = event['sentry.interfaces.Stacktrace']['frames']
self.assertNotEquals(len(frames), 1)
frame = frames[0]
self.assertEquals(frame['module'], 'raven.handlers.logging')
self.assertEqual(frame['module'], 'raven.handlers.logging')
self.assertFalse('sentry.interfaces.Exception' in event)
self.assertTrue('sentry.interfaces.Message' in event)
self.assertEquals(event['culprit'], 'root in make_record')
self.assertEquals(event['message'], 'This is a test of stacks')
self.assertEqual(event['culprit'], 'root in make_record')
self.assertEqual(event['message'], 'This is a test of stacks')
def test_no_record_stack(self):
record = self.make_record('This is a test with no stacks', extra={'stack': False})
self.handler.emit(record)
self.assertEquals(len(self.client.events), 1)
self.assertEqual(len(self.client.events), 1)
event = self.client.events.pop(0)
self.assertEquals(event['message'], 'This is a test with no stacks')
self.assertEqual(event['message'], 'This is a test with no stacks')
self.assertFalse('sentry.interfaces.Stacktrace' in event)
def test_explicit_stack(self):
record = self.make_record('This is a test of stacks', extra={'stack': iter_stack_frames()})
self.handler.emit(record)
self.assertEquals(len(self.client.events), 1)
self.assertEqual(len(self.client.events), 1)
event = self.client.events.pop(0)
assert 'sentry.interfaces.Stacktrace' in event
assert 'culprit' in event
assert event['culprit'] == 'root in make_record'
self.assertTrue('message' in event, event)
self.assertEquals(event['message'], 'This is a test of stacks')
self.assertEqual(event['message'], 'This is a test of stacks')
self.assertFalse('sentry.interfaces.Exception' in event)
self.assertTrue('sentry.interfaces.Message' in event)
msg = event['sentry.interfaces.Message']
self.assertEquals(msg['message'], 'This is a test of stacks')
self.assertEquals(msg['params'], ())
self.assertEqual(msg['message'], 'This is a test of stacks')
self.assertEqual(msg['params'], ())
def test_extra_culprit(self):
record = self.make_record('This is a test of stacks', extra={'culprit': 'foo in bar'})
self.handler.emit(record)
self.assertEquals(len(self.client.events), 1)
self.assertEqual(len(self.client.events), 1)
event = self.client.events.pop(0)
self.assertEquals(event['culprit'], 'foo in bar')
self.assertEqual(event['culprit'], 'foo in bar')
def test_extra_data_as_string(self):
record = self.make_record('Message', extra={'data': 'foo'})
self.handler.emit(record)
self.assertEquals(len(self.client.events), 1)
self.assertEqual(len(self.client.events), 1)
event = self.client.events.pop(0)
self.assertEquals(event['extra']['data'], "'foo'")
self.assertEqual(event['extra']['data'], "u'foo'")
def test_tags(self):
record = self.make_record('Message', extra={'tags': {'foo': 'bar'}})
self.handler.emit(record)
self.assertEquals(len(self.client.events), 1)
self.assertEqual(len(self.client.events), 1)
event = self.client.events.pop(0)
assert event['tags'] == {'foo': 'bar'}
@ -165,7 +167,7 @@ class LoggingIntegrationTest(TestCase):
record = self.make_record('Message', extra={'tags': {'foo': 'bar'}}, exc_info=sys.exc_info())
self.handler.emit(record)
self.assertEquals(len(self.client.events), 1)
self.assertEqual(len(self.client.events), 1)
event = self.client.events.pop(0)
assert event['tags'] == {'foo': 'bar'}
@ -174,12 +176,12 @@ class LoggingHandlerTest(TestCase):
def test_client_arg(self):
client = TempStoreClient(include_paths=['tests'])
handler = SentryHandler(client)
self.assertEquals(handler.client, client)
self.assertEqual(handler.client, client)
def test_client_kwarg(self):
client = TempStoreClient(include_paths=['tests'])
handler = SentryHandler(client=client)
self.assertEquals(handler.client, client)
self.assertEqual(handler.client, client)
def test_args_as_servers_and_key(self):
handler = SentryHandler(['http://sentry.local/api/store/'], 'KEY')
@ -203,4 +205,4 @@ class LoggingHandlerTest(TestCase):
def test_logging_level_not_set(self):
handler = SentryHandler('http://public:secret@example.com/1')
self.assertEquals(handler.level, logging.NOTSET)
self.assertEqual(handler.level, logging.NOTSET)

3
tests/transport/tests.py
View File

@ -1,4 +1,5 @@
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from raven.utils.compat import TestCase
from raven.base import Client
@ -81,7 +82,7 @@ class TransportTest(TestCase):
expected = {
'project': '1',
'sentry.interfaces.Message': {'message': 'foo', 'params': ()},
'server_name': u'test_server',
'server_name': 'test_server',
'level': 40,
'checksum': 'acbd18db4cc2f85cedef654fccc4a4d8',
'modules': {},

69
tests/utils/encoding/tests.py
View File

@ -3,17 +3,20 @@
import uuid
from raven.utils import six
from raven.utils.compat import TestCase
from raven.utils.compat import TestCase, skipIf
from raven.utils.serializer import transform
class TransformTest(TestCase):
@skipIf(six.PY3, "Doesn't apply for python 3")
def test_incorrect_unicode(self):
x = 'רונית מגן'
result = transform(x)
assert result == "'רונית מגן'"
@skipIf(six.PY3, "Doesn't apply for python 3")
def test_correct_unicode(self):
# 'רונית מגן'
x = six.text_type('\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df')
@ -22,52 +25,56 @@ class TransformTest(TestCase):
assert result == six.text_type("u'\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df'")
def test_bad_string(self):
x = 'The following character causes problems: \xd4'
x = six.b('The following character causes problems: \xd4')
result = transform(x)
assert result == "<type 'str'>"
assert result == str(six.binary_type)
def test_float(self):
result = transform(13.0)
self.assertEquals(type(result), float)
self.assertEquals(result, 13.0)
self.assertEqual(type(result), float)
self.assertEqual(result, 13.0)
def test_bool(self):
result = transform(True)
self.assertEquals(type(result), bool)
self.assertEquals(result, True)
self.assertEqual(type(result), bool)
self.assertEqual(result, True)
def test_int_subclass(self):
class X(int):
pass
result = transform(X())
self.assertEquals(type(result), int)
self.assertEquals(result, 0)
self.assertEqual(type(result), int)
self.assertEqual(result, 0)
# def test_bad_string(self):
# x = 'The following character causes problems: \xd4'
# result = transform(x)
# self.assertEquals(result, '(Error decoding value)')
# self.assertEqual(result, '(Error decoding value)')
def test_dict_keys(self):
x = {'foo': 'bar'}
result = transform(x)
self.assertEquals(type(result), dict)
keys = result.keys()
self.assertEquals(len(keys), 1)
self.assertEqual(type(result), dict)
keys = list(result.keys())
self.assertEqual(len(keys), 1)
self.assertTrue(type(keys[0]), str)
self.assertEquals(keys[0], "'foo'")
if six.PY3:
self.assertEqual(keys[0], "u'foo'")
else:
self.assertEqual(keys[0], "'foo'")
@skipIf(six.PY3, "Doesn't apply for python 3")
def test_dict_keys_utf8_as_str(self):
x = {'רונית מגן': 'bar'}
result = transform(x)
self.assertEquals(type(result), dict)
keys = result.keys()
self.assertEquals(len(keys), 1)
self.assertEqual(type(result), dict)
keys = list(result.keys())
self.assertEqual(len(keys), 1)
assert keys[0] == "'רונית מגן'"
def test_dict_keys_utf8_as_unicode(self):
@ -77,7 +84,7 @@ class TransformTest(TestCase):
result = transform(x)
assert type(result) is dict
keys = result.keys()
keys = list(result.keys())
assert len(keys) == 1
assert keys[0] == six.text_type("u'\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df'")
@ -91,17 +98,17 @@ class TransformTest(TestCase):
x.append(x)
result = transform(x)
self.assertEquals(result, ('<...>',))
self.assertEqual(result, ('<...>',))
def test_custom_repr(self):
class Foo(object):
def __sentry__(self):
return 'example'
return six.u('example')
x = Foo()
result = transform(x)
self.assertEquals(result, "'example'")
self.assertEqual(result, "u'example'")
def test_broken_repr(self):
class Foo(object):
@ -111,25 +118,25 @@ class TransformTest(TestCase):
x = Foo()
result = transform(x)
self.assertEquals(result, "<class 'tests.utils.encoding.tests.Foo'>")
self.assertEqual(result, "<class 'tests.utils.encoding.tests.Foo'>")
def test_recursion_max_depth(self):
x = [[[[1]]]]
result = transform(x, max_depth=3)
self.assertEquals(result, ((("'[1]'",),),))
self.assertEqual(result, ((("u'[1]'",),),))
def test_list_max_length(self):
x = range(10)
x = list(range(10))
result = transform(x, list_max_length=3)
self.assertEquals(result, (0, 1, 2))
self.assertEqual(result, (0, 1, 2))
def test_dict_max_length(self):
x = dict((x, x) for x in xrange(10))
x = dict((x, x) for x in range(10))
result = transform(x, list_max_length=3)
self.assertEquals(type(x), dict)
self.assertEquals(len(result), 3)
self.assertEqual(type(x), dict)
self.assertEqual(len(result), 3)
def test_string_max_length(self):
x = '1234'
x = six.u('1234')
result = transform(x, string_max_length=3)
self.assertEquals(result, "'123'")
self.assertEqual(result, "u'123'")

5
tests/utils/stacks/tests.py
View File

@ -1,4 +1,5 @@
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from mock import Mock
from raven.utils.compat import TestCase
@ -61,6 +62,6 @@ class GetStackInfoTest(TestCase):
result = results[0]
assert 'vars' in result
assert result['vars'] == {
"'foo'": "'bar'",
"'biz'": "'baz'",
"u'foo'": "u'bar'",
"u'biz'": "u'baz'",
}