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.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_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_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_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_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): 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_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, ('<...>',))