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_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__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)