def test_make_resolve_partial__unicode(self):
"""
Test _make_resolve_partial(): that resolve_partial doesn't "double-decode" Unicode.
"""
renderer = Renderer()
renderer.partials = {'partial': 'foo'}
resolve_partial = renderer._make_resolve_partial()
self.assertEqual(resolve_partial("partial"), "foo")
# Now with a value that is already unicode.
renderer.partials = {'partial': 'foo'}
resolve_partial = renderer._make_resolve_partial()
# If the next line failed, we would get the following error:
# TypeError: decoding Unicode is not supported
self.assertEqual(resolve_partial("partial"), "foo")
def test_make_load_partial__unicode(self):
"""
Test _make_load_partial(): that load_partial doesn't "double-decode" Unicode.
"""
renderer = Renderer()
renderer.partials = {'partial': 'foo'}
load_partial = renderer._make_load_partial()
self.assertEqual(load_partial("partial"), "foo")
# Now with a value that is already unicode.
renderer.partials = {'partial': 'foo'}
load_partial = renderer._make_load_partial()
# If the next line failed, we would get the following error:
# TypeError: decoding Unicode is not supported
self.assertEqual(load_partial("partial"), "foo")
def test__resolve_partial__not_found__partials_dict(self):
"""
Check that resolve_partial returns the empty string when a template is not found.
"""
renderer = Renderer()
renderer.partials = {}
engine = renderer._make_render_engine()
resolve_partial = engine.resolve_partial
self.assertString(resolve_partial('foo'), '')
def test__resolve_partial__not_found__partials_dict(self):
"""
Check that resolve_partial returns the empty string when a template is not found.
"""
renderer = Renderer()
renderer.partials = {}
engine = renderer._make_render_engine()
resolve_partial = engine.resolve_partial
self.assertString(resolve_partial('foo'), '')
def test_make_resolve_partial(self):
"""
Test the _make_resolve_partial() method.
"""
renderer = Renderer()
renderer.partials = {'foo': 'bar'}
resolve_partial = renderer._make_resolve_partial()
actual = resolve_partial('foo')
self.assertEqual(actual, 'bar')
self.assertEqual(type(actual), str, "RenderEngine requires that "
"resolve_partial return unicode strings.")
def test_make_load_partial(self):
"""
Test the _make_load_partial() method.
"""
renderer = Renderer()
renderer.partials = {'foo': 'bar'}
load_partial = renderer._make_load_partial()
actual = load_partial('foo')
self.assertEqual(actual, 'bar')
self.assertEqual(type(actual), str, "RenderEngine requires that "
"load_partial return unicode strings.")
def test__load_partial__not_found__dict(self):
"""
Check that load_partial provides a nice message when a template is not found.
"""
renderer = Renderer()
renderer.partials = {}
engine = renderer._make_render_engine()
load_partial = engine.load_partial
# Include dict directly since str(dict) is different in Python 2 and 3:
# <type 'dict'> versus <class 'dict'>, respectively.
self.assertException(TemplateNotFoundError, "Name 'foo' not found in partials: %s" % dict,
load_partial, "foo")
def test__load_partial__not_found(self):
"""
Check that load_partial provides a nice message when a template is not found.
"""
renderer = Renderer()
renderer.partials = {}
engine = renderer._make_render_engine()
load_partial = engine.load_partial
try:
load_partial("foo")
raise Exception("Shouldn't get here")
except Exception, err:
self.assertEquals(str(err), "Partial not found with name: 'foo'")
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__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__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)
