def test__resolve_partial__not_found(self): """ Check that resolve_partial returns the empty string when a template is not found. """ renderer = Renderer() engine = renderer._make_render_engine() resolve_partial = engine.resolve_partial self.assertString(resolve_partial('foo'), '')
def test__escape__uses_renderer_escape(self): """ Test that escape uses the renderer's escape function. """ renderer = Renderer() renderer.escape = lambda s: "**" + s engine = renderer._make_render_engine() escape = engine.escape self.assertEqual(escape("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__interpolate__uses_renderer_escape(self): """ Test that interpolate uses the renderer's interpolate function. """ renderer = Renderer() renderer.escape = lambda s: "**" + s engine = renderer._make_render_engine() interpolate = engine.interpolate self.assertEqual(interpolate("foo", '', None), "**foo")
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__load_partial__not_found__default(self): """ Check that load_partial provides a nice message when a template is not found. """ renderer = Renderer() engine = renderer._make_render_engine() load_partial = engine.load_partial self.assertException(TemplateNotFoundError, "File 'foo.mustache' not found in dirs: ['.']", load_partial, "foo")
def test__literal__uses_renderer_unicode(self): """ Test that literal uses the renderer's unicode function. """ renderer = Renderer() renderer.unicode = lambda s: s.upper() engine = renderer._make_render_engine() literal = engine.literal self.assertEquals(literal("foo"), "FOO")
def test__escape__uses_renderer_unicode(self): """ Test that escape uses the renderer's unicode function. """ renderer = Renderer() renderer.unicode = lambda s: s.upper() engine = renderer._make_render_engine() escape = engine.escape self.assertEquals(escape("foo"), "FOO")
def test__resolve_context(self): """ Check resolve_context(): default arguments. """ renderer = Renderer() engine = renderer._make_render_engine() stack = ContextStack({'foo': 'bar'}) self.assertEqual('bar', engine.resolve_context(stack, 'foo')) self.assertString('', engine.resolve_context(stack, 'missing'))
def test__escape__uses_renderer_unicode(self): """ Test that escape uses the renderer's unicode function. """ renderer = Renderer() renderer.str = mock_unicode engine = renderer._make_render_engine() escape = engine.escape b = "foo".encode('ascii') self.assertEqual(escape(b), "FOO")
def test__resolve_partial__not_found__missing_tags_strict(self): """ Check that resolve_partial provides a nice message when a template is not found. """ renderer = Renderer() renderer.missing_tags = 'strict' engine = renderer._make_render_engine() resolve_partial = engine.resolve_partial self.assertException(TemplateNotFoundError, "File 'foo.mustache' not found in dirs: ['.']", resolve_partial, "foo")
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__resolve_context__missing_tags_strict(self): """ Check resolve_context(): missing_tags 'strict'. """ renderer = Renderer() renderer.missing_tags = 'strict' engine = renderer._make_render_engine() stack = ContextStack({'foo': 'bar'}) self.assertEqual('bar', engine.resolve_context(stack, 'foo')) self.assertException(KeyNotFoundError, "Key 'missing' not found: first part", engine.resolve_context, stack, 'missing')
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__escape__has_access_to_original_unicode_subclass(self): """ Test that escape receives strings with the unicode subclass intact. """ renderer = Renderer() renderer.escape = lambda s: str(type(s).__name__) engine = renderer._make_render_engine() escape = engine.escape class MyUnicode(str): pass self.assertEqual(escape("foo".encode('ascii')), str.__name__) self.assertEqual(escape("foo"), str.__name__) self.assertEqual(escape(MyUnicode("foo")), MyUnicode.__name__)
def test__escape__has_access_to_original_unicode_subclass(self): """ Test that escape receives strings with the unicode subclass intact. """ renderer = Renderer() renderer.escape = lambda s: type(s).__name__ engine = renderer._make_render_engine() escape = engine.escape class MyUnicode(unicode): pass self.assertEquals(escape("foo"), "unicode") self.assertEquals(escape(u"foo"), "unicode") self.assertEquals(escape(MyUnicode("foo")), "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__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__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__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)