def test_bytes_max_length(self):
x = six.b('\xd7\xd7\xd7\xd7\xd7\xd7')
result = transform(x, string_max_length=1)
if six.PY3:
assert result == "b'\\xd7'"
else:
assert result == "'\\xd7'"
def test_basic(self, mytest_model):
from django.db.models.query import QuerySet
obj = QuerySet(model=mytest_model)
result = transform(obj)
assert isinstance(result, string_types)
assert result == '<QuerySet: model=MyTestModel>'
def test_basic(self):
from django.utils.functional import lazy
obj = lazy(lambda: 'bar', six.text_type)()
res = transform(obj)
expected = "'bar'" if six.PY3 else "u'bar'"
self.assertEquals(res, expected)
def test_basic(self):
from django.db.models.query import QuerySet
obj = QuerySet(model=MyTestModel)
result = transform(obj)
assert isinstance(result, string_types)
assert result == '<QuerySet: model=MyTestModel>'
def test_basic(self):
from django.utils.functional import lazy
obj = lazy(lambda: 'bar', text_type)()
res = transform(obj)
expected = "'bar'" if not PY2 else "u'bar'"
assert res == expected
def transform(value):
from raven.utils.serializer import transform
warnings.warn('You should switch to raven.utils.serializer.transform',
DeprecationWarning)
return transform(value)
def test_unicode_in_python2(self):
# 'רונית מגן'
x = six.u('\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df')
result = transform(x)
assert result == six.u(
"u'\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df'")
def test_basic(self):
from django.utils.functional import lazy
obj = lazy(lambda: 'bar', text_type)()
res = transform(obj)
expected = "'bar'" if not PY2 else "u'bar'"
assert res == expected
def test_basic(self):
from django.db.models.query import QuerySet
obj = QuerySet(model=TestModel)
result = transform(obj)
self.assertTrue(isinstance(result, six.string_types))
self.assertEquals(result, '<QuerySet: model=TestModel>')
def test_basic(self):
from django.utils.functional import lazy
obj = lazy(lambda: 'bar', six.text_type)()
res = transform(obj)
expected = "'bar'" if six.PY3 else "u'bar'"
self.assertEquals(res, expected)
def test_int_subclass(self):
class X(int):
pass
result = transform(X())
self.assertEqual(type(result), int)
self.assertEqual(result, 0)
def test_int_subclass(self):
class X(int):
pass
result = transform(X())
self.assertEqual(type(result), int)
self.assertEqual(result, 0)
def test_basic(self):
from django.db.models.query import QuerySet
obj = QuerySet(model=TestModel)
result = transform(obj)
self.assertTrue(isinstance(result, basestring))
self.assertEquals(result, u'<QuerySet: model=TestModel>')
def test_recursion_max_depth(self):
x = [[[[1]]]]
result = transform(x, max_depth=3)
if six.PY3:
expected = ((("'[1]'",),),)
else:
expected = ((("u'[1]'",),),)
self.assertEqual(result, expected)
def test_dict_keys_utf8_as_str(self):
x = {'רונית מגן': 'bar'}
result = transform(x)
self.assertEqual(type(result), dict)
keys = list(result.keys())
self.assertEqual(len(keys), 1)
assert keys[0] == "'רונית מגן'"
def test_dict_keys_utf8_as_str(self):
x = {'רונית מגן': 'bar'}
result = transform(x)
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):
x = {'רונית מגן': 'bar'}
result = transform(x)
keys = list(result.keys())
self.assertEquals(len(keys), 1)
self.assertTrue(type(keys[0]), str)
self.assertEquals(keys[0], 'רונית מגן')
def test_recurse_exception(self):
class NonAsciiRepr(object):
def __repr__(self):
return six.b('中文')
x = [NonAsciiRepr()]
result = transform(x, max_depth=1)
self.assertEqual(json.dumps(result), six.b('["<class \'tests.utils.encoding.tests.NonAsciiRepr\'>"]'))
def test_dict_keys_utf8_as_unicode(self):
x = {u'רונית מגן': 'bar'}
result = transform(x)
keys = result.keys()
self.assertEquals(len(keys), 1)
self.assertTrue(type(keys[0]), str)
self.assertEquals(keys[0], 'רונית מגן')
def test_real_gettext_lazy(self):
d = {
six.text_type('lazy_translation'):
gettext_lazy(six.text_type('testing'))
}
key = "'lazy_translation'" if six.PY3 else "u'lazy_translation'"
value = "'testing'" if six.PY3 else "u'testing'"
assert transform(d) == {key: value}
def test_dict_keys(self):
x = {u'foo': 'bar'}
result = transform(x)
self.assertEquals(type(result), dict)
keys = result.keys()
self.assertEquals(len(keys), 1)
self.assertTrue(type(keys[0]), str)
self.assertEquals(keys[0], 'foo')
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.assertTrue(type(keys[0]), str)
self.assertEquals(keys[0], 'רונית מגן')
def test_custom_repr(self):
class Foo(object):
def __sentry__(self):
return 'example'
x = Foo()
result = transform(x)
self.assertEquals(result, 'example')
def test_dict_keys_utf8_as_str(self):
x = {'רונית מגן': 'bar'}
result = transform(x)
self.assertEquals(type(result), dict)
keys = list(result.keys())
self.assertEquals(len(keys), 1)
self.assertTrue(type(keys[0]), str)
self.assertEquals(keys[0], 'רונית מגן')
def test_broken_repr(self):
class Foo(object):
def __repr__(self):
raise ValueError
x = Foo()
result = transform(x)
self.assertEqual(result, "<class 'tests.utils.encoding.tests.Foo'>")
def test_dict_keys(self):
x = {u'foo': 'bar'}
result = transform(x)
self.assertEquals(type(result), dict)
keys = result.keys()
self.assertEquals(len(keys), 1)
self.assertTrue(type(keys[0]), str)
self.assertEquals(keys[0], 'foo')
def test_broken_repr(self):
class Foo(object):
def __repr__(self):
raise ValueError
x = Foo()
result = transform(x)
self.assertEquals(result, u"<class 'tests.utils.encoding.tests.Foo'>")
def test_custom_repr(self):
class Foo(object):
def __sentry__(self):
return 'example'
x = Foo()
result = transform(x)
self.assertEquals(result, 'example')
def test_dict_keys(self):
x = {'foo': 'bar'}
result = transform(x)
self.assertEqual(type(result), dict)
keys = list(result.keys())
self.assertEqual(len(keys), 1)
self.assertTrue(type(keys[0]), str)
self.assertEqual(keys[0], "'foo'")
def test_custom_repr(self):
class Foo(object):
def __sentry__(self):
return six.u('example')
x = Foo()
result = transform(x)
self.assertEqual(result, "u'example'")
def test_dict_keys_utf8_as_unicode(self):
x = {
six.text_type('\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df'): 'bar'
}
result = transform(x)
assert type(result) is dict
keys = list(result.keys())
assert len(keys) == 1
assert keys[0] == six.text_type("u'\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df'")
def shorten(var, list_length=50, string_length=200):
var = transform(var)
if isinstance(var, basestring) and len(var) > string_length:
var = var[:string_length] + '...'
elif isinstance(var, (list, tuple, set, frozenset)) and len(var) > list_length:
# TODO: we should write a real API for storing some metadata with vars when
# we get around to doing ref storage
# TODO: when we finish the above, we should also implement this for dicts
var = list(var)[:list_length] + ['...', '(%d more elements)' % (len(var) - list_length,)]
return var
def test_handles_gettext_lazy(self):
from django.utils.functional import lazy
def fake_gettext(to_translate):
return "Igpay Atinlay"
fake_gettext_lazy = lazy(fake_gettext, six.text_type)
result = transform(fake_gettext_lazy("something"))
self.assertTrue(isinstance(result, six.string_types))
self.assertEquals(result, "u'Igpay Atinlay'")
def test_handles_gettext_lazy(self):
from django.utils.functional import lazy
def fake_gettext(to_translate):
return u'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')
def test_handles_gettext_lazy(self):
from django.utils.functional import lazy
def fake_gettext(to_translate):
return 'Igpay Atinlay'
fake_gettext_lazy = lazy(fake_gettext, str)
result = transform(fake_gettext_lazy("something"))
self.assertTrue(isinstance(result, str))
self.assertEquals(result, 'Igpay Atinlay')
def test_broken_repr(self):
class Foo(object):
def __repr__(self):
raise ValueError
result = transform(Foo())
expected = "<class 'tests.utils.encoding.tests.Foo'>"
import sys
if sys.version_info[0] == 3 and sys.version_info[1] >= 3:
expected = "<class 'tests.utils.encoding.tests.TransformTest.test_broken_repr.<locals>.Foo'>"
assert result == expected
def test_handles_gettext_lazy(self):
from django.utils.functional import lazy
def fake_gettext(to_translate):
return 'Igpay Atinlay'
fake_gettext_lazy = lazy(fake_gettext, six.text_type)
result = transform(fake_gettext_lazy("something"))
self.assertTrue(isinstance(result, six.string_types))
expected = "'Igpay Atinlay'" if six.PY3 else "u'Igpay Atinlay'"
self.assertEquals(result, expected)
def test_broken_repr(self):
class Foo(object):
def __repr__(self):
raise ValueError
x = Foo()
result = transform(x)
if six.PY3:
self.assertEqual(result, "<class 'tests.utils.encoding.tests.TransformTest.test_broken_repr.<locals>.Foo'>")
else:
self.assertEqual(result, "<class 'tests.utils.encoding.tests.Foo'>")
def test_handles_gettext_lazy(self):
from django.utils.functional import lazy
def fake_gettext(to_translate):
return 'Igpay Atinlay'
fake_gettext_lazy = lazy(fake_gettext, text_type)
result = transform(fake_gettext_lazy("something"))
assert isinstance(result, string_types)
expected = "'Igpay Atinlay'" if not PY2 else "u'Igpay Atinlay'"
assert result == expected
def test_dict_keys_utf8_as_unicode(self):
x = {six.text_type("\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df"): "bar"}
result = transform(x)
assert type(result) is dict
keys = list(result.keys())
assert len(keys) == 1
if six.PY3:
expected = "'\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df'"
else:
expected = "u'\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df'"
assert keys[0] == expected
def test_handles_gettext_lazy(self):
from django.utils.functional import lazy
def fake_gettext(to_translate):
return 'Igpay Atinlay'
fake_gettext_lazy = lazy(fake_gettext, text_type)
result = transform(fake_gettext_lazy("something"))
assert isinstance(result, string_types)
expected = "'Igpay Atinlay'" if not PY2 else "u'Igpay Atinlay'"
assert result == expected
def test_handles_gettext_lazy(self):
import pickle
from django.utils.functional import lazy
def fake_gettext(to_translate):
return u'Igpay Atinlay'
fake_gettext_lazy = lazy(fake_gettext, str)
self.assertEquals(
pickle.loads(pickle.dumps(
transform(fake_gettext_lazy("something")))),
u'Igpay Atinlay')
def shorten(var, list_length=50, string_length=200):
var = transform(var)
if isinstance(var, str) and len(var) > string_length:
var = var[:string_length] + '...'
elif isinstance(var,
(list, tuple, set, frozenset)) and len(var) > list_length:
# TODO: we should write a real API for storing some metadata with vars when
# we get around to doing ref storage
# TODO: when we finish the above, we should also implement this for dicts
var = list(var)[:list_length] + [
'...', '(%d more elements)' % (len(var) - list_length, )
]
return var
def test_custom_repr(self):
class Foo(object):
def __sentry__(self):
return six.u('example')
x = Foo()
result = transform(x)
if six.PY3:
expected = "'example'"
else:
expected = "u'example'"
self.assertEqual(result, expected)
def test_dict_keys_utf8_as_unicode(self):
x = {
six.text_type('\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df'): 'bar'
}
result = transform(x)
assert type(result) is dict
keys = list(result.keys())
assert len(keys) == 1
if six.PY3:
expected = "'\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df'"
else:
expected = "u'\u05e8\u05d5\u05e0\u05d9\u05ea \u05de\u05d2\u05df'"
assert keys[0] == expected
def transform(self, data):
return transform(data,
list_max_length=self.list_max_length,
string_max_length=self.string_max_length)
def transform(self, data):
return transform(
data, list_max_length=self.list_max_length,
string_max_length=self.string_max_length)
def test_bool(self):
result = transform(True)
self.assertEqual(type(result), bool)
self.assertEqual(result, True)
def test_basic(self, mytest_model):
instance = mytest_model()
result = transform(instance)
assert isinstance(result, string_types)
assert result == '<MyTestModel: MyTestModel object>'
def get_stack_info(frames):
"""
Given a list of frames, returns a list of stack information
dictionary objects that are JSON-ready.
We have to be careful here as certain implementations of the
_Frame class do not contain the nescesary data to lookup all
of the information we want.
"""
results = []
for frame_info in frames:
# Old, terrible API
if isinstance(frame_info, (list, tuple)):
frame, lineno = frame_info
else:
frame = frame_info
lineno = frame_info.f_lineno
# Support hidden frames
f_locals = getattr(frame, 'f_locals', {})
if _getitem_from_frame(f_locals, '__traceback_hide__'):
continue
f_globals = getattr(frame, 'f_globals', {})
loader = _getitem_from_frame(f_globals, '__loader__')
module_name = _getitem_from_frame(f_globals, '__name__')
f_code = getattr(frame, 'f_code', None)
if f_code:
abs_path = frame.f_code.co_filename
function = frame.f_code.co_name
else:
abs_path = None
function = None
if lineno:
lineno -= 1
if lineno is not None and abs_path:
pre_context, context_line, post_context = get_lines_from_file(
abs_path, lineno, 3, loader, module_name)
else:
pre_context, context_line, post_context = [], None, []
# Try to pull a relative file path
# This changes /foo/site-packages/baz/bar.py into baz/bar.py
try:
base_filename = sys.modules[module_name.split('.', 1)[0]].__file__
filename = abs_path.split(base_filename.rsplit('/', 2)[0],
1)[-1][1:]
except:
filename = abs_path
if not filename:
filename = abs_path
if f_locals is not None and not isinstance(f_locals, dict):
# XXX: Genshi (and maybe others) have broken implementations of
# f_locals that are not actually dictionaries
try:
f_locals = to_dict(f_locals)
except Exception:
f_locals = '<invalid local scope>'
frame_result = {
'abs_path': abs_path,
'filename': filename,
'module': module_name,
'function': function,
'lineno': lineno + 1,
'vars': transform(f_locals),
}
if context_line:
frame_result.update({
'pre_context': pre_context,
'context_line': context_line,
'post_context': post_context,
})
results.append(frame_result)
return results
def test_bool(self):
result = transform(True)
self.assertEqual(type(result), bool)
self.assertEqual(result, True)
def test_basic(self):
instance = TestModel()
result = transform(instance)
self.assertTrue(isinstance(result, six.string_types))
self.assertEquals(result, '<TestModel: TestModel object>')
def test_uuid(self):
x = uuid.uuid4()
result = transform(x)
assert result == repr(x)
def test_recursive(self):
x = []
x.append(x)
result = transform(x)
self.assertEqual(result, ('<...>',))
