def test_unicode__string_encoding(self): """ Test that the string_encoding attribute is respected. """ renderer = Renderer() s = "é" renderer.string_encoding = "ascii" self.assertRaises(UnicodeDecodeError, renderer.unicode, s) renderer.string_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 string_encoding are both respected. renderer.decode_errors = 'ignore' renderer.string_encoding = 'ascii' self.assertEquals(renderer.render(template), "df") renderer.string_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.string_encoding = 'ascii' engine = renderer._make_render_engine() literal = engine.literal self.assertEqual(literal("foo"), "foo")
def test__literal__handles_unicode(self): """ Test that interpolate(..., 'literal') doesn't try to "double decode" unicode. """ renderer = Renderer() renderer.string_encoding = 'ascii' engine = renderer._make_render_engine() interpolate = engine.interpolate self.assertEqual(interpolate("foo", 'literal', None), "foo")
def test_unicode__decode_errors(self): """ Test that the decode_errors attribute is respected. """ renderer = Renderer() renderer.string_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__resolve_partial__returns_subclass(self): """Check that resolve_partial returns str (preserving any subclass).""" class MyUnicode(str): pass renderer = Renderer() renderer.string_encoding = 'ascii' renderer.partials = {'str': 'foo', 'subclass': MyUnicode('abc')} engine = renderer._make_render_engine() actual = engine.resolve_partial('str', None) self.assertEqual(actual, "foo") self.assertEqual(type(actual), str) # Check that unicode subclasses are not preserved. actual = engine.resolve_partial('subclass', None) self.assertEqual(actual, "abc") self.assertEqual(type(actual), MyUnicode)
def test__literal__returns_unicode(self): """ Test that literal returns unicode (and not a subclass). """ renderer = Renderer() renderer.string_encoding = 'ascii' engine = renderer._make_render_engine() literal = engine.literal self.assertEqual(type(literal("foo")), str) class MyUnicode(str): pass s = MyUnicode("abc") self.assertEqual(type(s), MyUnicode) self.assertTrue(isinstance(s, str)) self.assertEqual(type(literal(s)), str)
def test__literal__returns_unicode(self): """ Test that interpolate(..., 'literal') returns unicode (and not a subclass). """ renderer = Renderer() renderer.string_encoding = 'ascii' engine = renderer._make_render_engine() interpolate = engine.interpolate self.assertEqual(type(interpolate("foo", 'literal', None)), str) class MyUnicode(str): pass s = MyUnicode("abc") self.assertEqual(type(s), MyUnicode) self.assertTrue(isinstance(s, str)) self.assertEqual(type(interpolate(s, 'literal', None)), str)
def test__escape__returns_unicode(self): """ Test that literal returns unicode (and not a subclass). """ renderer = Renderer() renderer.string_encoding = 'ascii' engine = renderer._make_render_engine() escape = engine.escape self.assertEqual(type(escape("foo")), str) # Check that literal doesn't preserve unicode subclasses. class MyUnicode(str): pass s = MyUnicode("abc") self.assertEqual(type(s), MyUnicode) self.assertTrue(isinstance(s, str)) self.assertEqual(type(escape(s)), str)
def test__load_partial__returns_unicode(self): """ Check that load_partial returns unicode (and not a subclass). """ class MyUnicode(str): pass renderer = Renderer() renderer.string_encoding = 'ascii' renderer.partials = {'str': 'foo', 'subclass': MyUnicode('abc')} engine = renderer._make_render_engine() actual = engine.load_partial('str') self.assertEqual(actual, "foo") self.assertEqual(type(actual), str) # Check that unicode subclasses are not preserved. actual = engine.load_partial('subclass') self.assertEqual(actual, "abc") self.assertEqual(type(actual), str)