def test_unicode__default_encoding(self): """ Test that the default_encoding attribute is respected. """ renderer = Renderer() s = "é" renderer.default_encoding = "ascii" self.assertRaises(UnicodeDecodeError, renderer.unicode, s) renderer.default_encoding = "utf-8" self.assertEquals(renderer.unicode(s), u"é")
def test_render__nonascii_template(self): """ Test passing a non-unicode template with non-ascii characters. """ renderer = Renderer() template = "déf" # Check that decode_errors and default_encoding are both respected. renderer.decode_errors = 'ignore' renderer.default_encoding = 'ascii' self.assertEquals(renderer.render(template), "df") renderer.default_encoding = 'utf_8' self.assertEquals(renderer.render(template), u"déf")
def test__literal__handles_unicode(self): """ Test that literal doesn't try to "double decode" unicode. """ renderer = Renderer() renderer.default_encoding = 'ascii' engine = renderer._make_render_engine() literal = engine.literal self.assertEquals(literal(u"foo"), "foo")
def test_unicode__decode_errors(self): """ Test that the decode_errors attribute is respected. """ renderer = Renderer() renderer.default_encoding = "ascii" s = "déf" renderer.decode_errors = "ignore" self.assertEquals(renderer.unicode(s), "df") renderer.decode_errors = "replace" # U+FFFD is the official Unicode replacement character. self.assertEquals(renderer.unicode(s), u'd\ufffd\ufffdf')
def test__literal__returns_unicode(self): """ Test that literal returns unicode (and not a subclass). """ renderer = Renderer() renderer.default_encoding = 'ascii' engine = renderer._make_render_engine() literal = engine.literal self.assertEquals(type(literal("foo")), unicode) class MyUnicode(unicode): pass s = MyUnicode("abc") self.assertEquals(type(s), MyUnicode) self.assertTrue(isinstance(s, unicode)) self.assertEquals(type(literal(s)), unicode)
def test__escape__returns_unicode(self): """ Test that literal returns unicode (and not a subclass). """ renderer = Renderer() renderer.default_encoding = 'ascii' engine = renderer._make_render_engine() escape = engine.escape self.assertEquals(type(escape("foo")), unicode) # Check that literal doesn't preserve unicode subclasses. class MyUnicode(unicode): pass s = MyUnicode("abc") self.assertEquals(type(s), MyUnicode) self.assertTrue(isinstance(s, unicode)) self.assertEquals(type(escape(s)), unicode)
def test__load_partial__returns_unicode(self): """ Check that load_partial returns unicode (and not a subclass). """ class MyUnicode(unicode): pass renderer = Renderer() renderer.default_encoding = 'ascii' renderer.partials = {'str': 'foo', 'subclass': MyUnicode('abc')} engine = renderer._make_render_engine() actual = engine.load_partial('str') self.assertEquals(actual, "foo") self.assertEquals(type(actual), unicode) # Check that unicode subclasses are not preserved. actual = engine.load_partial('subclass') self.assertEquals(actual, "abc") self.assertEquals(type(actual), unicode)